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) { trace("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 = VarSub(&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 = VarSub(&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 = VarSub(&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 = VarMul(&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 = VarMul(&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 = VarAdd(&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 = VarAdd(&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 = VarAdd(&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 void test_VarCat(void)
5330 {
5331     LCID lcid;
5332     VARIANT left, right, result, expected, expected_broken;
5333     static const WCHAR sz34[] = {'3','4','\0'};
5334     static const WCHAR sz1234[] = {'1','2','3','4','\0'};
5335     static const WCHAR date_sz12[] = {'9','/','3','0','/','1','9','8','0','1','2','\0'};
5336     static const WCHAR date_sz12_broken[] = {'9','/','3','0','/','8','0','1','2','\0'};
5337     static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
5338     static const WCHAR sz12_date_broken[] = {'1','2','9','/','3','0','/','8','0','\0'};
5339     static const WCHAR sz_empty[] = {'\0'};
5340     TCHAR orig_date_format[128];
5341     VARTYPE leftvt, rightvt, resultvt;
5342     HRESULT hres;
5343     HRESULT expected_error_num;
5344
5345     /* Set date format for testing */
5346     lcid = LOCALE_USER_DEFAULT;
5347     GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
5348     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
5349
5350     VariantInit(&left);
5351     VariantInit(&right);
5352     VariantInit(&result);
5353     VariantInit(&expected);
5354
5355     /* Check expected types for all combinations */
5356     for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5357     {
5358
5359         SKIPTESTS(leftvt);
5360
5361         /* Check if we need/have support for I8 and/or UI8 */
5362         if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5363             continue;
5364
5365         for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5366         {
5367
5368             SKIPTESTS(rightvt);
5369             expected_error_num = S_OK;
5370             resultvt = VT_EMPTY;
5371
5372             if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5373                 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN  ||
5374                 leftvt == VT_RECORD || rightvt == VT_RECORD  ||
5375                 leftvt == 15 || rightvt == 15 /* Undefined type */)
5376                 continue;
5377
5378             /* Check if we need/have support for I8 and/or UI8 */
5379             if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5380                 continue;
5381
5382             if (leftvt == VT_NULL && rightvt == VT_NULL)
5383                 resultvt = VT_NULL;
5384             else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
5385                 rightvt == VT_DATE || rightvt == VT_DECIMAL))
5386                 expected_error_num = DISP_E_TYPEMISMATCH;
5387             else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
5388                 leftvt == VT_R4 || leftvt == VT_R8 ||
5389                 leftvt == VT_CY || leftvt == VT_BOOL ||
5390                 leftvt == VT_BSTR || leftvt == VT_I1 ||
5391                 leftvt == VT_UI1 || leftvt == VT_UI2 ||
5392                 leftvt == VT_UI4 || leftvt == VT_I8 ||
5393                 leftvt == VT_UI8 || leftvt == VT_INT ||
5394                 leftvt == VT_UINT || leftvt == VT_EMPTY ||
5395                 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
5396                 leftvt == VT_DATE)
5397                 &&
5398                 (rightvt == VT_I2 || rightvt == VT_I4 ||
5399                 rightvt == VT_R4 || rightvt == VT_R8 ||
5400                 rightvt == VT_CY || rightvt == VT_BOOL ||
5401                 rightvt == VT_BSTR || rightvt == VT_I1 ||
5402                 rightvt == VT_UI1 || rightvt == VT_UI2 ||
5403                 rightvt == VT_UI4 || rightvt == VT_I8 ||
5404                 rightvt == VT_UI8 || rightvt == VT_INT ||
5405                 rightvt == VT_UINT || rightvt == VT_EMPTY ||
5406                 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
5407                 rightvt == VT_DATE))
5408                 resultvt = VT_BSTR;
5409             else if (rightvt == VT_ERROR && leftvt < VT_VOID)
5410                 expected_error_num = DISP_E_TYPEMISMATCH;
5411             else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
5412                 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
5413                 expected_error_num = DISP_E_TYPEMISMATCH;
5414             else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
5415                 rightvt == VT_DECIMAL)
5416                 expected_error_num = DISP_E_BADVARTYPE;
5417             else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
5418                 expected_error_num = DISP_E_TYPEMISMATCH;
5419             else if (leftvt == VT_VARIANT)
5420                 expected_error_num = DISP_E_TYPEMISMATCH;
5421             else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
5422                 leftvt == VT_NULL || leftvt ==  VT_I2 ||
5423                 leftvt == VT_I4 || leftvt == VT_R4 ||
5424                 leftvt == VT_R8 || leftvt == VT_CY ||
5425                 leftvt == VT_DATE || leftvt == VT_BSTR ||
5426                 leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
5427                 leftvt == VT_I1 || leftvt == VT_UI1 ||
5428                 leftvt == VT_UI2 || leftvt == VT_UI4 ||
5429                 leftvt == VT_I8 || leftvt == VT_UI8 ||
5430                 leftvt == VT_INT || leftvt == VT_UINT
5431                 ))
5432                 expected_error_num = DISP_E_TYPEMISMATCH;
5433             else
5434                 expected_error_num = DISP_E_BADVARTYPE;
5435
5436             V_VT(&left) = leftvt;
5437             V_VT(&right) = rightvt;
5438
5439             switch (leftvt) {
5440             case VT_BSTR:
5441                 V_BSTR(&left) = SysAllocString(sz_empty); break;
5442             case VT_DATE:
5443                 V_DATE(&left) = 0.0; break;
5444             case VT_DECIMAL:
5445                 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
5446             default:
5447                 V_I8(&left) = 0;
5448             }
5449
5450             switch (rightvt) {
5451             case VT_BSTR:
5452                 V_BSTR(&right) = SysAllocString(sz_empty); break;
5453             case VT_DATE:
5454                 V_DATE(&right) = 0.0; break;
5455             case VT_DECIMAL:
5456                 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
5457             default:
5458                 V_I8(&right) = 0;
5459             }
5460
5461             hres = VarCat(&left, &right, &result);
5462
5463             /* Determine the error code for the vt combination */
5464             ok(hres == expected_error_num,
5465                 "VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
5466                 leftvt, rightvt, expected_error_num, hres);
5467
5468             /* Check types are correct */
5469             ok(V_VT(&result) == resultvt,
5470                 "VarCat: %d, %d: expected vt %d, got vt %d\n",
5471                 leftvt, rightvt, resultvt, V_VT(&result));
5472
5473             VariantClear(&left);
5474             VariantClear(&right);
5475             VariantClear(&result);
5476         }
5477     }
5478
5479     /* Running single comparison tests to compare outputs */
5480
5481     /* Test concat strings */
5482     V_VT(&left) = VT_BSTR;
5483     V_VT(&right) = VT_BSTR;
5484     V_VT(&expected) = VT_BSTR;
5485     V_BSTR(&left) = SysAllocString(sz12);
5486     V_BSTR(&right) = SysAllocString(sz34);
5487     V_BSTR(&expected) = SysAllocString(sz1234);
5488     hres = VarCat(&left,&right,&result);
5489     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5490     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5491         "VarCat: VT_BSTR concat with VT_BSTR failed to return correct result\n");
5492
5493     VariantClear(&left);
5494     VariantClear(&right);
5495     VariantClear(&result);
5496
5497     /* Test if expression is VT_ERROR */
5498     V_VT(&left) = VT_ERROR;
5499     V_VT(&right) = VT_BSTR;
5500     V_BSTR(&right) = SysAllocString(sz1234);
5501     hres = VarCat(&left,&right,&result);
5502     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5503     ok(V_VT(&result) == VT_EMPTY,
5504         "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
5505
5506     VariantClear(&left);
5507     VariantClear(&right);
5508     VariantClear(&result);
5509
5510     V_VT(&left) = VT_BSTR;
5511     V_VT(&right) = VT_ERROR;
5512     V_BSTR(&left) = SysAllocString(sz1234);
5513     hres = VarCat(&left,&right,&result);
5514     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5515     ok(V_VT(&result) == VT_EMPTY,
5516         "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
5517
5518     VariantClear(&left);
5519     VariantClear(&right);
5520     VariantClear(&result);
5521     VariantClear(&expected);
5522
5523     /* Test combining boolean with number */
5524     V_VT(&left) = VT_INT;
5525     V_VT(&right) = VT_BOOL;
5526     V_VT(&expected) = VT_BSTR;
5527     V_INT(&left) = 12;
5528     V_BOOL(&right) = TRUE;
5529     V_BSTR(&expected) = SysAllocString(sz12_true);
5530     hres = VarCat(&left,&right,&result);
5531     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5532     hres = VarCmp(&result,&expected,lcid,0);
5533     ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5534         hres, variantstr(&result), variantstr(&expected));
5535
5536     VariantClear(&left);
5537     VariantClear(&right);
5538     VariantClear(&result);
5539     VariantClear(&expected);
5540
5541     V_VT(&left) = VT_INT;
5542     V_VT(&right) = VT_BOOL;
5543     V_VT(&expected) = VT_BSTR;
5544     V_INT(&left) = 12;
5545     V_BOOL(&right) = FALSE;
5546     V_BSTR(&expected) = SysAllocString(sz12_false);
5547     hres = VarCat(&left,&right,&result);
5548     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5549     hres = VarCmp(&result,&expected,lcid,0);
5550     ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5551         hres, variantstr(&result), variantstr(&expected));
5552
5553     VariantClear(&left);
5554     VariantClear(&right);
5555     VariantClear(&result);
5556     VariantClear(&expected);
5557
5558     /* Test when both expressions are numeric */
5559     V_VT(&left) = VT_INT;
5560     V_VT(&right) = VT_INT;
5561     V_VT(&expected) = VT_BSTR;
5562     V_INT(&left)  = 12;
5563     V_INT(&right) = 34;
5564     V_BSTR(&expected) = SysAllocString(sz1234);
5565     hres = VarCat(&left,&right,&result);
5566     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5567     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5568         "VarCat: NUMBER concat with NUMBER returned incorrect result\n");
5569
5570     VariantClear(&left);
5571     VariantClear(&right);
5572     VariantClear(&result);
5573
5574     /* Test if one expression is numeric and the other is a string */
5575     V_VT(&left) = VT_INT;
5576     V_VT(&right) = VT_BSTR;
5577     V_INT(&left) = 12;
5578     V_BSTR(&right) = SysAllocString(sz34);
5579     hres = VarCat(&left,&right,&result);
5580     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5581     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5582         "VarCat: NUMBER concat with VT_BSTR, incorrect result\n");
5583
5584     VariantClear(&left);
5585     VariantClear(&right);
5586     VariantClear(&result);
5587
5588     V_VT(&left) = VT_BSTR;
5589     V_VT(&right) = VT_INT;
5590     V_BSTR(&left) = SysAllocString(sz12);
5591     V_INT(&right) = 34;
5592     hres = VarCat(&left,&right,&result);
5593     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5594     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5595         "VarCat: VT_BSTR concat with NUMBER, incorrect result\n");
5596
5597     VariantClear(&left);
5598     VariantClear(&right);
5599     VariantClear(&result);
5600     VariantClear(&expected);
5601
5602     /* Test concat dates with strings */
5603     V_VT(&left) = VT_BSTR;
5604     V_VT(&right) = VT_DATE;
5605     V_VT(&expected) = VT_BSTR;
5606     V_VT(&expected_broken) = VT_BSTR;
5607     V_BSTR(&left) = SysAllocString(sz12);
5608     V_DATE(&right) = 29494.0;
5609     V_BSTR(&expected)= SysAllocString(sz12_date);
5610     V_BSTR(&expected_broken)= SysAllocString(sz12_date_broken);
5611     hres = VarCat(&left,&right,&result);
5612     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5613     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5614         broken(VarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5615         "VarCat: VT_BSTR concat with VT_DATE returned incorrect result\n");
5616
5617     VariantClear(&left);
5618     VariantClear(&right);
5619     VariantClear(&result);
5620     VariantClear(&expected);
5621     VariantClear(&expected_broken);
5622
5623     V_VT(&left) = VT_DATE;
5624     V_VT(&right) = VT_BSTR;
5625     V_VT(&expected) = VT_BSTR;
5626     V_VT(&expected_broken) = VT_BSTR;
5627     V_DATE(&left) = 29494.0;
5628     V_BSTR(&right) = SysAllocString(sz12);
5629     V_BSTR(&expected)= SysAllocString(date_sz12);
5630     V_BSTR(&expected_broken)= SysAllocString(date_sz12_broken);
5631     hres = VarCat(&left,&right,&result);
5632     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5633     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5634         broken(VarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5635         "VarCat: VT_DATE concat with VT_BSTR returned incorrect result\n");
5636
5637     VariantClear(&left);
5638     VariantClear(&right);
5639     VariantClear(&result);
5640     VariantClear(&expected);
5641     VariantClear(&expected_broken);
5642
5643     /* Test of both expressions are empty */
5644     V_VT(&left) = VT_BSTR;
5645     V_VT(&right) = VT_BSTR;
5646     V_VT(&expected) = VT_BSTR;
5647     V_BSTR(&left) = SysAllocString(sz_empty);
5648     V_BSTR(&right) = SysAllocString(sz_empty);
5649     V_BSTR(&expected)= SysAllocString(sz_empty);
5650     hres = VarCat(&left,&right,&result);
5651     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5652     ok(VarCmp(&result,&left,lcid,0) == VARCMP_EQ,
5653         "VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
5654
5655     /* Restore original date format settings */
5656     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
5657
5658     VariantClear(&left);
5659     VariantClear(&right);
5660     VariantClear(&result);
5661     VariantClear(&expected);
5662
5663     /* Test boolean conversion */
5664     V_VT(&left) = VT_BOOL;
5665     V_BOOL(&left) = VARIANT_TRUE;
5666     V_VT(&right) = VT_BSTR;
5667     V_BSTR(&right) = SysAllocStringLen(NULL,0);
5668     hres = VarCat(&left, &right, &result);
5669     ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5670     if(!strcmp_wa(V_BSTR(&result), "True")) {
5671         V_VT(&right) = VT_BOOL;
5672         V_BOOL(&right) = 100;
5673         hres = VarCat(&left, &right, &result);
5674         ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5675         test_bstr_var(&result, "TrueTrue");
5676         VariantClear(&result);
5677
5678         V_BOOL(&right) = VARIANT_FALSE;
5679         hres = VarCat(&left, &right, &result);
5680         ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5681         test_bstr_var(&result, "TrueFalse");
5682         VariantClear(&result);
5683     }else {
5684         skip("Got %s as True, assuming non-English locale\n", wine_dbgstr_w(V_BSTR(&result)));
5685     }
5686 }
5687
5688 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
5689
5690 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
5691         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5692         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5693         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5694         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5695
5696 #define VARANDCY(vt1,val1,val2,rvt,rval)                 \
5697         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5698         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5699         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5700         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5701
5702 /* Skip any type that is not defined or produces an error for every case */
5703 #define SKIPTESTAND(a)                                \
5704         if (a == VT_ERROR || a == VT_VARIANT ||       \
5705             a == VT_DISPATCH || a == VT_UNKNOWN ||    \
5706             a > VT_UINT || a == 15 /*not defined*/)   \
5707             continue
5708
5709 static void test_VarAnd(void)
5710 {
5711     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5712     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5713     VARIANT left, right, exp, result;
5714     BSTR false_str, true_str;
5715     VARTYPE i;
5716     HRESULT hres;
5717
5718     true_str = SysAllocString(szTrue);
5719     false_str = SysAllocString(szFalse);
5720
5721     CHECKPTR(VarAnd);
5722
5723     /* Test all possible flag/vt combinations & the resulting vt type */
5724     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5725     {
5726         VARTYPE leftvt, rightvt, resvt;
5727
5728         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5729         {
5730             SKIPTESTAND(leftvt);
5731
5732             /* Check if we need/have support for I8 and/or UI8 */
5733             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5734                 continue;
5735
5736             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5737             {
5738                 BOOL bFail = FALSE;
5739                 SKIPTESTAND(rightvt);
5740
5741                 /* Check if we need/have support for I8 and/or UI8 */
5742                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5743                     continue;
5744
5745                 memset(&left, 0, sizeof(left));
5746                 memset(&right, 0, sizeof(right));
5747                 V_VT(&left) = leftvt | ExtraFlags[i];
5748                 V_VT(&right) = rightvt | ExtraFlags[i];
5749                 V_VT(&result) = VT_EMPTY;
5750                 resvt = VT_EMPTY;
5751                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
5752                     V_BSTR(&left) = true_str;
5753                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
5754                     V_BSTR(&right) = true_str;
5755
5756                 /* Native VarAnd always returns an error when using extra
5757                  * flags or if the variant combination is I8 and INT.
5758                  */
5759                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5760                     (leftvt == VT_INT && rightvt == VT_I8) ||
5761                     ExtraFlags[i] != 0)
5762                     bFail = TRUE;
5763
5764                 /* Determine return type */
5765                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5766                     resvt = VT_I8;
5767                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5768                     leftvt == VT_UINT || rightvt == VT_UINT ||
5769                     leftvt == VT_INT || rightvt == VT_INT ||
5770                     leftvt == VT_UINT || rightvt == VT_UINT ||
5771                     leftvt == VT_R4 || rightvt == VT_R4 ||
5772                     leftvt == VT_R8 || rightvt == VT_R8 ||
5773                     leftvt == VT_CY || rightvt == VT_CY ||
5774                     leftvt == VT_DATE || rightvt == VT_DATE ||
5775                     leftvt == VT_I1 || rightvt == VT_I1 ||
5776                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5777                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5778                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5779                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5780                     resvt = VT_I4;
5781                 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
5782                     leftvt == VT_I2 || rightvt == VT_I2 ||
5783                     leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5784                     if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
5785                         (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5786                         (leftvt == VT_UI1 && rightvt == VT_UI1))
5787                         resvt = VT_UI1;
5788                     else
5789                         resvt = VT_I2;
5790                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5791                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
5792                     resvt = VT_BOOL;
5793                 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
5794                     leftvt == VT_BSTR || rightvt == VT_BSTR)
5795                     resvt = VT_NULL;
5796                 else
5797                     bFail = TRUE;
5798
5799                 hres = pVarAnd(&left, &right, &result);
5800
5801                 /* Check expected HRESULT and if result variant type is correct */
5802                 if (bFail)
5803                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
5804                         "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
5805                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
5806                         vtstr(V_VT(&result)), hres);
5807                 else
5808                     ok (hres == S_OK && resvt == V_VT(&result),
5809                         "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
5810                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
5811                         S_OK, vtstr(V_VT(&result)), hres);
5812             }
5813         }
5814     }
5815
5816     /*
5817      * Test returned values. Since we know the returned type is correct
5818      * and that we handle all combinations of invalid types, just check
5819      * that good type combinations produce the desired value.
5820      * FIXME: Test VT_DECIMAL
5821      */
5822     VARAND(EMPTY,0,EMPTY,0,I2,0);
5823     VARAND(EMPTY,1,EMPTY,0,I2,0);
5824     VARAND(EMPTY,1,EMPTY,1,I2,0);
5825     VARAND(EMPTY,0,NULL,0,I2,0);
5826     VARAND(EMPTY,1,NULL,0,I2,0);
5827     VARAND(EMPTY,1,NULL,1,I2,0);
5828     VARAND(EMPTY,0,I1,0,I4,0);
5829     VARAND(EMPTY,0,I1,1,I4,0);
5830     VARAND(EMPTY,1,I1,1,I4,0);
5831     VARAND(EMPTY,0,UI1,0,I2,0);
5832     VARAND(EMPTY,0,UI1,1,I2,0);
5833     VARAND(EMPTY,1,UI1,1,I2,0);
5834     VARAND(EMPTY,0,I2,0,I2,0);
5835     VARAND(EMPTY,0,I2,1,I2,0);
5836     VARAND(EMPTY,1,I2,1,I2,0);
5837     VARAND(EMPTY,0,UI2,0,I4,0);
5838     VARAND(EMPTY,0,UI2,1,I4,0);
5839     VARAND(EMPTY,1,UI2,1,I4,0);
5840     VARAND(EMPTY,0,I4,0,I4,0);
5841     VARAND(EMPTY,0,I4,1,I4,0);
5842     VARAND(EMPTY,1,I4,1,I4,0);
5843     VARAND(EMPTY,0,UI4,0,I4,0);
5844     VARAND(EMPTY,0,UI4,1,I4,0);
5845     VARAND(EMPTY,1,UI4,1,I4,0);
5846     if (HAVE_OLEAUT32_I8)
5847     {
5848         VARAND(EMPTY,0,I8,0,I8,0);
5849         VARAND(EMPTY,0,I8,1,I8,0);
5850         VARAND(EMPTY,1,I8,1,I8,0);
5851         VARAND(EMPTY,0,UI8,0,I4,0);
5852         VARAND(EMPTY,0,UI8,1,I4,0);
5853         VARAND(EMPTY,1,UI8,1,I4,0);
5854     }
5855     VARAND(EMPTY,0,INT,0,I4,0);
5856     VARAND(EMPTY,0,INT,1,I4,0);
5857     VARAND(EMPTY,1,INT,1,I4,0);
5858     VARAND(EMPTY,0,UINT,0,I4,0);
5859     VARAND(EMPTY,0,UINT,1,I4,0);
5860     VARAND(EMPTY,1,UINT,1,I4,0);
5861     VARAND(EMPTY,0,BOOL,0,I2,0);
5862     VARAND(EMPTY,0,BOOL,1,I2,0);
5863     VARAND(EMPTY,1,BOOL,1,I2,0);
5864     VARAND(EMPTY,0,R4,0,I4,0);
5865     VARAND(EMPTY,0,R4,1,I4,0);
5866     VARAND(EMPTY,1,R4,1,I4,0);
5867     VARAND(EMPTY,0,R8,0,I4,0);
5868     VARAND(EMPTY,0,R8,1,I4,0);
5869     VARAND(EMPTY,1,R8,1,I4,0);
5870     VARAND(EMPTY,0,BSTR,false_str,I2,0);
5871     VARAND(EMPTY,0,BSTR,true_str,I2,0);
5872     VARANDCY(EMPTY,0,10000,I4,0);
5873
5874     /* NULL OR 0 = NULL. NULL OR n = n */
5875     VARAND(NULL,0,NULL,0,NULL,0);
5876     VARAND(NULL,1,NULL,0,NULL,0);
5877     VARAND(NULL,0,I1,0,I4,0);
5878     VARAND(NULL,0,I1,1,NULL,0);
5879     VARAND(NULL,0,UI1,0,UI1,0);
5880     VARAND(NULL,0,UI1,1,NULL,0);
5881     VARAND(NULL,0,I2,0,I2,0);
5882     VARAND(NULL,0,I2,1,NULL,0);
5883     VARAND(NULL,0,UI2,0,I4,0);
5884     VARAND(NULL,0,UI2,1,NULL,0);
5885     VARAND(NULL,0,I4,0,I4,0);
5886     VARAND(NULL,0,I4,1,NULL,0);
5887     VARAND(NULL,0,UI4,0,I4,0);
5888     VARAND(NULL,0,UI4,1,NULL,0);
5889     if (HAVE_OLEAUT32_I8)
5890     {
5891         VARAND(NULL,0,I8,0,I8,0);
5892         VARAND(NULL,0,I8,1,NULL,0);
5893         VARAND(NULL,0,UI8,0,I4,0);
5894         VARAND(NULL,0,UI8,1,NULL,0);
5895     }
5896     VARAND(NULL,0,INT,0,I4,0);
5897     VARAND(NULL,0,INT,1,NULL,0);
5898     VARAND(NULL,0,UINT,0,I4,0);
5899     VARAND(NULL,0,UINT,1,NULL,0);
5900     VARAND(NULL,0,BOOL,0,BOOL,0);
5901     VARAND(NULL,0,BOOL,1,NULL,0);
5902     VARAND(NULL,0,R4,0,I4,0);
5903     VARAND(NULL,0,R4,1,NULL,0);
5904     VARAND(NULL,0,R8,0,I4,0);
5905     VARAND(NULL,0,R8,1,NULL,0);
5906     VARAND(NULL,0,BSTR,false_str,BOOL,0);
5907     VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
5908     VARANDCY(NULL,0,10000,NULL,0);
5909     VARANDCY(NULL,0,0,I4,0);
5910     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5911     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5912     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
5913     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5914
5915     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5916     VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5917     VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
5918     VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
5919     VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
5920     VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
5921     VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5922     VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5923     VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
5924     VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
5925     VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
5926     VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
5927     VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5928     VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5929     VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
5930     VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
5931     VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5932     VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
5933     VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5934     VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5935     VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
5936     VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
5937     VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5938     VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
5939     VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
5940     VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5941     VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
5942     VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5943     if (HAVE_OLEAUT32_I8)
5944     {
5945         VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5946         VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
5947         VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
5948         VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
5949         VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5950     }
5951     VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5952     VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
5953     VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
5954     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5955     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
5956     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5957     VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
5958     VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
5959     VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
5960     VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
5961     VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
5962     VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
5963     VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
5964     VARAND(I1,-1,I1,-1,I4,-1);
5965     VARAND(I1,-1,I1,0,I4,0);
5966     VARAND(I1,0,I1,0,I4,0);
5967     VARAND(I1,-1,UI1,255,I4,255);
5968     VARAND(I1,-1,UI1,0,I4,0);
5969     VARAND(I1,0,UI1,0,I4,0);
5970     VARAND(I1,-1,I2,-1,I4,-1);
5971     VARAND(I1,-1,I2,0,I4,0);
5972     VARAND(I1,0,I2,0,I4,0);
5973     VARAND(I1,-1,UI2,65535,I4,65535);
5974     VARAND(I1,-1,UI2,0,I4,0);
5975     VARAND(I1,0,UI2,0,I4,0);
5976     VARAND(I1,-1,I4,-1,I4,-1);
5977     VARAND(I1,-1,I4,0,I4,0);
5978     VARAND(I1,0,I4,0,I4,0);
5979     VARAND(I1,-1,UI4,0xffffffff,I4,-1);
5980     VARAND(I1,-1,UI4,0,I4,0);
5981     VARAND(I1,0,UI4,0,I4,0);
5982     VARAND(I1,-1,R4,-1,I4,-1);
5983     VARAND(I1,-1,R4,0,I4,0);
5984     VARAND(I1,0,R4,0,I4,0);
5985     VARAND(I1,-1,R8,-1,I4,-1);
5986     VARAND(I1,-1,R8,0,I4,0);
5987     VARAND(I1,0,R8,0,I4,0);
5988     VARAND(I1,-1,DATE,-1,I4,-1);
5989     VARAND(I1,-1,DATE,0,I4,0);
5990     VARAND(I1,0,DATE,0,I4,0);
5991     if (HAVE_OLEAUT32_I8)
5992     {
5993         VARAND(I1,-1,I8,-1,I8,-1);
5994         VARAND(I1,-1,I8,0,I8,0);
5995         VARAND(I1,0,I8,0,I8,0);
5996         VARAND(I1,-1,UI8,0,I4,0);
5997         VARAND(I1,0,UI8,0,I4,0);
5998     }
5999     VARAND(I1,-1,INT,-1,I4,-1);
6000     VARAND(I1,-1,INT,0,I4,0);
6001     VARAND(I1,0,INT,0,I4,0);
6002     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
6003     VARAND(I1,-1,UINT,0,I4,0);
6004     VARAND(I1,0,UINT,0,I4,0);
6005     VARAND(I1,0,BSTR,false_str,I4,0);
6006     VARAND(I1,-1,BSTR,false_str,I4,0);
6007     VARAND(I1,0,BSTR,true_str,I4,0);
6008     VARAND(I1,-1,BSTR,true_str,I4,-1);
6009     VARANDCY(I1,-1,10000,I4,1);
6010     VARANDCY(I1,-1,0,I4,0);
6011     VARANDCY(I1,0,0,I4,0);
6012
6013     VARAND(UI1,255,UI1,255,UI1,255);
6014     VARAND(UI1,255,UI1,0,UI1,0);
6015     VARAND(UI1,0,UI1,0,UI1,0);
6016     VARAND(UI1,255,I2,-1,I2,255);
6017     VARAND(UI1,255,I2,0,I2,0);
6018     VARAND(UI1,0,I2,0,I2,0);
6019     VARAND(UI1,255,UI2,65535,I4,255);
6020     VARAND(UI1,255,UI2,0,I4,0);
6021     VARAND(UI1,0,UI2,0,I4,0);
6022     VARAND(UI1,255,I4,-1,I4,255);
6023     VARAND(UI1,255,I4,0,I4,0);
6024     VARAND(UI1,0,I4,0,I4,0);
6025     VARAND(UI1,255,UI4,0xffffffff,I4,255);
6026     VARAND(UI1,255,UI4,0,I4,0);
6027     VARAND(UI1,0,UI4,0,I4,0);
6028     VARAND(UI1,255,R4,-1,I4,255);
6029     VARAND(UI1,255,R4,0,I4,0);
6030     VARAND(UI1,0,R4,0,I4,0);
6031     VARAND(UI1,255,R8,-1,I4,255);
6032     VARAND(UI1,255,R8,0,I4,0);
6033     VARAND(UI1,0,R8,0,I4,0);
6034     VARAND(UI1,255,DATE,-1,I4,255);
6035     VARAND(UI1,255,DATE,0,I4,0);
6036     VARAND(UI1,0,DATE,0,I4,0);
6037     if (HAVE_OLEAUT32_I8)
6038     {
6039         VARAND(UI1,255,I8,-1,I8,255);
6040         VARAND(UI1,255,I8,0,I8,0);
6041         VARAND(UI1,0,I8,0,I8,0);
6042         VARAND(UI1,255,UI8,0,I4,0);
6043         VARAND(UI1,0,UI8,0,I4,0);
6044     }
6045     VARAND(UI1,255,INT,-1,I4,255);
6046     VARAND(UI1,255,INT,0,I4,0);
6047     VARAND(UI1,0,INT,0,I4,0);
6048     VARAND(UI1,255,UINT,0xffffffff,I4,255);
6049     VARAND(UI1,255,UINT,0,I4,0);
6050     VARAND(UI1,0,UINT,0,I4,0);
6051     VARAND(UI1,0,BSTR,false_str,I2,0);
6052     VARAND(UI1,255,BSTR,false_str,I2,0);
6053     VARAND(UI1,0,BSTR,true_str,I2,0);
6054     VARAND(UI1,255,BSTR,true_str,I2,255);
6055     VARANDCY(UI1,255,10000,I4,1);
6056     VARANDCY(UI1,255,0,I4,0);
6057     VARANDCY(UI1,0,0,I4,0);
6058
6059     VARAND(I2,-1,I2,-1,I2,-1);
6060     VARAND(I2,-1,I2,0,I2,0);
6061     VARAND(I2,0,I2,0,I2,0);
6062     VARAND(I2,-1,UI2,65535,I4,65535);
6063     VARAND(I2,-1,UI2,0,I4,0);
6064     VARAND(I2,0,UI2,0,I4,0);
6065     VARAND(I2,-1,I4,-1,I4,-1);
6066     VARAND(I2,-1,I4,0,I4,0);
6067     VARAND(I2,0,I4,0,I4,0);
6068     VARAND(I2,-1,UI4,0xffffffff,I4,-1);
6069     VARAND(I2,-1,UI4,0,I4,0);
6070     VARAND(I2,0,UI4,0,I4,0);
6071     VARAND(I2,-1,R4,-1,I4,-1);
6072     VARAND(I2,-1,R4,0,I4,0);
6073     VARAND(I2,0,R4,0,I4,0);
6074     VARAND(I2,-1,R8,-1,I4,-1);
6075     VARAND(I2,-1,R8,0,I4,0);
6076     VARAND(I2,0,R8,0,I4,0);
6077     VARAND(I2,-1,DATE,-1,I4,-1);
6078     VARAND(I2,-1,DATE,0,I4,0);
6079     VARAND(I2,0,DATE,0,I4,0);
6080     if (HAVE_OLEAUT32_I8)
6081     {
6082         VARAND(I2,-1,I8,-1,I8,-1);
6083         VARAND(I2,-1,I8,0,I8,0);
6084         VARAND(I2,0,I8,0,I8,0);
6085         VARAND(I2,-1,UI8,0,I4,0);
6086         VARAND(I2,0,UI8,0,I4,0);
6087     }
6088     VARAND(I2,-1,INT,-1,I4,-1);
6089     VARAND(I2,-1,INT,0,I4,0);
6090     VARAND(I2,0,INT,0,I4,0);
6091     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
6092     VARAND(I2,-1,UINT,0,I4,0);
6093     VARAND(I2,0,UINT,0,I4,0);
6094     VARAND(I2,0,BSTR,false_str,I2,0);
6095     VARAND(I2,-1,BSTR,false_str,I2,0);
6096     VARAND(I2,0,BSTR,true_str,I2,0);
6097     VARAND(I2,-1,BSTR,true_str,I2,-1);
6098     VARANDCY(I2,-1,10000,I4,1);
6099     VARANDCY(I2,-1,0,I4,0);
6100     VARANDCY(I2,0,0,I4,0);
6101
6102     VARAND(UI2,65535,UI2,65535,I4,65535);
6103     VARAND(UI2,65535,UI2,0,I4,0);
6104     VARAND(UI2,0,UI2,0,I4,0);
6105     VARAND(UI2,65535,I4,-1,I4,65535);
6106     VARAND(UI2,65535,I4,0,I4,0);
6107     VARAND(UI2,0,I4,0,I4,0);
6108     VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
6109     VARAND(UI2,65535,UI4,0,I4,0);
6110     VARAND(UI2,0,UI4,0,I4,0);
6111     VARAND(UI2,65535,R4,-1,I4,65535);
6112     VARAND(UI2,65535,R4,0,I4,0);
6113     VARAND(UI2,0,R4,0,I4,0);
6114     VARAND(UI2,65535,R8,-1,I4,65535);
6115     VARAND(UI2,65535,R8,0,I4,0);
6116     VARAND(UI2,0,R8,0,I4,0);
6117     VARAND(UI2,65535,DATE,-1,I4,65535);
6118     VARAND(UI2,65535,DATE,0,I4,0);
6119     VARAND(UI2,0,DATE,0,I4,0);
6120     if (HAVE_OLEAUT32_I8)
6121     {
6122         VARAND(UI2,65535,I8,-1,I8,65535);
6123         VARAND(UI2,65535,I8,0,I8,0);
6124         VARAND(UI2,0,I8,0,I8,0);
6125         VARAND(UI2,65535,UI8,0,I4,0);
6126         VARAND(UI2,0,UI8,0,I4,0);
6127     }
6128     VARAND(UI2,65535,INT,-1,I4,65535);
6129     VARAND(UI2,65535,INT,0,I4,0);
6130     VARAND(UI2,0,INT,0,I4,0);
6131     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
6132     VARAND(UI2,65535,UINT,0,I4,0);
6133     VARAND(UI2,0,UINT,0,I4,0);
6134     VARAND(UI2,0,BSTR,false_str,I4,0);
6135     VARAND(UI2,65535,BSTR,false_str,I4,0);
6136     VARAND(UI2,0,BSTR,true_str,I4,0);
6137     VARAND(UI2,65535,BSTR,true_str,I4,65535);
6138     VARANDCY(UI2,65535,10000,I4,1);
6139     VARANDCY(UI2,65535,0,I4,0);
6140     VARANDCY(UI2,0,0,I4,0);
6141
6142     VARAND(I4,-1,I4,-1,I4,-1);
6143     VARAND(I4,-1,I4,0,I4,0);
6144     VARAND(I4,0,I4,0,I4,0);
6145     VARAND(I4,-1,UI4,0xffffffff,I4,-1);
6146     VARAND(I4,-1,UI4,0,I4,0);
6147     VARAND(I4,0,UI4,0,I4,0);
6148     VARAND(I4,-1,R4,-1,I4,-1);
6149     VARAND(I4,-1,R4,0,I4,0);
6150     VARAND(I4,0,R4,0,I4,0);
6151     VARAND(I4,-1,R8,-1,I4,-1);
6152     VARAND(I4,-1,R8,0,I4,0);
6153     VARAND(I4,0,R8,0,I4,0);
6154     VARAND(I4,-1,DATE,-1,I4,-1);
6155     VARAND(I4,-1,DATE,0,I4,0);
6156     VARAND(I4,0,DATE,0,I4,0);
6157     if (HAVE_OLEAUT32_I8)
6158     {
6159         VARAND(I4,-1,I8,-1,I8,-1);
6160         VARAND(I4,-1,I8,0,I8,0);
6161         VARAND(I4,0,I8,0,I8,0);
6162         VARAND(I4,-1,UI8,0,I4,0);
6163         VARAND(I4,0,UI8,0,I4,0);
6164     }
6165     VARAND(I4,-1,INT,-1,I4,-1);
6166     VARAND(I4,-1,INT,0,I4,0);
6167     VARAND(I4,0,INT,0,I4,0);
6168     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
6169     VARAND(I4,-1,UINT,0,I4,0);
6170     VARAND(I4,0,UINT,0,I4,0);
6171     VARAND(I4,0,BSTR,false_str,I4,0);
6172     VARAND(I4,-1,BSTR,false_str,I4,0);
6173     VARAND(I4,0,BSTR,true_str,I4,0);
6174     VARAND(I4,-1,BSTR,true_str,I4,-1);
6175     VARANDCY(I4,-1,10000,I4,1);
6176     VARANDCY(I4,-1,0,I4,0);
6177     VARANDCY(I4,0,0,I4,0);
6178
6179     VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
6180     VARAND(UI4,0xffffffff,UI4,0,I4,0);
6181     VARAND(UI4,0,UI4,0,I4,0);
6182     VARAND(UI4,0xffffffff,R4,-1,I4,-1);
6183     VARAND(UI4,0xffffffff,R4,0,I4,0);
6184     VARAND(UI4,0,R4,0,I4,0);
6185     VARAND(UI4,0xffffffff,R8,-1,I4,-1);
6186     VARAND(UI4,0xffffffff,R8,0,I4,0);
6187     VARAND(UI4,0,R8,0,I4,0);
6188     VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
6189     VARAND(UI4,0xffffffff,DATE,0,I4,0);
6190     VARAND(UI4,0,DATE,0,I4,0);
6191     if (HAVE_OLEAUT32_I8)
6192     {
6193         VARAND(UI4,0xffffffff,I8,0,I8,0);
6194         VARAND(UI4,0,I8,0,I8,0);
6195         VARAND(UI4,0xffffffff,UI8,0,I4,0);
6196         VARAND(UI4,0,UI8,0,I4,0);
6197     }
6198     VARAND(UI4,0xffffffff,INT,-1,I4,-1);
6199     VARAND(UI4,0xffffffff,INT,0,I4,0);
6200     VARAND(UI4,0,INT,0,I4,0);
6201     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
6202     VARAND(UI4,0xffffffff,UINT,0,I4,0);
6203     VARAND(UI4,0,UINT,0,I4,0);
6204     VARAND(UI4,0,BSTR,false_str,I4,0);
6205     VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
6206     VARAND(UI4,0,BSTR,true_str,I4,0);
6207     VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
6208     VARANDCY(UI4,0xffffffff,10000,I4,1);
6209     VARANDCY(UI4,0xffffffff,0,I4,0);
6210     VARANDCY(UI4,0,0,I4,0);
6211
6212     VARAND(R4,-1,R4,-1,I4,-1);
6213     VARAND(R4,-1,R4,0,I4,0);
6214     VARAND(R4,0,R4,0,I4,0);
6215     VARAND(R4,-1,R8,-1,I4,-1);
6216     VARAND(R4,-1,R8,0,I4,0);
6217     VARAND(R4,0,R8,0,I4,0);
6218     VARAND(R4,-1,DATE,-1,I4,-1);
6219     VARAND(R4,-1,DATE,0,I4,0);
6220     VARAND(R4,0,DATE,0,I4,0);
6221     if (HAVE_OLEAUT32_I8)
6222     {
6223         VARAND(R4,-1,I8,-1,I8,-1);
6224         VARAND(R4,-1,I8,0,I8,0);
6225         VARAND(R4,0,I8,0,I8,0);
6226         VARAND(R4,-1,UI8,0,I4,0);
6227         VARAND(R4,0,UI8,0,I4,0);
6228     }
6229     VARAND(R4,-1,INT,-1,I4,-1);
6230     VARAND(R4,-1,INT,0,I4,0);
6231     VARAND(R4,0,INT,0,I4,0);
6232     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
6233     VARAND(R4,-1,UINT,0,I4,0);
6234     VARAND(R4,0,UINT,0,I4,0);
6235     VARAND(R4,0,BSTR,false_str,I4,0);
6236     VARAND(R4,-1,BSTR,false_str,I4,0);
6237     VARAND(R4,0,BSTR,true_str,I4,0);
6238     VARAND(R4,-1,BSTR,true_str,I4,-1);
6239     VARANDCY(R4,-1,10000,I4,1);
6240     VARANDCY(R4,-1,0,I4,0);
6241     VARANDCY(R4,0,0,I4,0);
6242
6243     VARAND(R8,-1,R8,-1,I4,-1);
6244     VARAND(R8,-1,R8,0,I4,0);
6245     VARAND(R8,0,R8,0,I4,0);
6246     VARAND(R8,-1,DATE,-1,I4,-1);
6247     VARAND(R8,-1,DATE,0,I4,0);
6248     VARAND(R8,0,DATE,0,I4,0);
6249     if (HAVE_OLEAUT32_I8)
6250     {
6251         VARAND(R8,-1,I8,-1,I8,-1);
6252         VARAND(R8,-1,I8,0,I8,0);
6253         VARAND(R8,0,I8,0,I8,0);
6254         VARAND(R8,-1,UI8,0,I4,0);
6255         VARAND(R8,0,UI8,0,I4,0);
6256     }
6257     VARAND(R8,-1,INT,-1,I4,-1);
6258     VARAND(R8,-1,INT,0,I4,0);
6259     VARAND(R8,0,INT,0,I4,0);
6260     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
6261     VARAND(R8,-1,UINT,0,I4,0);
6262     VARAND(R8,0,UINT,0,I4,0);
6263     VARAND(R8,0,BSTR,false_str,I4,0);
6264     VARAND(R8,-1,BSTR,false_str,I4,0);
6265     VARAND(R8,0,BSTR,true_str,I4,0);
6266     VARAND(R8,-1,BSTR,true_str,I4,-1);
6267     VARANDCY(R8,-1,10000,I4,1);
6268     VARANDCY(R8,-1,0,I4,0);
6269     VARANDCY(R8,0,0,I4,0);
6270
6271     VARAND(DATE,-1,DATE,-1,I4,-1);
6272     VARAND(DATE,-1,DATE,0,I4,0);
6273     VARAND(DATE,0,DATE,0,I4,0);
6274     if (HAVE_OLEAUT32_I8)
6275     {
6276         VARAND(DATE,-1,I8,-1,I8,-1);
6277         VARAND(DATE,-1,I8,0,I8,0);
6278         VARAND(DATE,0,I8,0,I8,0);
6279         VARAND(DATE,-1,UI8,0,I4,0);
6280         VARAND(DATE,0,UI8,0,I4,0);
6281     }
6282     VARAND(DATE,-1,INT,-1,I4,-1);
6283     VARAND(DATE,-1,INT,0,I4,0);
6284     VARAND(DATE,0,INT,0,I4,0);
6285     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
6286     VARAND(DATE,-1,UINT,0,I4,0);
6287     VARAND(DATE,0,UINT,0,I4,0);
6288     VARAND(DATE,0,BSTR,false_str,I4,0);
6289     VARAND(DATE,-1,BSTR,false_str,I4,0);
6290     VARAND(DATE,0,BSTR,true_str,I4,0);
6291     VARAND(DATE,-1,BSTR,true_str,I4,-1);
6292     VARANDCY(DATE,-1,10000,I4,1);
6293     VARANDCY(DATE,-1,0,I4,0);
6294     VARANDCY(DATE,0,0,I4,0);
6295
6296     if (HAVE_OLEAUT32_I8)
6297     {
6298         VARAND(I8,-1,I8,-1,I8,-1);
6299         VARAND(I8,-1,I8,0,I8,0);
6300         VARAND(I8,0,I8,0,I8,0);
6301         VARAND(I8,-1,UI8,0,I8,0);
6302         VARAND(I8,0,UI8,0,I8,0);
6303         VARAND(I8,-1,UINT,0,I8,0);
6304         VARAND(I8,0,UINT,0,I8,0);
6305         VARAND(I8,0,BSTR,false_str,I8,0);
6306         VARAND(I8,-1,BSTR,false_str,I8,0);
6307         VARAND(I8,0,BSTR,true_str,I8,0);
6308         VARAND(I8,-1,BSTR,true_str,I8,-1);
6309         VARANDCY(I8,-1,10000,I8,1);
6310         VARANDCY(I8,-1,0,I8,0);
6311         VARANDCY(I8,0,0,I8,0);
6312
6313         VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
6314         VARAND(UI8,0xffff,UI8,0,I4,0);
6315         VARAND(UI8,0,UI8,0,I4,0);
6316         VARAND(UI8,0xffff,INT,-1,I4,65535);
6317         VARAND(UI8,0xffff,INT,0,I4,0);
6318         VARAND(UI8,0,INT,0,I4,0);
6319         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
6320         VARAND(UI8,0xffff,UINT,0,I4,0);
6321         VARAND(UI8,0,UINT,0,I4,0);
6322         VARAND(UI8,0,BSTR,false_str,I4,0);
6323         VARAND(UI8,0xffff,BSTR,false_str,I4,0);
6324         VARAND(UI8,0,BSTR,true_str,I4,0);
6325         VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
6326         VARANDCY(UI8,0xffff,10000,I4,1);
6327         VARANDCY(UI8,0xffff,0,I4,0);
6328         VARANDCY(UI8,0,0,I4,0);
6329     }
6330
6331     VARAND(INT,-1,INT,-1,I4,-1);
6332     VARAND(INT,-1,INT,0,I4,0);
6333     VARAND(INT,0,INT,0,I4,0);
6334     VARAND(INT,-1,UINT,0xffff,I4,65535);
6335     VARAND(INT,-1,UINT,0,I4,0);
6336     VARAND(INT,0,UINT,0,I4,0);
6337     VARAND(INT,0,BSTR,false_str,I4,0);
6338     VARAND(INT,-1,BSTR,false_str,I4,0);
6339     VARAND(INT,0,BSTR,true_str,I4,0);
6340     VARAND(INT,-1,BSTR,true_str,I4,-1);
6341     VARANDCY(INT,-1,10000,I4,1);
6342     VARANDCY(INT,-1,0,I4,0);
6343     VARANDCY(INT,0,0,I4,0);
6344
6345     VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
6346     VARAND(UINT,0xffff,UINT,0,I4,0);
6347     VARAND(UINT,0,UINT,0,I4,0);
6348     VARAND(UINT,0,BSTR,false_str,I4,0);
6349     VARAND(UINT,0xffff,BSTR, false_str,I4,0);
6350     VARAND(UINT,0,BSTR,true_str,I4,0);
6351     VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
6352     VARANDCY(UINT,0xffff,10000,I4,1);
6353     VARANDCY(UINT,0xffff,0,I4,0);
6354     VARANDCY(UINT,0,0,I4,0);
6355
6356     VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
6357     VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
6358     VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
6359     VARANDCY(BSTR,true_str,10000,I4,1);
6360     VARANDCY(BSTR,false_str,10000,I4,0);
6361
6362     SysFreeString(true_str);
6363     SysFreeString(false_str);
6364 }
6365
6366 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
6367
6368 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
6369 {
6370     HRESULT hres;
6371
6372     hres = pVarCmp(left,right,lcid,flags);
6373     ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
6374                        variantstr(left), variantstr(right), result, hres );
6375 }
6376 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
6377                         HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
6378 {
6379     test_cmp( line, lcid, 0, left, right, res1 );
6380     V_VT(left) |= VT_RESERVED;
6381     test_cmp( line, lcid, 0, left, right, res2 );
6382     V_VT(left) &= ~VT_RESERVED;
6383     V_VT(right) |= VT_RESERVED;
6384     test_cmp( line, lcid, 0, left, right, res3 );
6385     V_VT(left) |= VT_RESERVED;
6386     test_cmp( line, lcid, 0, left, right, res4 );
6387     ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
6388 }
6389
6390 /* ERROR from wingdi.h is interfering here */
6391 #undef ERROR
6392 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
6393         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
6394         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
6395         test_cmp( __LINE__, lcid, flags, &left, &right, result )
6396 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
6397         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
6398         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
6399         test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
6400 #define VARCMP(vt1,val1,vt2,val2,result) \
6401         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
6402 /* The above macros do not work for VT_NULL as NULL gets expanded first */
6403 #define V_NULL_  V_NULL
6404 #define VT_NULL_ VT_NULL
6405
6406 static void test_VarCmp(void)
6407 {
6408     VARIANT left, right;
6409     VARTYPE i;
6410     LCID lcid;
6411     HRESULT hres;
6412     DECIMAL dec;
6413     static const WCHAR szhuh[] = {'h','u','h','?','\0'};
6414     static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
6415     static const WCHAR szempty[] = {'\0'};
6416     static const WCHAR sz0[] = {'0','\0'};
6417     static const WCHAR sz1[] = {'1','\0'};
6418     static const WCHAR sz7[] = {'7','\0'};
6419     static const WCHAR sz42[] = {'4','2','\0'};
6420     static const WCHAR sz1neg[] = {'-','1','\0'};
6421     static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
6422     static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
6423     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
6424     BSTR bstr2cents, bstr1few;
6425
6426     CHECKPTR(VarCmp);
6427
6428     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
6429     bstrempty = SysAllocString(szempty);
6430     bstrhuh = SysAllocString(szhuh);
6431     bstr2cents = SysAllocString(sz2cents);
6432     bstr0 = SysAllocString(sz0);
6433     bstr1 = SysAllocString(sz1);
6434     bstr7 = SysAllocString(sz7);
6435     bstr42 = SysAllocString(sz42);
6436     bstr1neg = SysAllocString(sz1neg);
6437     bstr666neg = SysAllocString(sz666neg);
6438     bstr1few = SysAllocString(sz1few);
6439
6440     /* Test all possible flag/vt combinations & the resulting vt type */
6441     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6442     {
6443         VARTYPE leftvt, rightvt;
6444
6445         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6446         {
6447
6448             SKIPTESTS(leftvt);
6449
6450             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6451             {
6452                 BOOL bFail = FALSE;
6453                 HRESULT expect = VARCMP_EQ;
6454
6455                 SKIPTESTS(rightvt);
6456
6457                 memset(&left, 0, sizeof(left));
6458                 memset(&right, 0, sizeof(right));
6459                 V_VT(&left) = leftvt | ExtraFlags[i];
6460                 if (leftvt == VT_BSTR) {
6461                     V_BSTR(&left) = bstr1neg;
6462                     if (ExtraFlags[i] & VT_RESERVED)
6463                         expect = VARCMP_LT;
6464                     else
6465                         expect = VARCMP_GT;
6466                 }
6467                 V_VT(&right) = rightvt | ExtraFlags[i];
6468                 if (rightvt == VT_BSTR) {
6469                     V_BSTR(&right) = bstr1neg;
6470                     if (ExtraFlags[i] & VT_RESERVED)
6471                         expect = VARCMP_GT;
6472                     else
6473                         expect = VARCMP_LT;
6474                 }
6475
6476                 /* Don't ask me why but native VarCmp cannot handle:
6477                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
6478                    VT_INT is only supported as left variant. Go figure.
6479                    Tested with DCOM98, Win2k, WinXP */
6480                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6481                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
6482                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
6483                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6484                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6485                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6486                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6487                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
6488                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6489                     leftvt == VT_I1 || rightvt == VT_I1 ||
6490                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6491                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6492                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6493                     rightvt == VT_INT ||
6494                     leftvt == VT_UINT || rightvt == VT_UINT) {
6495                     bFail = TRUE;
6496                 }
6497
6498                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
6499                     !(ExtraFlags[i] & ~VT_RESERVED)) {
6500                     expect = VARCMP_EQ;
6501                     bFail = FALSE;
6502                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
6503                     expect = VARCMP_NULL;
6504                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
6505                     expect = VARCMP_EQ;
6506                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
6507                     expect = VARCMP_GT;
6508                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
6509                     expect = VARCMP_LT;
6510
6511                 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
6512                 if (bFail) {
6513                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6514                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%X\n",
6515                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
6516                 } else {
6517                     ok(hres == expect,
6518                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%X, got 0x%X\n",
6519                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
6520                        hres);
6521                 }
6522             }
6523         }
6524     }
6525
6526     /* VARCMP{,EX} run each 4 tests with a permutation of all possible
6527        input variants with (1) and without (0) VT_RESERVED set. The order
6528        of the permutations is (0,0); (1,0); (0,1); (1,1) */
6529     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
6530     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
6531     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
6532     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
6533     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
6534     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
6535     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
6536     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
6537     VARCMP(I4,1,UI1,1,VARCMP_EQ);
6538     VARCMP(I2,2,I2,2,VARCMP_EQ);
6539     VARCMP(I2,1,I2,2,VARCMP_LT);
6540     VARCMP(I2,2,I2,1,VARCMP_GT);
6541     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
6542     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
6543
6544     /* BSTR handling, especially in conjunction with VT_RESERVED */
6545     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
6546     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
6547     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
6548     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
6549     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
6550     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
6551     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
6552     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
6553     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
6554     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
6555     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
6556     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
6557     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
6558     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
6559     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6560     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6561     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6562     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6563     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6564     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
6565     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6566     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6567     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
6568     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
6569     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6570     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
6571     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6572     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6573     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6574     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6575     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
6576     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6577     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
6578     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6579     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
6580     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6581     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6582     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6583     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6584     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6585     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6586     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6587     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6588     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6589     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6590     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6591     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6592     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6593     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6594     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6595     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6596     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6597     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
6598     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
6599     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
6600
6601     /* DECIMAL handling */
6602     setdec(&dec,0,0,0,0);
6603     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6604     setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
6605     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
6606     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
6607     setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
6608     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
6609     setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001);    /* 1+1e-20 */
6610     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
6611
6612     /* Show that DATE is handled just as a R8 */
6613     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
6614     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
6615     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
6616     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
6617     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
6618     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
6619     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
6620     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
6621     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
6622
6623     /* R4 precision handling */
6624     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
6625     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
6626     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
6627     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
6628     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
6629     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
6630     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
6631     setdec(&dec,8,0,0,0x5F5E101);         /* 1+1e-8 */
6632     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
6633
6634     SysFreeString(bstrhuh);
6635     SysFreeString(bstrempty);
6636     SysFreeString(bstr0);
6637     SysFreeString(bstr1);
6638     SysFreeString(bstr7);
6639     SysFreeString(bstr42);
6640     SysFreeString(bstr1neg);
6641     SysFreeString(bstr666neg);
6642     SysFreeString(bstr2cents);
6643     SysFreeString(bstr1few);
6644 }
6645
6646 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
6647
6648 #define VARPOW(vt1,val1,vt2,val2,rvt,rval)               \
6649         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6650         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6651         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6652         test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
6653
6654 /* Skip any type that is not defined or produces an error for every case */
6655 #define SKIPTESTPOW(a)                            \
6656     if (a == VT_ERROR || a == VT_VARIANT ||       \
6657         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
6658         a == VT_RECORD || a > VT_UINT ||          \
6659         a == 15 /*not defined*/)                  \
6660         continue
6661
6662 static void test_VarPow(void)
6663 {
6664     static const WCHAR str2[] = { '2','\0' };
6665     static const WCHAR str3[] = { '3','\0' };
6666     VARIANT left, right, exp, result, cy, dec;
6667     BSTR num2_str, num3_str;
6668     VARTYPE i;
6669     HRESULT hres;
6670
6671     CHECKPTR(VarPow);
6672
6673     num2_str = SysAllocString(str2);
6674     num3_str = SysAllocString(str3);
6675
6676     /* Test all possible flag/vt combinations & the resulting vt type */
6677     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6678     {
6679         VARTYPE leftvt, rightvt, resvt;
6680
6681         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6682         {
6683             SKIPTESTPOW(leftvt);
6684
6685             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6686             {
6687                 BOOL bFail = FALSE;
6688                 SKIPTESTPOW(rightvt);
6689
6690                 /* Native crashes with VT_BYREF */
6691                 if (ExtraFlags[i] == VT_BYREF)
6692                     continue;
6693
6694                 memset(&left, 0, sizeof(left));
6695                 memset(&right, 0, sizeof(right));
6696                 V_VT(&left) = leftvt | ExtraFlags[i];
6697                 V_VT(&right) = rightvt | ExtraFlags[i];
6698                 V_VT(&result) = VT_EMPTY;
6699                 resvt = VT_EMPTY;
6700
6701                 if (leftvt == VT_BSTR)
6702                     V_BSTR(&left) = num2_str;
6703                 if (rightvt == VT_BSTR)
6704                     V_BSTR(&right) = num2_str;
6705
6706                 /* Native VarPow always returns an error when using extra flags */
6707                 if (ExtraFlags[i] != 0)
6708                     bFail = TRUE;
6709
6710                 /* Determine return type */
6711                 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
6712                          ((leftvt != VT_I8 && leftvt != VT_UI8 &&
6713                            rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
6714                     resvt = VT_NULL;
6715                 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
6716                     leftvt == VT_I4 || leftvt == VT_R4 ||
6717                     leftvt == VT_R8 || leftvt == VT_CY ||
6718                     leftvt == VT_DATE || leftvt == VT_BSTR ||
6719                     leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
6720                     (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
6721                     (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
6722                     leftvt == VT_INT || leftvt == VT_UINT) &&
6723                     (rightvt == VT_EMPTY || rightvt == VT_I2 ||
6724                     rightvt == VT_I4 || rightvt == VT_R4 ||
6725                     rightvt == VT_R8 || rightvt == VT_CY ||
6726                     rightvt == VT_DATE || rightvt == VT_BSTR ||
6727                     rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
6728                     (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
6729                     (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
6730                     rightvt == VT_INT || rightvt == VT_UINT))
6731                     resvt = VT_R8;
6732                 else
6733                     bFail = TRUE;
6734
6735                 hres = pVarPow(&left, &right, &result);
6736
6737                 /* Check expected HRESULT and if result variant type is correct */
6738                 if (bFail)
6739                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6740                         "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
6741                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
6742                         vtstr(V_VT(&result)), hres);
6743                 else
6744                     ok (hres == S_OK && resvt == V_VT(&result),
6745                         "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
6746                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
6747                         S_OK, vtstr(V_VT(&result)), hres);
6748             }
6749         }
6750     }
6751
6752     /* Check return values for valid variant type combinations */
6753     VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
6754     VARPOW(EMPTY,0,NULL,0,NULL,0);
6755     VARPOW(EMPTY,0,I2,3,R8,0.0);
6756     VARPOW(EMPTY,0,I4,3,R8,0.0);
6757     VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
6758     VARPOW(EMPTY,0,R8,3.0,R8,0.0);
6759     VARPOW(EMPTY,0,DATE,3,R8,0.0);
6760     VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
6761     VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
6762     VARPOW(EMPTY,0,I1,3,R8,0.0);
6763     VARPOW(EMPTY,0,UI1,3,R8,0.0);
6764     VARPOW(EMPTY,0,UI2,3,R8,0.0);
6765     VARPOW(EMPTY,0,UI4,3,R8,0.0);
6766     if (HAVE_OLEAUT32_I8)
6767     {
6768         VARPOW(EMPTY,0,I8,3,R8,0.0);
6769         VARPOW(EMPTY,0,UI8,3,R8,0.0);
6770     }
6771     VARPOW(EMPTY,0,INT,3,R8,0.0);
6772     VARPOW(EMPTY,0,UINT,3,R8,0.0);
6773     VARPOW(NULL,0,EMPTY,0,NULL,0);
6774     VARPOW(NULL,0,NULL,0,NULL,0);
6775     VARPOW(NULL,0,I2,3,NULL,0);
6776     VARPOW(NULL,0,I4,3,NULL,0);
6777     VARPOW(NULL,0,R4,3.0f,NULL,0);
6778     VARPOW(NULL,0,R8,3.0,NULL,0);
6779     VARPOW(NULL,0,DATE,3,NULL,0);
6780     VARPOW(NULL,0,BSTR,num3_str,NULL,0);
6781     VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
6782     VARPOW(NULL,0,I1,3,NULL,0);
6783     VARPOW(NULL,0,UI1,3,NULL,0);
6784     VARPOW(NULL,0,UI2,3,NULL,0);
6785     VARPOW(NULL,0,UI4,3,NULL,0);
6786     if (HAVE_OLEAUT32_I8)
6787     {
6788         VARPOW(NULL,0,I8,3,NULL,0);
6789         VARPOW(NULL,0,UI8,3,NULL,0);
6790     }
6791     VARPOW(NULL,0,INT,3,NULL,0);
6792     VARPOW(NULL,0,UINT,3,NULL,0);
6793     VARPOW(I2,2,EMPTY,0,R8,1.0);
6794     VARPOW(I2,2,NULL,0,NULL,0);
6795     VARPOW(I2,2,I2,3,R8,8.0);
6796     VARPOW(I2,2,I4,3,R8,8.0);
6797     VARPOW(I2,2,R4,3.0f,R8,8.0);
6798     VARPOW(I2,2,R8,3.0,R8,8.0);
6799     VARPOW(I2,2,DATE,3,R8,8.0);
6800     VARPOW(I2,2,BSTR,num3_str,R8,8.0);
6801     VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
6802     VARPOW(I2,2,I1,3,R8,8.0);
6803     VARPOW(I2,2,UI1,3,R8,8.0);
6804     VARPOW(I2,2,UI2,3,R8,8.0);
6805     VARPOW(I2,2,UI4,3,R8,8.0);
6806     if (HAVE_OLEAUT32_I8)
6807     {
6808         VARPOW(I2,2,I8,3,R8,8.0);
6809         VARPOW(I2,2,UI8,3,R8,8.0);
6810     }
6811     VARPOW(I2,2,INT,3,R8,8.0);
6812     VARPOW(I2,2,UINT,3,R8,8.0);
6813     VARPOW(I4,2,EMPTY,0,R8,1.0);
6814     VARPOW(I4,2,NULL,0,NULL,0);
6815     VARPOW(I4,2,I2,3,R8,8.0);
6816     VARPOW(I4,2,I4,3,R8,8.0);
6817     VARPOW(I4,2,R4,3.0f,R8,8.0);
6818     VARPOW(I4,2,R8,3.0,R8,8.0);
6819     VARPOW(I4,2,DATE,3,R8,8.0);
6820     VARPOW(I4,2,BSTR,num3_str,R8,8.0);
6821     VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
6822     VARPOW(I4,2,I1,3,R8,8.0);
6823     VARPOW(I4,2,UI1,3,R8,8.0);
6824     VARPOW(I4,2,UI2,3,R8,8.0);
6825     VARPOW(I4,2,UI4,3,R8,8.0);
6826     if (HAVE_OLEAUT32_I8)
6827     {
6828         VARPOW(I4,2,I8,3,R8,8.0);
6829         VARPOW(I4,2,UI8,3,R8,8.0);
6830     }
6831     VARPOW(I4,2,INT,3,R8,8.0);
6832     VARPOW(I4,2,UINT,3,R8,8.0);
6833     VARPOW(R4,2,EMPTY,0,R8,1.0);
6834     VARPOW(R4,2,NULL,0,NULL,0);
6835     VARPOW(R4,2,I2,3,R8,8.0);
6836     VARPOW(R4,2,I4,3,R8,8.0);
6837     VARPOW(R4,2,R4,3.0f,R8,8.0);
6838     VARPOW(R4,2,R8,3.0,R8,8.0);
6839     VARPOW(R4,2,DATE,3,R8,8.0);
6840     VARPOW(R4,2,BSTR,num3_str,R8,8.0);
6841     VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
6842     VARPOW(R4,2,I1,3,R8,8.0);
6843     VARPOW(R4,2,UI1,3,R8,8.0);
6844     VARPOW(R4,2,UI2,3,R8,8.0);
6845     VARPOW(R4,2,UI4,3,R8,8.0);
6846     if (HAVE_OLEAUT32_I8)
6847     {
6848         VARPOW(R4,2,I8,3,R8,8.0);
6849         VARPOW(R4,2,UI8,3,R8,8.0);
6850     }
6851     VARPOW(R4,2,INT,3,R8,8.0);
6852     VARPOW(R4,2,UINT,3,R8,8.0);
6853     VARPOW(R8,2,EMPTY,0,R8,1.0);
6854     VARPOW(R8,2,NULL,0,NULL,0);
6855     VARPOW(R8,2,I2,3,R8,8.0);
6856     VARPOW(R8,2,I4,3,R8,8.0);
6857     VARPOW(R8,2,R4,3.0f,R8,8.0);
6858     VARPOW(R8,2,R8,3.0,R8,8.0);
6859     VARPOW(R8,2,DATE,3,R8,8.0);
6860     VARPOW(R8,2,BSTR,num3_str,R8,8.0);
6861     VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
6862     VARPOW(R8,2,I1,3,R8,8.0);
6863     VARPOW(R8,2,UI1,3,R8,8.0);
6864     VARPOW(R8,2,UI2,3,R8,8.0);
6865     VARPOW(R8,2,UI4,3,R8,8.0);
6866     if (HAVE_OLEAUT32_I8)
6867     {
6868         VARPOW(R8,2,I8,3,R8,8.0);
6869         VARPOW(R8,2,UI8,3,R8,8.0);
6870     }
6871     VARPOW(R8,2,INT,3,R8,8.0);
6872     VARPOW(R8,2,UINT,3,R8,8.0);
6873     VARPOW(DATE,2,EMPTY,0,R8,1.0);
6874     VARPOW(DATE,2,NULL,0,NULL,0);
6875     VARPOW(DATE,2,I2,3,R8,8.0);
6876     VARPOW(DATE,2,I4,3,R8,8.0);
6877     VARPOW(DATE,2,R4,3.0f,R8,8.0);
6878     VARPOW(DATE,2,R8,3.0,R8,8.0);
6879     VARPOW(DATE,2,DATE,3,R8,8.0);
6880     VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
6881     VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
6882     VARPOW(DATE,2,I1,3,R8,8.0);
6883     VARPOW(DATE,2,UI1,3,R8,8.0);
6884     VARPOW(DATE,2,UI2,3,R8,8.0);
6885     VARPOW(DATE,2,UI4,3,R8,8.0);
6886     if (HAVE_OLEAUT32_I8)
6887     {
6888         VARPOW(DATE,2,I8,3,R8,8.0);
6889         VARPOW(DATE,2,UI8,3,R8,8.0);
6890     }
6891     VARPOW(DATE,2,INT,3,R8,8.0);
6892     VARPOW(DATE,2,UINT,3,R8,8.0);
6893     VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
6894     VARPOW(BSTR,num2_str,NULL,0,NULL,0);
6895     VARPOW(BSTR,num2_str,I2,3,R8,8.0);
6896     VARPOW(BSTR,num2_str,I4,3,R8,8.0);
6897     VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
6898     VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
6899     VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
6900     VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
6901     VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
6902     VARPOW(BSTR,num2_str,I1,3,R8,8.0);
6903     VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
6904     VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
6905     VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
6906     if (HAVE_OLEAUT32_I8)
6907     {
6908         VARPOW(BSTR,num2_str,I8,3,R8,8.0);
6909         VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
6910     }
6911     VARPOW(BSTR,num2_str,INT,3,R8,8.0);
6912     VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
6913     VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
6914     VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
6915     VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
6916     VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
6917     VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
6918     VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
6919     VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
6920     VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
6921     VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
6922     VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
6923     VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
6924     VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
6925     VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
6926     if (HAVE_OLEAUT32_I8)
6927     {
6928         VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
6929         VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
6930     }
6931     VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
6932     VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
6933     VARPOW(I1,2,EMPTY,0,R8,1.0);
6934     VARPOW(I1,2,NULL,0,NULL,0);
6935     VARPOW(I1,2,I2,3,R8,8.0);
6936     VARPOW(I1,2,I4,3,R8,8.0);
6937     VARPOW(I1,2,R4,3.0f,R8,8.0);
6938     VARPOW(I1,2,R8,3.0,R8,8.0);
6939     VARPOW(I1,2,DATE,3,R8,8.0);
6940     VARPOW(I1,2,BSTR,num3_str,R8,8.0);
6941     VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
6942     VARPOW(I1,2,I1,3,R8,8.0);
6943     VARPOW(I1,2,UI1,3,R8,8.0);
6944     VARPOW(I1,2,UI2,3,R8,8.0);
6945     VARPOW(I1,2,UI4,3,R8,8.0);
6946     if (HAVE_OLEAUT32_I8)
6947     {
6948         VARPOW(I1,2,I8,3,R8,8.0);
6949         VARPOW(I1,2,UI8,3,R8,8.0);
6950     }
6951     VARPOW(I1,2,INT,3,R8,8.0);
6952     VARPOW(I1,2,UINT,3,R8,8.0);
6953     VARPOW(UI1,2,EMPTY,0,R8,1.0);
6954     VARPOW(UI1,2,NULL,0,NULL,0);
6955     VARPOW(UI1,2,I2,3,R8,8.0);
6956     VARPOW(UI1,2,I4,3,R8,8.0);
6957     VARPOW(UI1,2,R4,3.0f,R8,8.0);
6958     VARPOW(UI1,2,R8,3.0,R8,8.0);
6959     VARPOW(UI1,2,DATE,3,R8,8.0);
6960     VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
6961     VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
6962     VARPOW(UI1,2,I1,3,R8,8.0);
6963     VARPOW(UI1,2,UI1,3,R8,8.0);
6964     VARPOW(UI1,2,UI2,3,R8,8.0);
6965     VARPOW(UI1,2,UI4,3,R8,8.0);
6966     if (HAVE_OLEAUT32_I8)
6967     {
6968         VARPOW(UI1,2,I8,3,R8,8.0);
6969         VARPOW(UI1,2,UI8,3,R8,8.0);
6970     }
6971     VARPOW(UI1,2,INT,3,R8,8.0);
6972     VARPOW(UI1,2,UINT,3,R8,8.0);
6973     VARPOW(UI2,2,EMPTY,0,R8,1.0);
6974     VARPOW(UI2,2,NULL,0,NULL,0);
6975     VARPOW(UI2,2,I2,3,R8,8.0);
6976     VARPOW(UI2,2,I4,3,R8,8.0);
6977     VARPOW(UI2,2,R4,3.0f,R8,8.0);
6978     VARPOW(UI2,2,R8,3.0,R8,8.0);
6979     VARPOW(UI2,2,DATE,3,R8,8.0);
6980     VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
6981     VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
6982     VARPOW(UI2,2,I1,3,R8,8.0);
6983     VARPOW(UI2,2,UI1,3,R8,8.0);
6984     VARPOW(UI2,2,UI2,3,R8,8.0);
6985     VARPOW(UI2,2,UI4,3,R8,8.0);
6986     if (HAVE_OLEAUT32_I8)
6987     {
6988         VARPOW(UI2,2,I8,3,R8,8.0);
6989         VARPOW(UI2,2,UI8,3,R8,8.0);
6990     }
6991     VARPOW(UI2,2,INT,3,R8,8.0);
6992     VARPOW(UI2,2,UINT,3,R8,8.0);
6993     VARPOW(UI4,2,EMPTY,0,R8,1.0);
6994     VARPOW(UI4,2,NULL,0,NULL,0);
6995     VARPOW(UI4,2,I2,3,R8,8.0);
6996     VARPOW(UI4,2,I4,3,R8,8.0);
6997     VARPOW(UI4,2,R4,3.0f,R8,8.0);
6998     VARPOW(UI4,2,R8,3.0,R8,8.0);
6999     VARPOW(UI4,2,DATE,3,R8,8.0);
7000     VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
7001     VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
7002     VARPOW(UI4,2,I1,3,R8,8.0);
7003     VARPOW(UI4,2,UI1,3,R8,8.0);
7004     VARPOW(UI4,2,UI2,3,R8,8.0);
7005     VARPOW(UI4,2,UI4,3,R8,8.0);
7006     if (HAVE_OLEAUT32_I8)
7007     {
7008         VARPOW(UI4,2,I8,3,R8,8.0);
7009         VARPOW(UI4,2,UI8,3,R8,8.0);
7010     }
7011     VARPOW(UI4,2,INT,3,R8,8.0);
7012     VARPOW(UI4,2,UINT,3,R8,8.0);
7013     if (HAVE_OLEAUT32_I8)
7014     {
7015         VARPOW(I8,2,EMPTY,0,R8,1.0);
7016         VARPOW(I8,2,NULL,0,NULL,0);
7017         VARPOW(I8,2,I2,3,R8,8.0);
7018         VARPOW(I8,2,I4,3,R8,8.0);
7019         VARPOW(I8,2,R4,3.0f,R8,8.0);
7020         VARPOW(I8,2,R8,3.0,R8,8.0);
7021         VARPOW(I8,2,DATE,3,R8,8.0);
7022         VARPOW(I8,2,BSTR,num3_str,R8,8.0);
7023         VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
7024         VARPOW(I8,2,I1,3,R8,8.0);
7025         VARPOW(I8,2,UI1,3,R8,8.0);
7026         VARPOW(I8,2,UI2,3,R8,8.0);
7027         VARPOW(I8,2,UI4,3,R8,8.0);
7028         VARPOW(I8,2,I8,3,R8,8.0);
7029         VARPOW(I8,2,UI8,3,R8,8.0);
7030         VARPOW(I8,2,INT,3,R8,8.0);
7031         VARPOW(I8,2,UINT,3,R8,8.0);
7032         VARPOW(UI8,2,EMPTY,0,R8,1.0);
7033         VARPOW(UI8,2,NULL,0,NULL,0);
7034         VARPOW(UI8,2,I2,3,R8,8.0);
7035         VARPOW(UI8,2,I4,3,R8,8.0);
7036         VARPOW(UI8,2,R4,3.0f,R8,8.0);
7037         VARPOW(UI8,2,R8,3.0,R8,8.0);
7038         VARPOW(UI8,2,DATE,3,R8,8.0);
7039         VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
7040         VARPOW(UI8,2,I1,3,R8,8.0);
7041         VARPOW(UI8,2,UI1,3,R8,8.0);
7042         VARPOW(UI8,2,UI2,3,R8,8.0);
7043         VARPOW(UI8,2,UI4,3,R8,8.0);
7044         VARPOW(UI8,2,I8,3,R8,8.0);
7045         VARPOW(UI8,2,UI8,3,R8,8.0);
7046         VARPOW(UI8,2,INT,3,R8,8.0);
7047         VARPOW(UI8,2,UINT,3,R8,8.0);
7048     }
7049     VARPOW(INT,2,EMPTY,0,R8,1.0);
7050     VARPOW(INT,2,NULL,0,NULL,0);
7051     VARPOW(INT,2,I2,3,R8,8.0);
7052     VARPOW(INT,2,I4,3,R8,8.0);
7053     VARPOW(INT,2,R4,3.0f,R8,8.0);
7054     VARPOW(INT,2,R8,3.0,R8,8.0);
7055     VARPOW(INT,2,DATE,3,R8,8.0);
7056     VARPOW(INT,2,BSTR,num3_str,R8,8.0);
7057     VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
7058     VARPOW(INT,2,I1,3,R8,8.0);
7059     VARPOW(INT,2,UI1,3,R8,8.0);
7060     VARPOW(INT,2,UI2,3,R8,8.0);
7061     VARPOW(INT,2,UI4,3,R8,8.0);
7062     if (HAVE_OLEAUT32_I8)
7063     {
7064         VARPOW(INT,2,I8,3,R8,8.0);
7065         VARPOW(INT,2,UI8,3,R8,8.0);
7066     }
7067     VARPOW(INT,2,INT,3,R8,8.0);
7068     VARPOW(INT,2,UINT,3,R8,8.0);
7069     VARPOW(UINT,2,EMPTY,0,R8,1.0);
7070     VARPOW(UINT,2,NULL,0,NULL,0);
7071     VARPOW(UINT,2,I2,3,R8,8.0);
7072     VARPOW(UINT,2,I4,3,R8,8.0);
7073     VARPOW(UINT,2,R4,3.0f,R8,8.0);
7074     VARPOW(UINT,2,R8,3.0,R8,8.0);
7075     VARPOW(UINT,2,DATE,3,R8,8.0);
7076     VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
7077     VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
7078     VARPOW(UINT,2,I1,3,R8,8.0);
7079     VARPOW(UINT,2,UI1,3,R8,8.0);
7080     VARPOW(UINT,2,UI2,3,R8,8.0);
7081     VARPOW(UINT,2,UI4,3,R8,8.0);
7082     if (HAVE_OLEAUT32_I8)
7083     {
7084         VARPOW(UINT,2,I8,3,R8,8.0);
7085         VARPOW(UINT,2,UI8,3,R8,8.0);
7086     }
7087     VARPOW(UINT,2,INT,3,R8,8.0);
7088     VARPOW(UINT,2,UINT,3,R8,8.0);
7089
7090     /* Manually test some VT_CY, VT_DECIMAL variants */
7091     V_VT(&cy) = VT_CY;
7092     hres = VarCyFromI4(2, &V_CY(&cy));
7093     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7094     V_VT(&dec) = VT_DECIMAL;
7095     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7096     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7097     memset(&left, 0, sizeof(left));
7098     memset(&right, 0, sizeof(right));
7099     V_VT(&left) = VT_I4;
7100     V_I4(&left) = 100;
7101     V_VT(&right) = VT_I8;
7102     V_UI1(&right) = 2;
7103
7104     hres = pVarPow(&cy, &cy, &result);
7105     ok(hres == S_OK && V_VT(&result) == VT_R8,
7106         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7107         S_OK, hres, vtstr(V_VT(&result)));
7108     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7109         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7110
7111     hres = pVarPow(&cy, &right, &result);
7112     if (hres == S_OK)
7113     {
7114         ok(hres == S_OK && V_VT(&result) == VT_R8,
7115            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7116            S_OK, hres, vtstr(V_VT(&result)));
7117         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7118            "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7119     }
7120     else
7121     {
7122         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7123            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7124            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7125     }
7126
7127     hres = pVarPow(&left, &cy, &result);
7128     ok(hres == S_OK && V_VT(&result) == VT_R8,
7129         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7130         S_OK, hres, vtstr(V_VT(&result)));
7131     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
7132         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
7133
7134     hres = pVarPow(&left, &dec, &result);
7135     ok(hres == S_OK && V_VT(&result) == VT_R8,
7136         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7137         S_OK, hres, vtstr(V_VT(&result)));
7138     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
7139         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
7140
7141     hres = pVarPow(&dec, &dec, &result);
7142     ok(hres == S_OK && V_VT(&result) == VT_R8,
7143         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7144         S_OK, hres, vtstr(V_VT(&result)));
7145     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7146         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7147
7148     hres = pVarPow(&dec, &right, &result);
7149     if (hres == S_OK)
7150     {
7151         ok(hres == S_OK && V_VT(&result) == VT_R8,
7152            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7153            S_OK, hres, vtstr(V_VT(&result)));
7154         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7155            "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7156     }
7157     else
7158     {
7159         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7160            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7161            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7162     }
7163
7164     SysFreeString(num2_str);
7165     SysFreeString(num3_str);
7166 }
7167
7168 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7169
7170 #define VARDIV(vt1,val1,vt2,val2,rvt,rval)               \
7171         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7172         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7173         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7174         test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
7175
7176 /* Skip any type that is not defined or produces an error for every case */
7177 #define SKIPTESTDIV(a)                            \
7178     if (a == VT_ERROR || a == VT_VARIANT ||       \
7179         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7180         a == VT_RECORD || a > VT_UINT ||          \
7181         a == VT_I1 || a == VT_UI8 ||              \
7182         a == VT_INT || a == VT_UINT ||            \
7183         a == VT_UI2 || a == VT_UI4 ||             \
7184         a == 15 /*not defined*/)                  \
7185         continue
7186
7187 static void test_VarDiv(void)
7188 {
7189     static const WCHAR str1[] = { '1','\0' };
7190     static const WCHAR str2[] = { '2','\0' };
7191     VARIANT left, right, exp, result, cy, dec;
7192     BSTR num1_str, num2_str;
7193     VARTYPE i;
7194     HRESULT hres;
7195     double r;
7196
7197     num1_str = SysAllocString(str1);
7198     num2_str = SysAllocString(str2);
7199
7200     CHECKPTR(VarDiv);
7201
7202     /* Test all possible flag/vt combinations & the resulting vt type */
7203     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7204     {
7205         VARTYPE leftvt, rightvt, resvt;
7206
7207         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7208         {
7209             SKIPTESTDIV(leftvt);
7210
7211             /* Check if we need/have support for I8 */
7212             if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
7213                 continue;
7214
7215             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7216             {
7217                 BOOL bFail = FALSE;
7218                 SKIPTESTDIV(rightvt);
7219
7220                 /* Check if we need/have support for I8 */
7221                 if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
7222                     continue;
7223
7224                 /* Native crashes with VT_BYREF */
7225                 if (ExtraFlags[i] == VT_BYREF)
7226                     continue;
7227
7228                 memset(&left, 0, sizeof(left));
7229                 memset(&right, 0, sizeof(right));
7230                 V_VT(&left) = leftvt | ExtraFlags[i];
7231                 V_VT(&right) = rightvt | ExtraFlags[i];
7232                 V_VT(&result) = VT_EMPTY;
7233                 resvt = VT_EMPTY;
7234
7235                 if (leftvt == VT_BSTR)
7236                     V_BSTR(&left) = num2_str;
7237                 else if (leftvt == VT_DECIMAL)
7238                 {
7239                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7240                     V_VT(&left) = leftvt | ExtraFlags[i];
7241                 }
7242
7243                 /* Division by 0 is undefined */
7244                 switch(rightvt)
7245                 {
7246                 case VT_BSTR:
7247                     V_BSTR(&right) = num2_str;
7248                     break;
7249                 case VT_DECIMAL:
7250                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7251                     V_VT(&right) = rightvt | ExtraFlags[i];
7252                     break;
7253                 case VT_BOOL:
7254                     V_BOOL(&right) = VARIANT_TRUE;
7255                     break;
7256                 case VT_I2: V_I2(&right) = 2; break;
7257                 case VT_I4: V_I4(&right) = 2; break;
7258                 case VT_R4: V_R4(&right) = 2.0f; break;
7259                 case VT_R8: V_R8(&right) = 2.0; break;
7260                 case VT_CY: V_CY(&right).int64 = 2; break;
7261                 case VT_DATE: V_DATE(&right) = 2; break;
7262                 case VT_UI1: V_UI1(&right) = 2; break;
7263                 case VT_I8: V_I8(&right) = 2; break;
7264                 default: break;
7265                 }
7266
7267                 /* Determine return type */
7268                 if (!(rightvt == VT_EMPTY))
7269                 {
7270                     if (leftvt == VT_NULL || rightvt == VT_NULL)
7271                         resvt = VT_NULL;
7272                     else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
7273                         resvt = VT_DECIMAL;
7274                     else if (leftvt == VT_I8 || rightvt == VT_I8 ||
7275                         leftvt == VT_CY || rightvt == VT_CY ||
7276                         leftvt == VT_DATE || rightvt == VT_DATE ||
7277                         leftvt == VT_I4 || rightvt == VT_I4 ||
7278                         leftvt == VT_BSTR || rightvt == VT_BSTR ||
7279                         leftvt == VT_I2 || rightvt == VT_I2 ||
7280                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
7281                         leftvt == VT_R8 || rightvt == VT_R8 ||
7282                         leftvt == VT_UI1 || rightvt == VT_UI1)
7283                     {
7284                         if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
7285                             (leftvt == VT_R4 && rightvt == VT_UI1))
7286                             resvt = VT_R4;
7287                         else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
7288                             rightvt == VT_I2)) || (rightvt == VT_R4 &&
7289                             (leftvt == VT_BOOL || leftvt == VT_I2)))
7290                             resvt = VT_R4;
7291                         else
7292                             resvt = VT_R8;
7293                     }
7294                     else if (leftvt == VT_R4 || rightvt == VT_R4)
7295                         resvt = VT_R4;
7296                 }
7297                 else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
7298                     resvt = VT_NULL;
7299                 else
7300                     bFail = TRUE;
7301
7302                 /* Native VarDiv always returns an error when using extra flags */
7303                 if (ExtraFlags[i] != 0)
7304                     bFail = TRUE;
7305
7306                 hres = pVarDiv(&left, &right, &result);
7307
7308                 /* Check expected HRESULT and if result variant type is correct */
7309                 if (bFail)
7310                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7311                         hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
7312                         "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7313                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7314                         vtstr(V_VT(&result)), hres);
7315                 else
7316                     ok (hres == S_OK && resvt == V_VT(&result),
7317                         "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7318                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7319                         S_OK, vtstr(V_VT(&result)), hres);
7320             }
7321         }
7322     }
7323
7324     /* Test return values for all the good cases */
7325     VARDIV(EMPTY,0,NULL,0,NULL,0);
7326     VARDIV(EMPTY,0,I2,2,R8,0.0);
7327     VARDIV(EMPTY,0,I4,2,R8,0.0);
7328     VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
7329     VARDIV(EMPTY,0,R8,2.0,R8,0.0);
7330     VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
7331     VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
7332     VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
7333     VARDIV(EMPTY,0,UI1,2,R8,0.0);
7334     if (HAVE_OLEAUT32_I8)
7335     {
7336         VARDIV(EMPTY,0,I8,2,R8,0.0);
7337     }
7338     VARDIV(NULL,0,EMPTY,0,NULL,0);
7339     VARDIV(NULL,0,NULL,0,NULL,0);
7340     VARDIV(NULL,0,I2,2,NULL,0);
7341     VARDIV(NULL,0,I4,2,NULL,0);
7342     VARDIV(NULL,0,R4,2.0f,NULL,0);
7343     VARDIV(NULL,0,R8,2.0,NULL,0);
7344     VARDIV(NULL,0,DATE,2,NULL,0);
7345     VARDIV(NULL,0,BSTR,num2_str,NULL,0);
7346     VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7347     VARDIV(NULL,0,UI1,2,NULL,0);
7348     if (HAVE_OLEAUT32_I8)
7349     {
7350         VARDIV(NULL,0,I8,2,NULL,0);
7351     }
7352     VARDIV(I2,2,NULL,0,NULL,0);
7353     VARDIV(I2,1,I2,2,R8,0.5);
7354     VARDIV(I2,1,I4,2,R8,0.5);
7355     VARDIV(I2,1,R4,2,R4,0.5f);
7356     VARDIV(I2,1,R8,2.0,R8,0.5);
7357     VARDIV(I2,1,DATE,2,R8,0.5);
7358     VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
7359     VARDIV(I2,1,UI1,2,R8,0.5);
7360     if (HAVE_OLEAUT32_I8)
7361     {
7362         VARDIV(I2,1,I8,2,R8,0.5);
7363     }
7364     VARDIV(I4,1,NULL,0,NULL,0);
7365     VARDIV(I4,1,I2,2,R8,0.5);
7366     VARDIV(I4,1,I4,2,R8,0.5);
7367     VARDIV(I4,1,R4,2.0f,R8,0.5);
7368     VARDIV(I4,1,R8,2.0,R8,0.5);
7369     VARDIV(I4,1,DATE,2,R8,0.5);
7370     VARDIV(I4,1,BSTR,num2_str,R8,0.5);
7371     VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
7372     VARDIV(I4,1,UI1,2,R8,0.5);
7373     if (HAVE_OLEAUT32_I8)
7374     {
7375         VARDIV(I4,1,I8,2,R8,0.5);
7376     }
7377     VARDIV(R4,1.0f,NULL,0,NULL,0);
7378     VARDIV(R4,1.0f,I2,2,R4,0.5f);
7379     VARDIV(R4,1.0f,I4,2,R8,0.5);
7380     VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
7381     VARDIV(R4,1.0f,R8,2.0,R8,0.5);
7382     VARDIV(R4,1.0f,DATE,2,R8,0.5);
7383     VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
7384     VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
7385     VARDIV(R4,1.0f,UI1,2,R4,0.5f);
7386     if (HAVE_OLEAUT32_I8)
7387     {
7388         VARDIV(R4,1.0f,I8,2,R8,0.5);
7389     }
7390     VARDIV(R8,1.0,NULL,0,NULL,0);
7391     VARDIV(R8,1.0,I2,2,R8,0.5);
7392     VARDIV(R8,1.0,I4,2,R8,0.5);
7393     VARDIV(R8,1.0,R4,2.0f,R8,0.5);
7394     VARDIV(R8,1.0,R8,2.0,R8,0.5);
7395     VARDIV(R8,1.0,DATE,2,R8,0.5);
7396     VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
7397     VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
7398     VARDIV(R8,1.0,UI1,2,R8,0.5);
7399     if (HAVE_OLEAUT32_I8)
7400     {
7401         VARDIV(R8,1.0,I8,2,R8,0.5);
7402     }
7403     VARDIV(DATE,1,NULL,0,NULL,0);
7404     VARDIV(DATE,1,I2,2,R8,0.5);
7405     VARDIV(DATE,1,I4,2,R8,0.5);
7406     VARDIV(DATE,1,R4,2.0f,R8,0.5);
7407     VARDIV(DATE,1,R8,2.0,R8,0.5);
7408     VARDIV(DATE,1,DATE,2,R8,0.5);
7409     VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
7410     VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
7411     VARDIV(DATE,1,UI1,2,R8,0.5);
7412     if (HAVE_OLEAUT32_I8)
7413     {
7414         VARDIV(DATE,1,I8,2,R8,0.5);
7415     }
7416     VARDIV(BSTR,num1_str,NULL,0,NULL,0);
7417     VARDIV(BSTR,num1_str,I2,2,R8,0.5);
7418     VARDIV(BSTR,num1_str,I4,2,R8,0.5);
7419     VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
7420     VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
7421     VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
7422     VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
7423     VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
7424     VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
7425     if (HAVE_OLEAUT32_I8)
7426     {
7427         VARDIV(BSTR,num1_str,I8,2,R8,0.5);
7428     }
7429     VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7430     VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
7431     VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
7432     VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
7433     VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
7434     VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
7435     VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
7436     VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
7437     VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
7438     VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
7439     VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
7440     VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
7441     VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
7442     VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
7443     if (HAVE_OLEAUT32_I8)
7444     {
7445         VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
7446     }
7447     VARDIV(UI1,1,NULL,0,NULL,0);
7448     VARDIV(UI1,1,I2,2,R8,0.5);
7449     VARDIV(UI1,1,I4,2,R8,0.5);
7450     VARDIV(UI1,1,R4,2.0f,R4,0.5f);
7451     VARDIV(UI1,1,R8,2.0,R8,0.5);
7452     VARDIV(UI1,1,DATE,2,R8,0.5);
7453     VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
7454     VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
7455     VARDIV(UI1,1,UI1,2,R8,0.5);
7456     if (HAVE_OLEAUT32_I8)
7457     {
7458         VARDIV(UI1,1,I8,2,R8,0.5);
7459         VARDIV(I8,1,NULL,0,NULL,0);
7460         VARDIV(I8,1,I2,2,R8,0.5);
7461         VARDIV(I8,1,I4,2,R8,0.5);
7462         VARDIV(I8,1,R4,2.0f,R8,0.5);
7463         VARDIV(I8,1,R8,2.0,R8,0.5);
7464         VARDIV(I8,1,DATE,2,R8,0.5);
7465         VARDIV(I8,1,BSTR,num2_str,R8,0.5);
7466         VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
7467         VARDIV(I8,1,UI1,2,R8,0.5);
7468         VARDIV(I8,1,I8,2,R8,0.5);
7469     }
7470
7471     /* Manually test some VT_CY, VT_DECIMAL variants */
7472     V_VT(&cy) = VT_CY;
7473     hres = VarCyFromI4(10000, &V_CY(&cy));
7474     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7475     V_VT(&dec) = VT_DECIMAL;
7476     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7477     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7478     memset(&left, 0, sizeof(left));
7479     memset(&right, 0, sizeof(right));
7480     V_VT(&left) = VT_I4;
7481     V_I4(&left) = 100;
7482     V_VT(&right) = VT_UI1;
7483     V_UI1(&right) = 2;
7484
7485     hres = pVarDiv(&cy, &cy, &result);
7486     ok(hres == S_OK && V_VT(&result) == VT_R8,
7487         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7488     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
7489         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
7490
7491     hres = pVarDiv(&cy, &right, &result);
7492     ok(hres == S_OK && V_VT(&result) == VT_R8,
7493         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7494     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
7495         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
7496
7497     hres = pVarDiv(&left, &cy, &result);
7498     ok(hres == S_OK && V_VT(&result) == VT_R8,
7499         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7500     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
7501         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
7502
7503     hres = pVarDiv(&left, &dec, &result);
7504     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7505         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7506     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7507     ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
7508         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
7509
7510     hres = pVarDiv(&dec, &dec, &result);
7511     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7512         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7513     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7514     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7515         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7516
7517     hres = pVarDiv(&dec, &right, &result);
7518     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7519         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7520     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7521     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7522         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7523
7524     /* Check for division by zero and overflow */
7525     V_VT(&left) = VT_R8;
7526     V_I4(&left) = 1;
7527     V_VT(&right) = VT_R8;
7528     V_I4(&right) = 0;
7529     hres = pVarDiv(&left, &right, &result);
7530     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7531         "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7532
7533     V_VT(&left) = VT_R8;
7534     V_I4(&left) = 0;
7535     V_VT(&right) = VT_R8;
7536     V_I4(&right) = 0;
7537     hres = pVarDiv(&left, &right, &result);
7538     ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
7539         "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%X\n", hres);
7540
7541     SysFreeString(num1_str);
7542     SysFreeString(num2_str);
7543 }
7544
7545 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7546
7547 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval)              \
7548         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7549         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7550         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7551         test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
7552
7553 /* Skip any type that is not defined or produces an error for every case */
7554 #define SKIPTESTIDIV(a)                           \
7555     if (a == VT_ERROR || a == VT_VARIANT ||       \
7556         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7557         a == VT_RECORD || a > VT_UINT ||          \
7558         a == 15 /*not defined*/)                  \
7559         continue
7560
7561 static void test_VarIdiv(void)
7562 {
7563     static const WCHAR str1[] = { '1','\0' };
7564     static const WCHAR str2[] = { '2','\0' };
7565     VARIANT left, right, exp, result, cy, dec;
7566     BSTR num1_str, num2_str;
7567     VARTYPE i;
7568     HRESULT hres;
7569
7570     CHECKPTR(VarIdiv);
7571
7572     num1_str = SysAllocString(str1);
7573     num2_str = SysAllocString(str2);
7574
7575     /* Test all possible flag/vt combinations & the resulting vt type */
7576     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7577     {
7578         VARTYPE leftvt, rightvt, resvt;
7579
7580         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7581         {
7582             SKIPTESTIDIV(leftvt);
7583
7584             /* Check if we need/have support for I8 and/or UI8 */
7585             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7586                 continue;
7587
7588             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7589             {
7590                 BOOL bFail = FALSE;
7591                 SKIPTESTIDIV(rightvt);
7592
7593                 /* Native crashes with extra flag VT_BYREF */
7594                 if (ExtraFlags[i] == VT_BYREF)
7595                     continue;
7596
7597                 /* Check if we need/have support for I8 and/or UI8 */
7598                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7599                     continue;
7600
7601                 memset(&left, 0, sizeof(left));
7602                 memset(&right, 0, sizeof(right));
7603                 V_VT(&left) = leftvt | ExtraFlags[i];
7604                 V_VT(&right) = rightvt | ExtraFlags[i];
7605                 V_VT(&result) = VT_EMPTY;
7606                 resvt = VT_EMPTY;
7607
7608                 if (leftvt == VT_BSTR)
7609                     V_BSTR(&left) = num2_str;
7610                 else if (leftvt == VT_DECIMAL)
7611                 {
7612                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7613                     V_VT(&left) = leftvt | ExtraFlags[i];
7614                 }
7615
7616                 /* Division by 0 is undefined */
7617                 switch(rightvt)
7618                 {
7619                 case VT_BSTR:
7620                     V_BSTR(&right) = num2_str;
7621                     break;
7622                 case VT_DECIMAL:
7623                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7624                     V_VT(&right) = rightvt | ExtraFlags[i];
7625                     break;
7626                 case VT_BOOL:
7627                     V_BOOL(&right) = VARIANT_TRUE;
7628                     break;
7629                 case VT_CY:
7630                     VarCyFromI4(10000, &V_CY(&right));
7631                     V_VT(&right) = rightvt | ExtraFlags[i];
7632                     break;
7633                 case VT_I2: V_I2(&right) = 2; break;
7634                 case VT_I4: V_I4(&right) = 2; break;
7635                 case VT_R4: V_R4(&right) = 2.0f; break;
7636                 case VT_R8: V_R8(&right) = 2.0; break;
7637                 case VT_DATE: V_DATE(&right) = 2; break;
7638                 case VT_I1: V_I1(&right) = 2; break;
7639                 case VT_UI1: V_UI1(&right) = 2; break;
7640                 case VT_UI2: V_UI2(&right) = 2; break;
7641                 case VT_UI4: V_UI4(&right) = 2; break;
7642                 case VT_I8: V_I8(&right) = 2; break;
7643                 case VT_UI8: V_UI8(&right) = 2; break;
7644                 case VT_INT: V_INT(&right) = 2; break;
7645                 case VT_UINT: V_UINT(&right) = 2; break;
7646                 default: break;
7647                 }
7648
7649                 /* Native VarIdiv always returns an error when using extra
7650                  * flags or if the variant combination is I8 and INT.
7651                  */
7652                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
7653                     (leftvt == VT_INT && rightvt == VT_I8) ||
7654                     (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
7655                     ExtraFlags[i] != 0)
7656                     bFail = TRUE;
7657
7658                 /* Determine variant type */
7659                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
7660                     resvt = VT_NULL;
7661                 else if (leftvt == VT_I8 || rightvt == VT_I8)
7662                     resvt = VT_I8;
7663                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
7664                     leftvt == VT_INT || rightvt == VT_INT ||
7665                     leftvt == VT_UINT || rightvt == VT_UINT ||
7666                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
7667                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
7668                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
7669                     leftvt == VT_I1 || rightvt == VT_I1 ||
7670                     leftvt == VT_BSTR || rightvt == VT_BSTR ||
7671                     leftvt == VT_DATE || rightvt == VT_DATE ||
7672                     leftvt == VT_CY || rightvt == VT_CY ||
7673                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
7674                     leftvt == VT_R8 || rightvt == VT_R8 ||
7675                     leftvt == VT_R4 || rightvt == VT_R4)
7676                     resvt = VT_I4;
7677                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
7678                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
7679                     leftvt == VT_EMPTY)
7680                     resvt = VT_I2;
7681                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
7682                     resvt = VT_UI1;
7683                 else
7684                     bFail = TRUE;
7685
7686                 hres = pVarIdiv(&left, &right, &result);
7687
7688                 /* Check expected HRESULT and if result variant type is correct */
7689                 if (bFail)
7690                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7691                         hres == DISP_E_DIVBYZERO,
7692                         "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7693                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7694                         vtstr(V_VT(&result)), hres);
7695                 else
7696                     ok (hres == S_OK && resvt == V_VT(&result),
7697                         "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7698                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7699                         S_OK, vtstr(V_VT(&result)), hres);
7700             }
7701         }
7702     }
7703
7704     /* Test return values for all the good cases */
7705     VARIDIV(EMPTY,0,NULL,0,NULL,0);
7706     VARIDIV(EMPTY,0,I2,1,I2,0);
7707     VARIDIV(EMPTY,0,I4,1,I4,0);
7708     VARIDIV(EMPTY,0,R4,1.0f,I4,0);
7709     VARIDIV(EMPTY,0,R8,1.0,I4,0);
7710     VARIDIV(EMPTY,0,DATE,1.0,I4,0);
7711     VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
7712     VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
7713     VARIDIV(EMPTY,0,I1,1,I4,0);
7714     VARIDIV(EMPTY,0,UI1,1,I2,0);
7715     VARIDIV(EMPTY,0,UI2,1,I4,0);
7716     VARIDIV(EMPTY,0,UI4,1,I4,0);
7717     if (HAVE_OLEAUT32_I8)
7718     {
7719         VARIDIV(EMPTY,0,I8,1,I8,0);
7720         VARIDIV(EMPTY,0,UI8,1,I4,0);
7721     }
7722     VARIDIV(EMPTY,0,INT,1,I4,0);
7723     VARIDIV(EMPTY,0,UINT,1,I4,0);
7724     VARIDIV(NULL,0,EMPTY,0,NULL,0);
7725     VARIDIV(NULL,0,NULL,0,NULL,0);
7726     VARIDIV(NULL,0,I2,1,NULL,0);
7727     VARIDIV(NULL,0,I4,1,NULL,0);
7728     VARIDIV(NULL,0,R4,1,NULL,0);
7729     VARIDIV(NULL,0,R8,1,NULL,0);
7730     VARIDIV(NULL,0,DATE,1,NULL,0);
7731     VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
7732     VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7733     VARIDIV(NULL,0,I1,1,NULL,0);
7734     VARIDIV(NULL,0,UI1,1,NULL,0);
7735     VARIDIV(NULL,0,UI2,1,NULL,0);
7736     VARIDIV(NULL,0,UI4,1,NULL,0);
7737     if (HAVE_OLEAUT32_I8)
7738     {
7739         VARIDIV(NULL,0,I8,1,NULL,0);
7740         VARIDIV(NULL,0,UI8,1,NULL,0);
7741     }
7742     VARIDIV(NULL,0,INT,1,NULL,0);
7743     VARIDIV(NULL,0,UINT,1,NULL,0);
7744     VARIDIV(I2,2,NULL,0,NULL,0);
7745     VARIDIV(I2,2,I2,1,I2,2);
7746     VARIDIV(I2,2,I4,1,I4,2);
7747     VARIDIV(I2,2,R4,1,I4,2);
7748     VARIDIV(I2,2,R8,1,I4,2);
7749     VARIDIV(I2,2,DATE,1,I4,2);
7750     VARIDIV(I2,2,BSTR,num1_str,I4,2);
7751     VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
7752     VARIDIV(I2,2,I1,1,I4,2);
7753     VARIDIV(I2,2,UI1,1,I2,2);
7754     VARIDIV(I2,2,UI2,1,I4,2);
7755     VARIDIV(I2,2,UI4,1,I4,2);
7756     if (HAVE_OLEAUT32_I8)
7757     {
7758         VARIDIV(I2,2,I8,1,I8,2);
7759         VARIDIV(I2,2,UI8,1,I4,2);
7760     }
7761     VARIDIV(I2,2,INT,1,I4,2);
7762     VARIDIV(I2,2,UINT,1,I4,2);
7763     VARIDIV(I4,2,NULL,0,NULL,0);
7764     VARIDIV(I4,2,I2,1,I4,2);
7765     VARIDIV(I4,2,I4,1,I4,2);
7766     VARIDIV(I4,2,R4,1,I4,2);
7767     VARIDIV(I4,2,R8,1,I4,2);
7768     VARIDIV(I4,2,DATE,1,I4,2);
7769     VARIDIV(I4,2,BSTR,num1_str,I4,2);
7770     VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
7771     VARIDIV(I4,2,I1,1,I4,2);
7772     VARIDIV(I4,2,UI1,1,I4,2);
7773     VARIDIV(I4,2,UI2,1,I4,2);
7774     VARIDIV(I4,2,UI4,1,I4,2);
7775     if (HAVE_OLEAUT32_I8)
7776     {
7777         VARIDIV(I4,2,I8,1,I8,2);
7778         VARIDIV(I4,2,UI8,1,I4,2);
7779     }
7780     VARIDIV(I4,2,INT,1,I4,2);
7781     VARIDIV(I4,2,UINT,1,I4,2);
7782     VARIDIV(R4,2.0f,NULL,0,NULL,0);
7783     VARIDIV(R4,2.0f,I2,1,I4,2);
7784     VARIDIV(R4,2.0f,I4,1,I4,2);
7785     VARIDIV(R4,2.0f,R4,1.0f,I4,2);
7786     VARIDIV(R4,2.0f,R8,1.0,I4,2);
7787     VARIDIV(R4,2.0f,DATE,1,I4,2);
7788     VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
7789     VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
7790     VARIDIV(R4,2.0f,I1,1,I4,2);
7791     VARIDIV(R4,2.0f,UI1,1,I4,2);
7792     VARIDIV(R4,2.0f,UI2,1,I4,2);
7793     VARIDIV(R4,2.0f,UI4,1,I4,2);
7794     if (HAVE_OLEAUT32_I8)
7795     {
7796         VARIDIV(R4,2.0f,I8,1,I8,2);
7797         VARIDIV(R4,2.0f,UI8,1,I4,2);
7798     }
7799     VARIDIV(R4,2.0f,INT,1,I4,2);
7800     VARIDIV(R4,2.0f,UINT,1,I4,2);
7801     VARIDIV(R8,2.0,NULL,0,NULL,0);
7802     VARIDIV(R8,2.0,I2,1,I4,2);
7803     VARIDIV(R8,2.0,I4,1,I4,2);
7804     VARIDIV(R8,2.0,R4,1,I4,2);
7805     VARIDIV(R8,2.0,R8,1,I4,2);
7806     VARIDIV(R8,2.0,DATE,1,I4,2);
7807     VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
7808     VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
7809     VARIDIV(R8,2.0,I1,1,I4,2);
7810     VARIDIV(R8,2.0,UI1,1,I4,2);
7811     VARIDIV(R8,2.0,UI2,1,I4,2);
7812     VARIDIV(R8,2.0,UI4,1,I4,2);
7813     if (HAVE_OLEAUT32_I8)
7814     {
7815         VARIDIV(R8,2.0,I8,1,I8,2);
7816         VARIDIV(R8,2.0,UI8,1,I4,2);
7817     }
7818     VARIDIV(R8,2.0,INT,1,I4,2);
7819     VARIDIV(R8,2.0,UINT,1,I4,2);
7820     VARIDIV(DATE,2,NULL,0,NULL,0);
7821     VARIDIV(DATE,2,I2,1,I4,2);
7822     VARIDIV(DATE,2,I4,1,I4,2);
7823     VARIDIV(DATE,2,R4,1,I4,2);
7824     VARIDIV(DATE,2,R8,1,I4,2);
7825     VARIDIV(DATE,2,DATE,1,I4,2);
7826     VARIDIV(DATE,2,BSTR,num1_str,I4,2);
7827     VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
7828     VARIDIV(DATE,2,I1,1,I4,2);
7829     VARIDIV(DATE,2,UI1,1,I4,2);
7830     VARIDIV(DATE,2,UI2,1,I4,2);
7831     VARIDIV(DATE,2,UI4,1,I4,2);
7832     if (HAVE_OLEAUT32_I8)
7833     {
7834         VARIDIV(DATE,2,I8,1,I8,2);
7835         VARIDIV(DATE,2,UI8,1,I4,2);
7836     }
7837     VARIDIV(DATE,2,INT,1,I4,2);
7838     VARIDIV(DATE,2,UINT,1,I4,2);
7839     VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
7840     VARIDIV(BSTR,num2_str,I2,1,I4,2);
7841     VARIDIV(BSTR,num2_str,I4,1,I4,2);
7842     VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
7843     VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
7844     VARIDIV(BSTR,num2_str,DATE,1,I4,2);
7845     VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
7846     VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
7847     VARIDIV(BSTR,num2_str,I1,1,I4,2);
7848     VARIDIV(BSTR,num2_str,UI1,1,I4,2);
7849     VARIDIV(BSTR,num2_str,UI2,1,I4,2);
7850     VARIDIV(BSTR,num2_str,UI4,1,I4,2);
7851     if (HAVE_OLEAUT32_I8)
7852     {
7853         VARIDIV(BSTR,num2_str,I8,1,I8,2);
7854         VARIDIV(BSTR,num2_str,UI8,1,I4,2);
7855     }
7856     VARIDIV(BSTR,num2_str,INT,1,I4,2);
7857     VARIDIV(BSTR,num2_str,UINT,1,I4,2);
7858     VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7859     VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
7860     VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
7861     VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
7862     VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
7863     VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
7864     VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
7865     VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
7866     VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
7867     VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
7868     VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
7869     VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
7870     if (HAVE_OLEAUT32_I8)
7871     {
7872         VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
7873         VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
7874     }
7875     VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
7876     VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
7877     VARIDIV(I1,2,NULL,0,NULL,0);
7878     VARIDIV(I1,2,I2,1,I4,2);
7879     VARIDIV(I1,2,I4,1,I4,2);
7880     VARIDIV(I1,2,R4,1.0f,I4,2);
7881     VARIDIV(I1,2,R8,1.0,I4,2);
7882     VARIDIV(I1,2,DATE,1,I4,2);
7883     VARIDIV(I1,2,BSTR,num1_str,I4,2);
7884     VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
7885     VARIDIV(I1,2,I1,1,I4,2);
7886     VARIDIV(I1,2,UI1,1,I4,2);
7887     VARIDIV(I1,2,UI2,1,I4,2);
7888     VARIDIV(I1,2,UI4,1,I4,2);
7889     if (HAVE_OLEAUT32_I8)
7890     {
7891         VARIDIV(I1,2,I8,1,I8,2);
7892         VARIDIV(I1,2,UI8,1,I4,2);
7893     }
7894     VARIDIV(I1,2,INT,1,I4,2);
7895     VARIDIV(I1,2,UINT,1,I4,2);
7896     VARIDIV(UI1,2,NULL,0,NULL,0);
7897     VARIDIV(UI1,2,I2,1,I2,2);
7898     VARIDIV(UI1,2,I4,1,I4,2);
7899     VARIDIV(UI1,2,R4,1.0f,I4,2);
7900     VARIDIV(UI1,2,R8,1.0,I4,2);
7901     VARIDIV(UI1,2,DATE,1,I4,2);
7902     VARIDIV(UI1,2,BSTR,num1_str,I4,2);
7903     VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
7904     VARIDIV(UI1,2,I1,1,I4,2);
7905     VARIDIV(UI1,2,UI1,1,UI1,2);
7906     VARIDIV(UI1,2,UI2,1,I4,2);
7907     VARIDIV(UI1,2,UI4,1,I4,2);
7908     if (HAVE_OLEAUT32_I8)
7909     {
7910         VARIDIV(UI1,2,I8,1,I8,2);
7911         VARIDIV(UI1,2,UI8,1,I4,2);
7912     }
7913     VARIDIV(UI1,2,INT,1,I4,2);
7914     VARIDIV(UI1,2,UINT,1,I4,2);
7915     VARIDIV(UI2,2,NULL,0,NULL,0);
7916     VARIDIV(UI2,2,I2,1,I4,2);
7917     VARIDIV(UI2,2,I4,1,I4,2);
7918     VARIDIV(UI2,2,R4,1.0f,I4,2);
7919     VARIDIV(UI2,2,R8,1.0,I4,2);
7920     VARIDIV(UI2,2,DATE,1,I4,2);
7921     VARIDIV(UI2,2,BSTR,num1_str,I4,2);
7922     VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
7923     VARIDIV(UI2,2,I1,1,I4,2);
7924     VARIDIV(UI2,2,UI1,1,I4,2);
7925     VARIDIV(UI2,2,UI2,1,I4,2);
7926     VARIDIV(UI2,2,UI4,1,I4,2);
7927     if (HAVE_OLEAUT32_I8)
7928     {
7929         VARIDIV(UI2,2,I8,1,I8,2);
7930         VARIDIV(UI2,2,UI8,1,I4,2);
7931     }
7932     VARIDIV(UI2,2,INT,1,I4,2);
7933     VARIDIV(UI2,2,UINT,1,I4,2);
7934     VARIDIV(UI4,2,NULL,0,NULL,0);
7935     VARIDIV(UI4,2,I2,1,I4,2);
7936     VARIDIV(UI4,2,I4,1,I4,2);
7937     VARIDIV(UI4,2,R4,1.0f,I4,2);
7938     VARIDIV(UI4,2,R8,1.0,I4,2);
7939     VARIDIV(UI4,2,DATE,1,I4,2);
7940     VARIDIV(UI4,2,BSTR,num1_str,I4,2);
7941     VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
7942     VARIDIV(UI4,2,I1,1,I4,2);
7943     VARIDIV(UI4,2,UI1,1,I4,2);
7944     VARIDIV(UI4,2,UI2,1,I4,2);
7945     VARIDIV(UI4,2,UI4,1,I4,2);
7946     if (HAVE_OLEAUT32_I8)
7947     {
7948         VARIDIV(UI4,2,I8,1,I8,2);
7949         VARIDIV(UI4,2,UI8,1,I4,2);
7950     }
7951     VARIDIV(UI4,2,INT,1,I4,2);
7952     VARIDIV(UI4,2,UINT,1,I4,2);
7953     if (HAVE_OLEAUT32_I8)
7954     {
7955         VARIDIV(I8,2,NULL,0,NULL,0);
7956         VARIDIV(I8,2,I2,1,I8,2);
7957         VARIDIV(I8,2,I4,1,I8,2);
7958         VARIDIV(I8,2,R4,1.0f,I8,2);
7959         VARIDIV(I8,2,R8,1.0,I8,2);
7960         VARIDIV(I8,2,DATE,1,I8,2);
7961         VARIDIV(I8,2,BSTR,num1_str,I8,2);
7962         VARIDIV(I8,2,BOOL,1,I8,2);
7963         VARIDIV(I8,2,I1,1,I8,2);
7964         VARIDIV(I8,2,UI1,1,I8,2);
7965         VARIDIV(I8,2,UI2,1,I8,2);
7966         VARIDIV(I8,2,UI4,1,I8,2);
7967         VARIDIV(I8,2,I8,1,I8,2);
7968         VARIDIV(I8,2,UI8,1,I8,2);
7969         VARIDIV(I8,2,UINT,1,I8,2);
7970         VARIDIV(UI8,2,NULL,0,NULL,0);
7971         VARIDIV(UI8,2,I2,1,I4,2);
7972         VARIDIV(UI8,2,I4,1,I4,2);
7973         VARIDIV(UI8,2,R4,1.0f,I4,2);
7974         VARIDIV(UI8,2,R8,1.0,I4,2);
7975         VARIDIV(UI8,2,DATE,1,I4,2);
7976         VARIDIV(UI8,2,BSTR,num1_str,I4,2);
7977         VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
7978         VARIDIV(UI8,2,I1,1,I4,2);
7979         VARIDIV(UI8,2,UI1,1,I4,2);
7980         VARIDIV(UI8,2,UI2,1,I4,2);
7981         VARIDIV(UI8,2,UI4,1,I4,2);
7982         VARIDIV(UI8,2,I8,1,I8,2);
7983         VARIDIV(UI8,2,UI8,1,I4,2);
7984         VARIDIV(UI8,2,INT,1,I4,2);
7985         VARIDIV(UI8,2,UINT,1,I4,2);
7986     }
7987     VARIDIV(INT,2,NULL,0,NULL,0);
7988     VARIDIV(INT,2,I2,1,I4,2);
7989     VARIDIV(INT,2,I4,1,I4,2);
7990     VARIDIV(INT,2,R4,1.0f,I4,2);
7991     VARIDIV(INT,2,R8,1.0,I4,2);
7992     VARIDIV(INT,2,DATE,1,I4,2);
7993     VARIDIV(INT,2,BSTR,num1_str,I4,2);
7994     VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
7995     VARIDIV(INT,2,I1,1,I4,2);
7996     VARIDIV(INT,2,UI1,1,I4,2);
7997     VARIDIV(INT,2,UI2,1,I4,2);
7998     VARIDIV(INT,2,UI4,1,I4,2);
7999     if (HAVE_OLEAUT32_I8)
8000     {
8001         VARIDIV(INT,2,UI8,1,I4,2);
8002     }
8003     VARIDIV(INT,2,INT,1,I4,2);
8004     VARIDIV(INT,2,UINT,1,I4,2);
8005     VARIDIV(UINT,2,NULL,0,NULL,0);
8006     VARIDIV(UINT,2,I2,1,I4,2);
8007     VARIDIV(UINT,2,I4,1,I4,2);
8008     VARIDIV(UINT,2,R4,1.0f,I4,2);
8009     VARIDIV(UINT,2,R8,1.0,I4,2);
8010     VARIDIV(UINT,2,DATE,1,I4,2);
8011     VARIDIV(UINT,2,BSTR,num1_str,I4,2);
8012     VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
8013     VARIDIV(UINT,2,I1,1,I4,2);
8014     VARIDIV(UINT,2,UI1,1,I4,2);
8015     VARIDIV(UINT,2,UI2,1,I4,2);
8016     VARIDIV(UINT,2,UI4,1,I4,2);
8017     if (HAVE_OLEAUT32_I8)
8018     {
8019         VARIDIV(UINT,2,I8,1,I8,2);
8020         VARIDIV(UINT,2,UI8,1,I4,2);
8021     }
8022     VARIDIV(UINT,2,INT,1,I4,2);
8023     VARIDIV(UINT,2,UINT,1,I4,2);
8024
8025     /* Manually test some VT_CY, VT_DECIMAL variants */
8026     V_VT(&cy) = VT_CY;
8027     hres = VarCyFromI4(10000, &V_CY(&cy));
8028     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8029     V_VT(&dec) = VT_DECIMAL;
8030     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8031     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8032     memset(&left, 0, sizeof(left));
8033     memset(&right, 0, sizeof(right));
8034     V_VT(&left) = VT_I4;
8035     V_I4(&left) = 100;
8036     V_VT(&right) = VT_I8;
8037     V_UI1(&right) = 2;
8038
8039     hres = VarIdiv(&cy, &cy, &result);
8040     ok(hres == S_OK && V_VT(&result) == VT_I4,
8041         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8042         S_OK, hres, vtstr(V_VT(&result)));
8043     ok(hres == S_OK && V_I4(&result) == 1,
8044         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
8045
8046     if (HAVE_OLEAUT32_I8)
8047     {
8048         hres = VarIdiv(&cy, &right, &result);
8049         ok(hres == S_OK && V_VT(&result) == VT_I8,
8050             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8051             S_OK, hres, vtstr(V_VT(&result)));
8052         ok(hres == S_OK && V_I8(&result) == 5000,
8053             "VARIDIV: CY value 0x%x%08x, expected 0x%x\n",
8054             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), 5000);
8055     }
8056
8057     hres = VarIdiv(&left, &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) == 0,
8062         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 0);
8063
8064     hres = VarIdiv(&left, &dec, &result);
8065     ok(hres == S_OK && V_VT(&result) == VT_I4,
8066         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8067         S_OK, hres, vtstr(V_VT(&result)));
8068     ok(hres == S_OK && V_I4(&result) == 50,
8069         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 50);
8070
8071     hres = VarIdiv(&dec, &dec, &result);
8072     ok(hres == S_OK && V_VT(&result) == VT_I4,
8073         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8074         S_OK, hres, vtstr(V_VT(&result)));
8075     ok(hres == S_OK && V_I4(&result) == 1,
8076         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
8077
8078     if (HAVE_OLEAUT32_I8)
8079     {
8080         hres = VarIdiv(&dec, &right, &result);
8081         ok(hres == S_OK && V_VT(&result) == VT_I8,
8082             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8083             S_OK, hres, vtstr(V_VT(&result)));
8084         ok(hres == S_OK && V_I8(&result) == 1,
8085             "VARIDIV: DECIMAL value 0x%x%08x, expected %d\n",
8086             (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result), 1);
8087     }
8088
8089     /* Check for division by zero */
8090     V_VT(&left) = VT_INT;
8091     V_I4(&left) = 1;
8092     V_VT(&right) = VT_INT;
8093     V_I4(&right) = 0;
8094     hres = pVarIdiv(&left, &right, &result);
8095     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8096         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8097
8098     V_VT(&left) = VT_INT;
8099     V_I4(&left) = 0;
8100     V_VT(&right) = VT_INT;
8101     V_I4(&right) = 0;
8102     hres = pVarIdiv(&left, &right, &result);
8103     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8104         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8105
8106     SysFreeString(num1_str);
8107     SysFreeString(num2_str);
8108 }
8109
8110
8111 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
8112
8113 #define VARIMP(vt1,val1,vt2,val2,rvt,rval)              \
8114         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
8115         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8116         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
8117         test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
8118
8119 /* Skip any type that is not defined or produces an error for every case */
8120 #define SKIPTESTIMP(a)                            \
8121     if (a == VT_ERROR || a == VT_VARIANT ||       \
8122         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
8123         a == VT_RECORD || a > VT_UINT ||          \
8124         a == 15 /*not defined*/)                  \
8125         continue
8126
8127 static void test_VarImp(void)
8128 {
8129     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
8130     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
8131     VARIANT left, right, exp, result, cy, dec;
8132     BSTR true_str, false_str;
8133     VARTYPE i;
8134     HRESULT hres;
8135
8136     CHECKPTR(VarImp);
8137
8138     true_str = SysAllocString(szTrue);
8139     false_str = SysAllocString(szFalse);
8140
8141     /* Test all possible flag/vt combinations & the resulting vt type */
8142     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
8143     {
8144         VARTYPE leftvt, rightvt, resvt;
8145
8146         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8147         {
8148             SKIPTESTIMP(leftvt);
8149
8150             /* Check if we need/have support for I8 and/or UI8 */
8151             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8152                 continue;
8153
8154             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8155             {
8156                 BOOL bFail = FALSE;
8157                 SKIPTESTIMP(rightvt);
8158
8159                 /* Native crashes when using the extra flag VT_BYREF
8160                  * or with the following VT combinations
8161                  */
8162                 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
8163                     (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
8164                     ExtraFlags[i] == VT_BYREF)
8165                     continue;
8166
8167                 /* Check if we need/have support for I8 and/or UI8 */
8168                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8169                     continue;
8170
8171                 memset(&left, 0, sizeof(left));
8172                 memset(&right, 0, sizeof(right));
8173                 V_VT(&left) = leftvt | ExtraFlags[i];
8174                 V_VT(&right) = rightvt | ExtraFlags[i];
8175                 V_VT(&result) = VT_EMPTY;
8176                 resvt = VT_EMPTY;
8177
8178                 if (leftvt == VT_BSTR)
8179                     V_BSTR(&left) = true_str;
8180
8181                 /* This allows us to test return types that are not NULL
8182                  * (NULL Imp value = n, NULL Imp 0 = NULL)
8183                  */
8184                 switch(rightvt)
8185                 {
8186                 case VT_BSTR:
8187                     V_BSTR(&right) = true_str;
8188                     break;
8189                 case VT_DECIMAL:
8190                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8191                     V_VT(&right) = rightvt | ExtraFlags[i];
8192                     break;
8193                 case VT_BOOL:
8194                     V_BOOL(&right) = VARIANT_TRUE;
8195                     break;
8196                 case VT_I1: V_I1(&right) = 2; break;
8197                 case VT_I2: V_I2(&right) = 2; break;
8198                 case VT_I4: V_I4(&right) = 2; break;
8199                 case VT_R4: V_R4(&right) = 2.0f; break;
8200                 case VT_R8: V_R8(&right) = 2.0; break;
8201                 case VT_CY: V_CY(&right).int64 = 10000; break;
8202                 case VT_DATE: V_DATE(&right) = 2; break;
8203                 case VT_I8: V_I8(&right) = 2; break;
8204                 case VT_INT: V_INT(&right) = 2; break;
8205                 case VT_UINT: V_UINT(&right) = 2; break;
8206                 case VT_UI1: V_UI1(&right) = 2; break;
8207                 case VT_UI2: V_UI2(&right) = 2; break;
8208                 case VT_UI4: V_UI4(&right) = 2; break;
8209                 case VT_UI8: V_UI8(&right) = 2; break;
8210                 default: break;
8211                 }
8212
8213                 /* Native VarImp always returns an error when using extra
8214                  * flags or if the variants are I8 and INT.
8215                  */
8216                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8217                     ExtraFlags[i] != 0)
8218                     bFail = TRUE;
8219
8220                 /* Determine result type */
8221                 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
8222                     (leftvt == VT_NULL && rightvt == VT_NULL) ||
8223                     (leftvt == VT_NULL && rightvt == VT_EMPTY))
8224                     resvt = VT_NULL;
8225                 else if (leftvt == VT_I8 || rightvt == VT_I8)
8226                     resvt = VT_I8;
8227                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8228                     leftvt == VT_INT || rightvt == VT_INT ||
8229                     leftvt == VT_UINT || rightvt == VT_UINT ||
8230                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
8231                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
8232                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
8233                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8234                     leftvt == VT_DATE || rightvt == VT_DATE ||
8235                     leftvt == VT_CY || rightvt == VT_CY ||
8236                     leftvt == VT_R8 || rightvt == VT_R8 ||
8237                     leftvt == VT_R4 || rightvt == VT_R4 ||
8238                     leftvt == VT_I1 || rightvt == VT_I1)
8239                     resvt = VT_I4;
8240                 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
8241                     (leftvt == VT_UI1 && rightvt == VT_NULL) ||
8242                     (leftvt == VT_NULL && rightvt == VT_UI1))
8243                     resvt = VT_UI1;
8244                 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
8245                     leftvt == VT_I2 || rightvt == VT_I2 ||
8246                     leftvt == VT_UI1 || rightvt == VT_UI1)
8247                     resvt = VT_I2;
8248                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
8249                     leftvt == VT_BSTR || rightvt == VT_BSTR)
8250                     resvt = VT_BOOL;
8251
8252                 hres = pVarImp(&left, &right, &result);
8253
8254                 /* Check expected HRESULT and if result variant type is correct */
8255                 if (bFail)
8256                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
8257                         "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
8258                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
8259                         vtstr(V_VT(&result)), hres);
8260                 else
8261                     ok (hres == S_OK && resvt == V_VT(&result),
8262                         "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
8263                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
8264                         S_OK, vtstr(V_VT(&result)), hres);
8265             }
8266         }
8267     }
8268
8269     VARIMP(EMPTY,0,EMPTY,0,I2,-1);
8270     VARIMP(EMPTY,0,NULL,0,I2,-1);
8271     VARIMP(EMPTY,0,I2,-1,I2,-1);
8272     VARIMP(EMPTY,0,I4,-1,I4,-1);
8273     VARIMP(EMPTY,0,R4,0.0f,I4,-1);
8274     VARIMP(EMPTY,0,R8,-1.0,I4,-1);
8275     VARIMP(EMPTY,0,DATE,0,I4,-1);
8276     VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
8277     VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
8278     VARIMP(EMPTY,0,I1,0,I4,-1);
8279     VARIMP(EMPTY,0,UI1,1,I2,-1);
8280     VARIMP(EMPTY,0,UI2,1,I4,-1);
8281     VARIMP(EMPTY,0,UI4,1,I4,-1);
8282     if (HAVE_OLEAUT32_I8)
8283     {
8284         VARIMP(EMPTY,0,I8,1,I8,-1);
8285         VARIMP(EMPTY,0,UI8,1,I4,-1);
8286     }
8287     VARIMP(EMPTY,0,INT,-1,I4,-1);
8288     VARIMP(EMPTY,0,UINT,1,I4,-1);
8289     VARIMP(NULL,0,EMPTY,0,NULL,0);
8290     VARIMP(NULL,0,NULL,0,NULL,0);
8291     VARIMP(NULL,0,I2,-1,I2,-1);
8292     VARIMP(NULL,0,I4,-1,I4,-1);
8293     VARIMP(NULL,0,R4,0.0f,NULL,0);
8294     VARIMP(NULL,0,R8,-1.0,I4,-1);
8295     VARIMP(NULL,0,DATE,0,NULL,0);
8296     VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
8297     VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
8298     VARIMP(NULL,0,I1,0,NULL,0);
8299     VARIMP(NULL,0,UI1,1,UI1,1);
8300     VARIMP(NULL,0,UI2,1,I4,1);
8301     VARIMP(NULL,0,UI4,1,I4,1);
8302     if (HAVE_OLEAUT32_I8)
8303     {
8304         VARIMP(NULL,0,I8,1,I8,1);
8305         VARIMP(NULL,0,UI8,1,I4,1);
8306     }
8307     VARIMP(NULL,0,INT,-1,I4,-1);
8308     VARIMP(NULL,0,UINT,1,I4,1);
8309     VARIMP(I2,-1,EMPTY,0,I2,0);
8310     VARIMP(I2,-1,I2,-1,I2,-1);
8311     VARIMP(I2,-1,I4,-1,I4,-1);
8312     VARIMP(I2,-1,R4,0.0f,I4,0);
8313     VARIMP(I2,-1,R8,-1.0,I4,-1);
8314     VARIMP(I2,-1,DATE,0,I4,0);
8315     VARIMP(I2,-1,BSTR,true_str,I2,-1);
8316     VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
8317     VARIMP(I2,-1,I1,0,I4,0);
8318     VARIMP(I2,-1,UI1,1,I2,1);
8319     VARIMP(I2,-1,UI2,1,I4,1);
8320     VARIMP(I2,-1,UI4,1,I4,1);
8321     if (HAVE_OLEAUT32_I8)
8322     {
8323         VARIMP(I2,-1,I8,1,I8,1);
8324         VARIMP(I2,-1,UI8,1,I4,1);
8325     }
8326     VARIMP(I2,-1,INT,-1,I4,-1);
8327     VARIMP(I2,-1,UINT,1,I4,1);
8328     VARIMP(I4,2,EMPTY,0,I4,-3);
8329     VARIMP(I4,2,NULL,0,I4,-3);
8330     VARIMP(I4,2,I2,-1,I4,-1);
8331     VARIMP(I4,2,I4,-1,I4,-1);
8332     VARIMP(I4,2,R4,0.0f,I4,-3);
8333     VARIMP(I4,2,R8,-1.0,I4,-1);
8334     VARIMP(I4,2,DATE,0,I4,-3);
8335     VARIMP(I4,2,BSTR,true_str,I4,-1);
8336     VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
8337     VARIMP(I4,2,I1,0,I4,-3);
8338     VARIMP(I4,2,UI1,1,I4,-3);
8339     VARIMP(I4,2,UI2,1,I4,-3);
8340     VARIMP(I4,2,UI4,1,I4,-3);
8341     if (HAVE_OLEAUT32_I8)
8342     {
8343         VARIMP(I4,2,I8,1,I8,-3);
8344         VARIMP(I4,2,UI8,1,I4,-3);
8345     }
8346     VARIMP(I4,2,INT,-1,I4,-1);
8347     VARIMP(I4,2,UINT,1,I4,-3);
8348     VARIMP(R4,-1.0f,EMPTY,0,I4,0);
8349     VARIMP(R4,-1.0f,NULL,0,NULL,0);
8350     VARIMP(R4,-1.0f,I2,-1,I4,-1);
8351     VARIMP(R4,-1.0f,I4,-1,I4,-1);
8352     VARIMP(R4,-1.0f,R4,0.0f,I4,0);
8353     VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
8354     VARIMP(R4,-1.0f,DATE,1,I4,1);
8355     VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
8356     VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
8357     VARIMP(R4,-1.0f,I1,0,I4,0);
8358     VARIMP(R4,-1.0f,UI1,1,I4,1);
8359     VARIMP(R4,-1.0f,UI2,1,I4,1);
8360     VARIMP(R4,-1.0f,UI4,1,I4,1);
8361     if (HAVE_OLEAUT32_I8)
8362     {
8363         VARIMP(R4,-1.0f,I8,1,I8,1);
8364         VARIMP(R4,-1.0f,UI8,1,I4,1);
8365     }
8366     VARIMP(R4,-1.0f,INT,-1,I4,-1);
8367     VARIMP(R4,-1.0f,UINT,1,I4,1);
8368     VARIMP(R8,1.0,EMPTY,0,I4,-2);
8369     VARIMP(R8,1.0,NULL,0,I4,-2);
8370     VARIMP(R8,1.0,I2,-1,I4,-1);
8371     VARIMP(R8,1.0,I4,-1,I4,-1);
8372     VARIMP(R8,1.0,R4,0.0f,I4,-2);
8373     VARIMP(R8,1.0,R8,-1.0,I4,-1);
8374     VARIMP(R8,1.0,DATE,0,I4,-2);
8375     VARIMP(R8,1.0,BSTR,true_str,I4,-1);
8376     VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
8377     VARIMP(R8,1.0,I1,0,I4,-2);
8378     VARIMP(R8,1.0,UI1,1,I4,-1);
8379     VARIMP(R8,1.0,UI2,1,I4,-1);
8380     VARIMP(R8,1.0,UI4,1,I4,-1);
8381     if (HAVE_OLEAUT32_I8)
8382     {
8383         VARIMP(R8,1.0,I8,1,I8,-1);
8384         VARIMP(R8,1.0,UI8,1,I4,-1);
8385     }
8386     VARIMP(R8,1.0,INT,-1,I4,-1);
8387     VARIMP(R8,1.0,UINT,1,I4,-1);
8388     VARIMP(DATE,0,EMPTY,0,I4,-1);
8389     VARIMP(DATE,0,NULL,0,I4,-1);
8390     VARIMP(DATE,0,I2,-1,I4,-1);
8391     VARIMP(DATE,0,I4,-1,I4,-1);
8392     VARIMP(DATE,0,R4,0.0f,I4,-1);
8393     VARIMP(DATE,0,R8,-1.0,I4,-1);
8394     VARIMP(DATE,0,DATE,0,I4,-1);
8395     VARIMP(DATE,0,BSTR,true_str,I4,-1);
8396     VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
8397     VARIMP(DATE,0,I1,0,I4,-1);
8398     VARIMP(DATE,0,UI1,1,I4,-1);
8399     VARIMP(DATE,0,UI2,1,I4,-1);
8400     VARIMP(DATE,0,UI4,1,I4,-1);
8401     if (HAVE_OLEAUT32_I8)
8402     {
8403         VARIMP(DATE,0,I8,1,I8,-1);
8404         VARIMP(DATE,0,UI8,1,I4,-1);
8405     }
8406     VARIMP(DATE,0,INT,-1,I4,-1);
8407     VARIMP(DATE,0,UINT,1,I4,-1);
8408     VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
8409     VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
8410     VARIMP(BSTR,false_str,I2,-1,I2,-1);
8411     VARIMP(BSTR,false_str,I4,-1,I4,-1);
8412     VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
8413     VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
8414     VARIMP(BSTR,false_str,DATE,0,I4,-1);
8415     VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
8416     VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
8417     VARIMP(BSTR,false_str,I1,0,I4,-1);
8418     VARIMP(BSTR,false_str,UI1,1,I2,-1);
8419     VARIMP(BSTR,false_str,UI2,1,I4,-1);
8420     VARIMP(BSTR,false_str,UI4,1,I4,-1);
8421     if (HAVE_OLEAUT32_I8)
8422     {
8423         VARIMP(BSTR,false_str,I8,1,I8,-1);
8424         VARIMP(BSTR,false_str,UI8,1,I4,-1);
8425     }
8426     VARIMP(BSTR,false_str,INT,-1,I4,-1);
8427     VARIMP(BSTR,false_str,UINT,1,I4,-1);
8428     VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
8429     VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8430     VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
8431     VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
8432     VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
8433     VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
8434     VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
8435     VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
8436     VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
8437     VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
8438     VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
8439     VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
8440     VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
8441     if (HAVE_OLEAUT32_I8)
8442     {
8443         VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
8444         VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
8445     }
8446     VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
8447     VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
8448     VARIMP(I1,-1,EMPTY,0,I4,0);
8449     VARIMP(I1,-1,NULL,0,NULL,0);
8450     VARIMP(I1,-1,I2,-1,I4,-1);
8451     VARIMP(I1,-1,I4,-1,I4,-1);
8452     VARIMP(I1,-1,R4,0.0f,I4,0);
8453     VARIMP(I1,-1,R8,-1.0,I4,-1);
8454     VARIMP(I1,-1,DATE,0,I4,0);
8455     VARIMP(I1,-1,BSTR,true_str,I4,-1);
8456     VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
8457     VARIMP(I1,-1,I1,0,I4,0);
8458     VARIMP(I1,-1,UI1,1,I4,1);
8459     VARIMP(I1,-1,UI2,1,I4,1);
8460     VARIMP(I1,-1,UI4,1,I4,1);
8461     if (HAVE_OLEAUT32_I8)
8462     {
8463         VARIMP(I1,-1,I8,1,I8,1);
8464         VARIMP(I1,-1,UI8,1,I4,1);
8465     }
8466     VARIMP(I1,-1,INT,-1,I4,-1);
8467     VARIMP(I1,-1,UINT,1,I4,1);
8468     VARIMP(UI1,0,EMPTY,0,I2,-1);
8469     VARIMP(UI1,0,NULL,0,UI1,255);
8470     VARIMP(UI1,0,I2,-1,I2,-1);
8471     VARIMP(UI1,0,I4,-1,I4,-1);
8472     VARIMP(UI1,0,R4,0.0f,I4,-1);
8473     VARIMP(UI1,0,R8,-1.0,I4,-1);
8474     VARIMP(UI1,0,DATE,0,I4,-1);
8475     VARIMP(UI1,0,BSTR,true_str,I2,-1);
8476     VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
8477     VARIMP(UI1,0,I1,0,I4,-1);
8478     VARIMP(UI1,0,UI1,1,UI1,255);
8479     VARIMP(UI1,0,UI2,1,I4,-1);
8480     VARIMP(UI1,0,UI4,1,I4,-1);
8481     if (HAVE_OLEAUT32_I8)
8482     {
8483         VARIMP(UI1,0,I8,1,I8,-1);
8484         VARIMP(UI1,0,UI8,1,I4,-1);
8485     }
8486     VARIMP(UI1,0,INT,-1,I4,-1);
8487     VARIMP(UI1,0,UINT,1,I4,-1);
8488     VARIMP(UI2,0,EMPTY,0,I4,-1);
8489     VARIMP(UI2,0,NULL,0,I4,-1);
8490     VARIMP(UI2,0,I2,-1,I4,-1);
8491     VARIMP(UI2,0,I4,-1,I4,-1);
8492     VARIMP(UI2,0,R4,0.0f,I4,-1);
8493     VARIMP(UI2,0,R8,-1.0,I4,-1);
8494     VARIMP(UI2,0,DATE,0,I4,-1);
8495     VARIMP(UI2,0,BSTR,true_str,I4,-1);
8496     VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
8497     VARIMP(UI2,0,I1,0,I4,-1);
8498     VARIMP(UI2,0,UI1,1,I4,-1);
8499     VARIMP(UI2,0,UI2,1,I4,-1);
8500     VARIMP(UI2,0,UI4,1,I4,-1);
8501     if (HAVE_OLEAUT32_I8)
8502     {
8503         VARIMP(UI2,0,I8,1,I8,-1);
8504         VARIMP(UI2,0,UI8,1,I4,-1);
8505     }
8506     VARIMP(UI2,0,INT,-1,I4,-1);
8507     VARIMP(UI2,0,UINT,1,I4,-1);
8508     VARIMP(UI4,0,EMPTY,0,I4,-1);
8509     VARIMP(UI4,0,NULL,0,I4,-1);
8510     VARIMP(UI4,0,I2,-1,I4,-1);
8511     VARIMP(UI4,0,I4,-1,I4,-1);
8512     VARIMP(UI4,0,R4,0.0f,I4,-1);
8513     VARIMP(UI4,0,R8,-1.0,I4,-1);
8514     VARIMP(UI4,0,DATE,0,I4,-1);
8515     VARIMP(UI4,0,BSTR,true_str,I4,-1);
8516     VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
8517     VARIMP(UI4,0,I1,0,I4,-1);
8518     VARIMP(UI4,0,UI1,1,I4,-1);
8519     VARIMP(UI4,0,UI2,1,I4,-1);
8520     VARIMP(UI4,0,UI4,1,I4,-1);
8521     if (HAVE_OLEAUT32_I8)
8522     {
8523         VARIMP(UI4,0,I8,1,I8,-1);
8524         VARIMP(UI4,0,UI8,1,I4,-1);
8525     }
8526     VARIMP(UI4,0,INT,-1,I4,-1);
8527     VARIMP(UI4,0,UINT,1,I4,-1);
8528     if (HAVE_OLEAUT32_I8)
8529     {
8530         VARIMP(I8,-1,EMPTY,0,I8,0);
8531         VARIMP(I8,-1,NULL,0,NULL,0);
8532         VARIMP(I8,-1,I2,-1,I8,-1);
8533         VARIMP(I8,-1,I4,-1,I8,-1);
8534         VARIMP(I8,-1,R4,0.0f,I8,0);
8535         VARIMP(I8,-1,R8,-1.0,I8,-1);
8536         VARIMP(I8,-1,DATE,0,I8,0);
8537         VARIMP(I8,-1,BSTR,true_str,I8,-1);
8538         VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
8539         VARIMP(I8,-1,I1,0,I8,0);
8540         VARIMP(I8,-1,UI1,1,I8,1);
8541         VARIMP(I8,-1,UI2,1,I8,1);
8542         VARIMP(I8,-1,UI4,1,I8,1);
8543         VARIMP(I8,-1,I8,1,I8,1);
8544         VARIMP(I8,-1,UI8,1,I8,1);
8545         VARIMP(I8,-1,UINT,1,I8,1);
8546         VARIMP(UI8,0,EMPTY,0,I4,-1);
8547         VARIMP(UI8,0,NULL,0,I4,-1);
8548         VARIMP(UI8,0,I2,-1,I4,-1);
8549         VARIMP(UI8,0,I4,-1,I4,-1);
8550         VARIMP(UI8,0,R4,0.0f,I4,-1);
8551         VARIMP(UI8,0,R8,-1.0,I4,-1);
8552         VARIMP(UI8,0,DATE,0,I4,-1);
8553         VARIMP(UI8,0,BSTR,true_str,I4,-1);
8554         VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
8555         VARIMP(UI8,0,I1,0,I4,-1);
8556         VARIMP(UI8,0,UI1,1,I4,-1);
8557         VARIMP(UI8,0,UI2,1,I4,-1);
8558         VARIMP(UI8,0,UI4,1,I4,-1);
8559         VARIMP(UI8,0,I8,1,I8,-1);
8560         VARIMP(UI8,0,UI8,1,I4,-1);
8561         VARIMP(UI8,0,INT,-1,I4,-1);
8562         VARIMP(UI8,0,UINT,1,I4,-1);
8563     }
8564     VARIMP(INT,-1,EMPTY,0,I4,0);
8565     VARIMP(INT,-1,NULL,0,NULL,0);
8566     VARIMP(INT,-1,I2,-1,I4,-1);
8567     VARIMP(INT,-1,I4,-1,I4,-1);
8568     VARIMP(INT,-1,R4,0.0f,I4,0);
8569     VARIMP(INT,-1,R8,-1.0,I4,-1);
8570     VARIMP(INT,-1,DATE,0,I4,0);
8571     VARIMP(INT,-1,BSTR,true_str,I4,-1);
8572     VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
8573     VARIMP(INT,-1,I1,0,I4,0);
8574     VARIMP(INT,-1,UI1,1,I4,1);
8575     VARIMP(INT,-1,UI2,1,I4,1);
8576     VARIMP(INT,-1,UI4,1,I4,1);
8577     if (HAVE_OLEAUT32_I8)
8578     {
8579         VARIMP(INT,-1,I8,1,I8,1);
8580         VARIMP(INT,-1,UI8,1,I4,1);
8581     }
8582     VARIMP(INT,-1,INT,-1,I4,-1);
8583     VARIMP(INT,-1,UINT,1,I4,1);
8584     VARIMP(UINT,1,EMPTY,0,I4,-2);
8585     VARIMP(UINT,1,NULL,0,I4,-2);
8586     VARIMP(UINT,1,I2,-1,I4,-1);
8587     VARIMP(UINT,1,I4,-1,I4,-1);
8588     VARIMP(UINT,1,R4,0.0f,I4,-2);
8589     VARIMP(UINT,1,R8,-1.0,I4,-1);
8590     VARIMP(UINT,1,DATE,0,I4,-2);
8591     VARIMP(UINT,1,BSTR,true_str,I4,-1);
8592     VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
8593     VARIMP(UINT,1,I1,0,I4,-2);
8594     VARIMP(UINT,1,UI1,1,I4,-1);
8595     VARIMP(UINT,1,UI2,1,I4,-1);
8596     VARIMP(UINT,1,UI4,1,I4,-1);
8597     if (HAVE_OLEAUT32_I8)
8598     {
8599         VARIMP(UINT,1,I8,1,I8,-1);
8600         VARIMP(UINT,1,UI8,1,I4,-1);
8601     }
8602     VARIMP(UINT,1,INT,-1,I4,-1);
8603     VARIMP(UINT,1,UINT,1,I4,-1);
8604
8605     /* Manually test some VT_CY, VT_DECIMAL variants */
8606     V_VT(&cy) = VT_CY;
8607     hres = VarCyFromI4(1, &V_CY(&cy));
8608     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8609     V_VT(&dec) = VT_DECIMAL;
8610     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8611     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8612     memset(&left, 0, sizeof(left));
8613     memset(&right, 0, sizeof(right));
8614     V_VT(&left) = VT_I4;
8615     V_I4(&left) = 0;
8616     V_VT(&right) = VT_I8;
8617     V_UI1(&right) = 0;
8618
8619     hres = pVarImp(&cy, &cy, &result);
8620     ok(hres == S_OK && V_VT(&result) == VT_I4,
8621         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8622         S_OK, hres, vtstr(V_VT(&result)));
8623     ok(hres == S_OK && V_I4(&result) == -1,
8624         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8625
8626     if (HAVE_OLEAUT32_I8)
8627     {
8628         hres = pVarImp(&cy, &right, &result);
8629         ok(hres == S_OK && V_VT(&result) == VT_I8,
8630             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8631             S_OK, hres, vtstr(V_VT(&result)));
8632         ok(hres == S_OK && V_I8(&result) == -2,
8633             "VARIMP: CY value %x%08x, expected %d\n",
8634             (DWORD)((V_I8(&result)) >> 32), (DWORD)(V_I8(&result)), -2);
8635     }
8636
8637     hres = pVarImp(&left, &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     hres = pVarImp(&left, &dec, &result);
8645     ok(hres == S_OK && V_VT(&result) == VT_I4,
8646         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8647         S_OK, hres, vtstr(V_VT(&result)));
8648     ok(hres == S_OK && V_I4(&result) == -1,
8649         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8650
8651     hres = pVarImp(&dec, &dec, &result);
8652     ok(hres == S_OK && V_VT(&result) == VT_I4,
8653         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8654         S_OK, hres, vtstr(V_VT(&result)));
8655     ok(hres == S_OK && V_I4(&result) == -1,
8656         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8657
8658     if (HAVE_OLEAUT32_I8)
8659     {
8660         hres = pVarImp(&dec, &right, &result);
8661         ok(hres == S_OK && V_VT(&result) == VT_I8,
8662             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8663             S_OK, hres, vtstr(V_VT(&result)));
8664         ok(hres == S_OK && V_I8(&result) == -3,
8665             "VARIMP: DECIMAL value 0x%x%08x, expected %d\n",
8666             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), -3);
8667     }
8668
8669     SysFreeString(false_str);
8670     SysFreeString(true_str);
8671 }
8672
8673 START_TEST(vartest)
8674 {
8675   init();
8676
8677   test_VariantInit();
8678   test_VariantClear();
8679   test_VariantCopy();
8680   test_VariantCopyInd();
8681   test_VarParseNumFromStr();
8682   test_VarNumFromParseNum();
8683   test_VarUdateFromDate();
8684   test_VarDateFromUdate();
8685   test_SystemTimeToVariantTime();
8686   test_VariantTimeToSystemTime();
8687   test_DosDateTimeToVariantTime();
8688   test_VariantTimeToDosDateTime();
8689   test_VarAbs();
8690   test_VarNot();
8691   test_VarSub();
8692   test_VarMod();
8693   test_VarFix();
8694   test_VarInt();
8695   test_VarNeg();
8696   test_VarRound();
8697   test_VarXor();
8698   test_VarOr();
8699   test_VarPow();
8700   test_VarEqv();
8701   test_VarMul();
8702   test_VarAdd();
8703   test_VarCat();
8704   test_VarCmp();
8705   test_VarAnd();
8706   test_VarDiv();
8707   test_VarIdiv();
8708   test_VarImp();
8709 }