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
 349 static void test_VariantInit(void)
 350 {
 351   VARIANTARG v1, v2;
 352
 353   /* Test that VariantInit() only sets the type */
 354   memset(&v1, -1, sizeof(v1));
 355   v2 = v1;
 356   V_VT(&v2) = VT_EMPTY;
 357   VariantInit(&v1);
 358   ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
 359 }
 360
 361 /* All possible combinations of extra V_VT() flags */
 362 static const VARTYPE ExtraFlags[16] =
 363 {
 364   0,
 365   VT_VECTOR,
 366   VT_ARRAY,
 367   VT_BYREF,
 368   VT_RESERVED,
 369   VT_VECTOR|VT_ARRAY,
 370   VT_VECTOR|VT_BYREF,
 371   VT_VECTOR|VT_RESERVED,
 372   VT_VECTOR|VT_ARRAY|VT_BYREF,
 373   VT_VECTOR|VT_ARRAY|VT_RESERVED,
 374   VT_VECTOR|VT_BYREF|VT_RESERVED,
 375   VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
 376   VT_ARRAY|VT_BYREF,
 377   VT_ARRAY|VT_RESERVED,
 378   VT_ARRAY|VT_BYREF|VT_RESERVED,
 379   VT_BYREF|VT_RESERVED,
 380 };
 381
 382 /* Determine if a vt is valid for VariantClear() */
 383 static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
 384 {
 385   int ret = 0;
 386
 387   /* Only the following flags/types are valid */
 388   if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
 389       vt != (VARTYPE)15 &&
 390       (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
 391       (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
 392       (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
 393        extraFlags == (VT_ARRAY|VT_BYREF)))
 394     ret = 1; /* ok */
 395
 396   if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
 397       ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
 398     ret = 0; /* Old versions of oleaut32 */
 399   return ret;
 400 }
 401
 402 typedef struct
 403 {
 404     IUnknown IUnknown_iface;
 405     LONG     ref;
 406     LONG     events;
 407 } test_VariantClearImpl;
 408
 409 static inline test_VariantClearImpl *impl_from_IUnknown(IUnknown *iface)
 410 {
 411     return CONTAINING_RECORD(iface, test_VariantClearImpl, IUnknown_iface);
 412 }
 413
 414 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
 415 {
 416     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 417     This->events |= 0x1;
 418     return E_NOINTERFACE;
 419 }
 420
 421 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
 422     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 423     This->events |= 0x2;
 424     return InterlockedIncrement(&This->ref);
 425 }
 426
 427 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
 428     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 429     /* static class, won't be  freed */
 430     This->events |= 0x4;
 431     return InterlockedDecrement(&This->ref);
 432 }
 433
 434 static const IUnknownVtbl test_VariantClear_vtbl = {
 435     VC_QueryInterface,
 436     VC_AddRef,
 437     VC_Release,
 438 };
 439
 440 static test_VariantClearImpl test_myVariantClearImpl = {{&test_VariantClear_vtbl}, 1, 0};
 441
 442 static void test_VariantClear(void)
 443 {
 444   HRESULT hres;
 445   VARIANTARG v;
 446   VARIANT v2;
 447   size_t i;
 448   LONG i4;
 449   IUnknown *punk;
 450
 451   /* Crashes: Native does not test input for NULL, so neither does Wine */
 452   if (0)
 453       VariantClear(NULL);
 454
 455   /* Only the type field is set, to VT_EMPTY */
 456   V_VT(&v) = VT_UI4;
 457   V_UI4(&v) = ~0u;
 458   hres = VariantClear(&v);
 459   ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
 460      (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
 461      "VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
 462   ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
 463
 464   /* Test all possible V_VT values.
 465    * Also demonstrates that null pointers in 'v' are not dereferenced.
 466    * Individual variant tests should test VariantClear() with non-NULL values.
 467    */
 468   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 469   {
 470     VARTYPE vt;
 471
 472     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 473     {
 474       HRESULT hExpected = DISP_E_BADVARTYPE;
 475
 476       SKIPTESTS(vt);
 477
 478       memset(&v, 0, sizeof(v));
 479       V_VT(&v) = vt | ExtraFlags[i];
 480
 481       hres = VariantClear(&v);
 482
 483       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 484         hExpected = S_OK;
 485
 486       ok(hres == hExpected, "VariantClear: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
 487          hExpected, hres, vt, ExtraFlags[i]);
 488     }
 489   }
 490
 491   /* Some BYREF tests with non-NULL ptrs */
 492
 493   /* VARIANT BYREF */
 494   V_VT(&v2) = VT_I4;
 495   V_I4(&v2) = 0x1234;
 496   V_VT(&v) = VT_VARIANT | VT_BYREF;
 497   V_VARIANTREF(&v) = &v2;
 498
 499   hres = VariantClear(&v);
 500   ok(hres == S_OK, "ret %08x\n", hres);
 501   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 502   ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
 503   ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
 504   ok(V_I4(&v2) == 0x1234, "i4 %04x\n", V_I4(&v2));
 505
 506   /* I4 BYREF */
 507   i4 = 0x4321;
 508   V_VT(&v) = VT_I4 | VT_BYREF;
 509   V_I4REF(&v) = &i4;
 510
 511   hres = VariantClear(&v);
 512   ok(hres == S_OK, "ret %08x\n", hres);
 513   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 514   ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
 515   ok(i4 == 0x4321, "i4 changed %08x\n", i4);
 516
 517
 518   /* UNKNOWN */
 519   V_VT(&v) = VT_UNKNOWN;
 520   V_UNKNOWN(&v) = &test_myVariantClearImpl.IUnknown_iface;
 521   test_myVariantClearImpl.events = 0;
 522   hres = VariantClear(&v);
 523   ok(hres == S_OK, "ret %08x\n", hres);
 524   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 525   ok(V_UNKNOWN(&v) == &test_myVariantClearImpl.IUnknown_iface, "unknown %p\n", V_UNKNOWN(&v));
 526   /* Check that Release got called, but nothing else */
 527   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 528
 529   /* UNKNOWN BYREF */
 530   punk = &test_myVariantClearImpl.IUnknown_iface;
 531   V_VT(&v) = VT_UNKNOWN | VT_BYREF;
 532   V_UNKNOWNREF(&v) = &punk;
 533   test_myVariantClearImpl.events = 0;
 534   hres = VariantClear(&v);
 535   ok(hres == S_OK, "ret %08x\n", hres);
 536   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 537   ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
 538   /* Check that nothing got called */
 539   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 540
 541   /* DISPATCH */
 542   V_VT(&v) = VT_DISPATCH;
 543   V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
 544   test_myVariantClearImpl.events = 0;
 545   hres = VariantClear(&v);
 546   ok(hres == S_OK, "ret %08x\n", hres);
 547   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 548   ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
 549   /* Check that Release got called, but nothing else */
 550   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 551
 552   /* DISPATCH BYREF */
 553   punk = &test_myVariantClearImpl.IUnknown_iface;
 554   V_VT(&v) = VT_DISPATCH | VT_BYREF;
 555   V_DISPATCHREF(&v) = (IDispatch**)&punk;
 556   test_myVariantClearImpl.events = 0;
 557   hres = VariantClear(&v);
 558   ok(hres == S_OK, "ret %08x\n", hres);
 559   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 560   ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
 561   /* Check that nothing got called */
 562   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 563 }
 564
 565 static void test_VariantCopy(void)
 566 {
 567   VARIANTARG vSrc, vDst;
 568   VARTYPE vt;
 569   size_t i;
 570   HRESULT hres, hExpected;
 571
 572   /* Establish that the failure/other cases are dealt with. Individual tests
 573    * for each type should verify that data is copied correctly, references
 574    * are updated, etc.
 575    */
 576
 577   /* vSrc == vDst */
 578   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 579   {
 580     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 581     {
 582       SKIPTESTS(vt);
 583
 584       memset(&vSrc, 0, sizeof(vSrc));
 585       V_VT(&vSrc) = vt | ExtraFlags[i];
 586
 587       hExpected = DISP_E_BADVARTYPE;
 588       /* src is allowed to be a VT_CLSID */
 589       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 590         hExpected = S_OK;
 591
 592       hres = VariantCopy(&vSrc, &vSrc);
 593
 594       ok(hres == hExpected,
 595          "Copy(src==dst): expected 0x%X, got 0x%X for src==dest vt %d|0x%X\n",
 596          hExpected, hres, vt, ExtraFlags[i]);
 597     }
 598   }
 599
 600   /* Test that if VariantClear() fails on dest, the function fails. This also
 601    * shows that dest is in fact cleared and not just overwritten
 602    */
 603   memset(&vSrc, 0, sizeof(vSrc));
 604   V_VT(&vSrc) = VT_UI1;
 605
 606   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 607   {
 608     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 609     {
 610       SKIPTESTS(vt);
 611
 612       hExpected = DISP_E_BADVARTYPE;
 613
 614       memset(&vDst, 0, sizeof(vDst));
 615       V_VT(&vDst) = vt | ExtraFlags[i];
 616
 617       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 618         hExpected = S_OK;
 619
 620       hres = VariantCopy(&vDst, &vSrc);
 621
 622       ok(hres == hExpected,
 623          "Copy(bad dst): expected 0x%X, got 0x%X for dest vt %d|0x%X\n",
 624          hExpected, hres, vt, ExtraFlags[i]);
 625       if (hres == S_OK)
 626         ok(V_VT(&vDst) == VT_UI1,
 627            "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 628     }
 629   }
 630
 631   /* Test that VariantClear() checks vSrc for validity before copying */
 632   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 633   {
 634     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 635     {
 636       SKIPTESTS(vt);
 637
 638       hExpected = DISP_E_BADVARTYPE;
 639
 640       memset(&vDst, 0, sizeof(vDst));
 641       V_VT(&vDst) = VT_EMPTY;
 642
 643       memset(&vSrc, 0, sizeof(vSrc));
 644       V_VT(&vSrc) = vt | ExtraFlags[i];
 645
 646       /* src is allowed to be a VT_CLSID */
 647       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 648         hExpected = S_OK;
 649
 650       hres = VariantCopy(&vDst, &vSrc);
 651
 652       ok(hres == hExpected,
 653          "Copy(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 654          hExpected, hres, vt, ExtraFlags[i]);
 655       if (hres == S_OK)
 656       {
 657         ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
 658            "Copy(bad src): expected vt = %d, got %d\n",
 659            vt | ExtraFlags[i], V_VT(&vDst));
 660         VariantClear(&vDst);
 661       }
 662     }
 663   }
 664
 665   /* Test that copying a NULL BSTR results in an empty BSTR */
 666   memset(&vDst, 0, sizeof(vDst));
 667   V_VT(&vDst) = VT_EMPTY;
 668   memset(&vSrc, 0, sizeof(vSrc));
 669   V_VT(&vSrc) = VT_BSTR;
 670   hres = VariantCopy(&vDst, &vSrc);
 671   ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
 672   if (hres == S_OK)
 673   {
 674     ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
 675        "Copy(NULL BSTR): should have non-NULL result\n");
 676     if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
 677     {
 678       ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
 679     }
 680     VariantClear(&vDst);
 681   }
 682 }
 683
 684 /* Determine if a vt is valid for VariantCopyInd() */
 685 static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
 686 {
 687   int ret = 0;
 688
 689   if ((extraFlags & VT_ARRAY) ||
 690      (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
 691      !(extraFlags & (VT_VECTOR|VT_RESERVED))))
 692   {
 693     ret = 1; /* ok */
 694   }
 695   return ret;
 696 }
 697
 698 static void test_VariantCopyInd(void)
 699 {
 700   VARIANTARG vSrc, vDst, vRef, vRef2;
 701   VARTYPE vt;
 702   size_t i;
 703   BYTE buffer[64];
 704   HRESULT hres, hExpected;
 705
 706   memset(buffer, 0, sizeof(buffer));
 707
 708   /* vSrc == vDst */
 709   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 710   {
 711     if (ExtraFlags[i] & VT_ARRAY)
 712       continue; /* Native crashes on NULL safearray */
 713
 714     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 715     {
 716       SKIPTESTS(vt);
 717
 718       memset(&vSrc, 0, sizeof(vSrc));
 719       V_VT(&vSrc) = vt | ExtraFlags[i];
 720
 721       hExpected = DISP_E_BADVARTYPE;
 722       if (!(ExtraFlags[i] & VT_BYREF))
 723       {
 724         /* if src is not by-reference, acts as VariantCopy() */
 725         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 726           hExpected = S_OK;
 727       }
 728       else
 729       {
 730         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 731             vt == VT_DISPATCH || vt == VT_RECORD)
 732           continue; /* Need valid ptrs for deep copies */
 733
 734         V_BYREF(&vSrc) = &buffer;
 735         hExpected = E_INVALIDARG;
 736
 737         if ((vt == VT_I8 || vt == VT_UI8) &&
 738             ExtraFlags[i] == VT_BYREF)
 739         {
 740           if (HAVE_OLEAUT32_I8)
 741             hExpected = S_OK; /* Only valid if I8 is a known type */
 742         }
 743         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 744           hExpected = S_OK;
 745       }
 746
 747       hres = VariantCopyInd(&vSrc, &vSrc);
 748
 749       ok(hres == hExpected,
 750          "CopyInd(src==dst): expected 0x%X, got 0x%X for src==dst vt %d|0x%X\n",
 751          hExpected, hres, vt, ExtraFlags[i]);
 752     }
 753   }
 754
 755   /* Bad dest */
 756   memset(&vSrc, 0, sizeof(vSrc));
 757   V_VT(&vSrc) = VT_UI1|VT_BYREF;
 758   V_BYREF(&vSrc) = &buffer;
 759
 760   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 761   {
 762     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 763     {
 764       SKIPTESTS(vt);
 765
 766       memset(&vDst, 0, sizeof(vDst));
 767       V_VT(&vDst) = vt | ExtraFlags[i];
 768
 769       hExpected = DISP_E_BADVARTYPE;
 770
 771       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 772         hExpected = S_OK;
 773
 774       hres = VariantCopyInd(&vDst, &vSrc);
 775
 776       ok(hres == hExpected,
 777          "CopyInd(bad dst): expected 0x%X, got 0x%X for dst vt %d|0x%X\n",
 778          hExpected, hres, vt, ExtraFlags[i]);
 779       if (hres == S_OK)
 780         ok(V_VT(&vDst) == VT_UI1,
 781            "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 782     }
 783   }
 784
 785   /* bad src */
 786   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 787   {
 788     if (ExtraFlags[i] & VT_ARRAY)
 789       continue; /* Native crashes on NULL safearray */
 790
 791     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 792     {
 793       SKIPTESTS(vt);
 794
 795       memset(&vDst, 0, sizeof(vDst));
 796       V_VT(&vDst) = VT_EMPTY;
 797
 798       memset(&vSrc, 0, sizeof(vSrc));
 799       V_VT(&vSrc) = vt | ExtraFlags[i];
 800
 801       hExpected = DISP_E_BADVARTYPE;
 802       if (!(ExtraFlags[i] & VT_BYREF))
 803       {
 804         /* if src is not by-reference, acts as VariantCopy() */
 805         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 806           hExpected = S_OK;
 807       }
 808       else
 809       {
 810         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 811             vt == VT_DISPATCH || vt == VT_RECORD)
 812           continue; /* Need valid ptrs for deep copies, see vartype.c */
 813
 814         V_BYREF(&vSrc) = &buffer;
 815
 816         hExpected = E_INVALIDARG;
 817
 818         if ((vt == VT_I8 || vt == VT_UI8) &&
 819             ExtraFlags[i] == VT_BYREF)
 820         {
 821           if (HAVE_OLEAUT32_I8)
 822             hExpected = S_OK; /* Only valid if I8 is a known type */
 823         }
 824         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 825           hExpected = S_OK;
 826       }
 827
 828       hres = VariantCopyInd(&vDst, &vSrc);
 829
 830       ok(hres == hExpected,
 831          "CopyInd(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 832          hExpected, hres, vt, ExtraFlags[i]);
 833       if (hres == S_OK)
 834       {
 835         if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
 836         {
 837           /* Type of vDst should be the type of the referenced variant.
 838            * Since we set the buffer to all zeros, its type should be
 839            * VT_EMPTY.
 840            */
 841           ok(V_VT(&vDst) == VT_EMPTY,
 842              "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
 843              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 844         }
 845         else
 846         {
 847           ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
 848              "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
 849              vt, ExtraFlags[i] & ~VT_BYREF,
 850              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 851         }
 852         VariantClear(&vDst);
 853       }
 854     }
 855   }
 856
 857   /* By-reference variants are dereferenced */
 858   V_VT(&vRef) = VT_UI1;
 859   V_UI1(&vRef) = 0x77;
 860   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 861   V_VARIANTREF(&vSrc) = &vRef;
 862   VariantInit(&vDst);
 863
 864   hres = VariantCopyInd(&vDst, &vSrc);
 865   ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
 866   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
 867      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 868       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 869
 870   /* By-reference variant to a by-reference type succeeds */
 871   V_VT(&vRef) = VT_UI1|VT_BYREF;
 872   V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
 873   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 874   V_VARIANTREF(&vSrc) = &vRef;
 875   VariantInit(&vDst);
 876
 877   hres = VariantCopyInd(&vDst, &vSrc);
 878   ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
 879   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
 880      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 881       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 882
 883   /* But a by-reference variant to a by-reference variant fails */
 884   V_VT(&vRef2) = VT_UI1;
 885   V_UI1(&vRef2) = 0x77;
 886   V_VT(&vRef) = VT_VARIANT|VT_BYREF;
 887   V_VARIANTREF(&vRef) = &vRef2;
 888   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 889   V_VARIANTREF(&vSrc) = &vRef;
 890   VariantInit(&vDst);
 891
 892   hres = VariantCopyInd(&vDst, &vSrc);
 893   ok(hres == E_INVALIDARG,
 894      "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08x\n", hres);
 895 }
 896
 897 static HRESULT (WINAPI *pVarParseNumFromStr)(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
 898
 899 /* Macros for converting and testing the result of VarParseNumFromStr */
 900 #define FAILDIG 255
 901
 902 static HRESULT convert_str( const char *str, INT dig, ULONG flags,
 903                             NUMPARSE *np, BYTE rgb[128], LCID lcid )
 904 {
 905     OLECHAR buff[128];
 906     MultiByteToWideChar( CP_ACP,0, str, -1, buff, sizeof(buff)/sizeof(WCHAR) );
 907     memset( rgb, FAILDIG, 128 );
 908     memset( np, 255, sizeof(*np) );
 909     np->cDig = dig;
 910     np->dwInFlags = flags;
 911     return pVarParseNumFromStr( buff, lcid, LOCALE_NOUSEROVERRIDE, np, rgb);
 912 }
 913
 914 static void expect_NumFromStr( int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c,
 915                                INT d, INT e, INT f )
 916 {
 917     if (hres == (HRESULT)S_OK)
 918     {
 919         ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
 920         ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%x, got 0x%x\n", b, np->dwInFlags);
 921         ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%x, got 0x%x\n", c, np->dwOutFlags);
 922         ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
 923         ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
 924         ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
 925     }
 926 }
 927
 928 #define CONVERTN(str,dig,flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )
 929 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
 930 #define EXPECT(a,b,c,d,e,f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )
 931 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
 932 #define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)
 933 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
 934
 935 static void test_VarParseNumFromStr(void)
 936 {
 937   HRESULT hres;
 938   /* Ensure all tests are using the same locale characters for '$', ',' etc */
 939   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 940   NUMPARSE np;
 941   BYTE rgb[128];
 942
 943   /** No flags **/
 944
 945   CHECKPTR(VarParseNumFromStr);
 946
 947   /* Consume a single digit */
 948   CONVERT("7", 0);
 949   EXPECT(1,0,0,1,0,0);
 950   EXPECT2(7,FAILDIG);
 951
 952   /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
 953   CONVERT("10", 0);
 954   EXPECT(1,0,0,2,0,1);
 955   /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
 956    * but then excludes them from the returned cDig count.
 957    * In our implementation we don't bother writing them at all.
 958    */
 959   EXPECTRGB(0, 1);
 960
 961   /* if cDig is too small and numbers follow, sets INEXACT */
 962   CONVERTN("11",1, 0);
 963   EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
 964   EXPECT2(1,FAILDIG);
 965
 966   /* Strips leading zeros */
 967   CONVERT("01", 0);
 968   EXPECT(1,0,0,2,0,0);
 969   EXPECT2(1,FAILDIG);
 970
 971   /* Strips leading zeros */
 972   CONVERTN("01",1, 0);
 973   EXPECT(1,0,0,2,0,0);
 974   EXPECT2(1,FAILDIG);
 975
 976
 977   /* Fails on non digits */
 978   CONVERT("a", 0);
 979   EXPECTFAIL;
 980   EXPECTRGB(0,FAILDIG);
 981
 982   /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
 983
 984   /* Without flag, fails on whitespace */
 985   CONVERT(" 0", 0);
 986   EXPECTFAIL;
 987   EXPECTRGB(0,FAILDIG);
 988
 989
 990   /* With flag, consumes whitespace */
 991   CONVERT(" 0", NUMPRS_LEADING_WHITE);
 992   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 993   EXPECT2(0,FAILDIG);
 994
 995   /* Test TAB once, then assume it acts as space for all cases */
 996   CONVERT("\t0", NUMPRS_LEADING_WHITE);
 997   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 998   EXPECT2(0,FAILDIG);
 999
1000
1001   /* Doesn't pick up trailing whitespace without flag */
1002   CONVERT("0 ", 0);
1003   EXPECT(1,0,0,1,0,0);
1004   EXPECT2(0,FAILDIG);
1005
1006   /* With flag, consumes trailing whitespace */
1007   CONVERT("0 ", NUMPRS_TRAILING_WHITE);
1008   EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1009   EXPECT2(0,FAILDIG);
1010
1011   /* Leading flag only consumes leading */
1012   CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
1013   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1014   EXPECT2(0,FAILDIG);
1015
1016   /* Both flags consumes both */
1017   CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
1018   EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
1019   EXPECT2(0,FAILDIG);
1020
1021   /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
1022
1023   /* Without flag, fails on + */
1024   CONVERT("+0", 0);
1025   EXPECTFAIL;
1026   EXPECTRGB(0,FAILDIG);
1027
1028   /* With flag, consumes + */
1029   CONVERT("+0", NUMPRS_LEADING_PLUS);
1030   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1031   EXPECT2(0,FAILDIG);
1032
1033   /* Without flag, doesn't consume trailing + */
1034   CONVERT("0+", 0);
1035   EXPECT(1,0,0,1,0,0);
1036   EXPECT2(0,FAILDIG);
1037
1038   /* With flag, consumes trailing + */
1039   CONVERT("0+", NUMPRS_TRAILING_PLUS);
1040   EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
1041   EXPECT2(0,FAILDIG);
1042
1043   /* With leading flag, doesn't consume trailing + */
1044   CONVERT("+0+", NUMPRS_LEADING_PLUS);
1045   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1046   EXPECT2(0,FAILDIG);
1047
1048   /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
1049   CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
1050   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1051   EXPECT2(0,FAILDIG);
1052
1053   /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
1054
1055   /* Without flag, fails on - */
1056   CONVERT("-0", 0);
1057   EXPECTFAIL;
1058   EXPECTRGB(0,FAILDIG);
1059
1060   /* With flag, consumes - */
1061   CONVERT("-0", NUMPRS_LEADING_MINUS);
1062   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1063   EXPECT2(0,FAILDIG);
1064
1065   /* Without flag, doesn't consume trailing - */
1066   CONVERT("0-", 0);
1067   EXPECT(1,0,0,1,0,0);
1068   EXPECT2(0,FAILDIG);
1069
1070   /* With flag, consumes trailing - */
1071   CONVERT("0-", NUMPRS_TRAILING_MINUS);
1072   EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
1073   EXPECT2(0,FAILDIG);
1074
1075   /* With leading flag, doesn't consume trailing - */
1076   CONVERT("-0-", NUMPRS_LEADING_MINUS);
1077   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1078   EXPECT2(0,FAILDIG);
1079
1080   /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
1081   CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
1082   EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1083   EXPECT2(0,FAILDIG);
1084
1085   /** NUMPRS_HEX_OCT **/
1086
1087   /* Could be hex, octal or decimal - With flag reads as decimal */
1088   CONVERT("0", NUMPRS_HEX_OCT);
1089   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1090   EXPECT2(0,FAILDIG);
1091
1092   /* Doesn't recognise hex in .asm syntax */
1093   CONVERT("0h", NUMPRS_HEX_OCT);
1094   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1095   EXPECT2(0,FAILDIG);
1096
1097   /* Doesn't fail with valid leading string but no digits */
1098   CONVERT("0x", NUMPRS_HEX_OCT);
1099   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1100   EXPECT2(0,FAILDIG);
1101
1102   /* Doesn't recognise hex format numbers at all! */
1103   CONVERT("0x0", NUMPRS_HEX_OCT);
1104   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1105   EXPECT2(0,FAILDIG);
1106
1107   /* Doesn't recognise plain hex digits either */
1108   CONVERT("FE", NUMPRS_HEX_OCT);
1109   EXPECTFAIL;
1110   EXPECTRGB(0,FAILDIG);
1111
1112   /* Octal */
1113   CONVERT("0100", NUMPRS_HEX_OCT);
1114   EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
1115   EXPECTRGB(0,1);
1116   EXPECTRGB(1,0);
1117   EXPECTRGB(2,0);
1118   EXPECTRGB(3,FAILDIG);
1119
1120   /* VB hex */
1121   CONVERT("&HF800", NUMPRS_HEX_OCT);
1122   EXPECT(4,NUMPRS_HEX_OCT,0x40,6,4,0);
1123   EXPECTRGB(0,15);
1124   EXPECTRGB(1,8);
1125   EXPECTRGB(2,0);
1126   EXPECTRGB(3,0);
1127   EXPECTRGB(4,FAILDIG);
1128
1129   /* VB hex lower case and leading zero */
1130   CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
1131   EXPECT(6,NUMPRS_HEX_OCT,0x40,9,4,0);
1132   EXPECTRGB(0,10);
1133   EXPECTRGB(1,11);
1134   EXPECTRGB(2,12);
1135   EXPECTRGB(3,13);
1136   EXPECTRGB(4,14);
1137   EXPECTRGB(5,15);
1138   EXPECTRGB(6,FAILDIG);
1139
1140   /* VB oct */
1141   CONVERT("&O300", NUMPRS_HEX_OCT);
1142   EXPECT(3,NUMPRS_HEX_OCT,0x40,5,3,0);
1143   EXPECTRGB(0,3);
1144   EXPECTRGB(1,0);
1145   EXPECTRGB(2,0);
1146   EXPECTRGB(3,FAILDIG);
1147
1148   /* VB oct lower case and leading zero */
1149   CONVERT("&o0777", NUMPRS_HEX_OCT);
1150   EXPECT(3,NUMPRS_HEX_OCT,0x40,6,3,0);
1151   EXPECTRGB(0,7);
1152   EXPECTRGB(1,7);
1153   EXPECTRGB(2,7);
1154   EXPECTRGB(3,FAILDIG);
1155
1156   /* VB oct char bigger than 7 */
1157   CONVERT("&o128", NUMPRS_HEX_OCT);
1158 /*
1159   Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
1160   EXPECTFAIL;
1161   EXPECTRGB(0,FAILDIG);
1162 */
1163   /** NUMPRS_PARENS **/
1164
1165   /* Empty parens = error */
1166   CONVERT("()", NUMPRS_PARENS);
1167   EXPECTFAIL;
1168   EXPECTRGB(0,FAILDIG);
1169
1170   /* With flag, trailing parens not consumed */
1171   CONVERT("0()", NUMPRS_PARENS);
1172   EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1173   EXPECT2(0,FAILDIG);
1174
1175   /* With flag, Number in parens made negative and parens consumed */
1176   CONVERT("(0)", NUMPRS_PARENS);
1177   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1178   EXPECT2(0,FAILDIG);
1179
1180   /** NUMPRS_THOUSANDS **/
1181
1182   /* With flag, thousands sep. not needed */
1183   CONVERT("0", NUMPRS_THOUSANDS);
1184   EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1185   EXPECT2(0,FAILDIG);
1186
1187   /* With flag, thousands sep. and following digits consumed */
1188   CONVERT("1,000", NUMPRS_THOUSANDS);
1189   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1190   EXPECTRGB(0,1);
1191
1192   /* With flag and decimal point, thousands sep. but not decimals consumed */
1193   CONVERT("1,000.0", NUMPRS_THOUSANDS);
1194   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1195   EXPECTRGB(0,1);
1196
1197   /** NUMPRS_CURRENCY **/
1198
1199   /* Without flag, chokes on currency sign */
1200   CONVERT("$11", 0);
1201   EXPECTFAIL;
1202   EXPECTRGB(0,FAILDIG);
1203
1204   /* With flag, consumes currency sign */
1205   CONVERT("$11", NUMPRS_CURRENCY);
1206   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1207   EXPECT2(1,1);
1208   EXPECTRGB(2,FAILDIG);
1209
1210   /* With flag only, doesn't consume decimal point */
1211   CONVERT("$11.1", NUMPRS_CURRENCY);
1212   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1213   EXPECT2(1,1);
1214   EXPECTRGB(2,FAILDIG);
1215
1216   /* With flag and decimal flag, consumes decimal point and following digits */
1217   CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1218   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1219   EXPECT2(1,1);
1220   EXPECTRGB(2,1);
1221   EXPECTRGB(3,FAILDIG);
1222
1223   /* Thousands flag can only be used with currency */
1224   CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1225   EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1226   EXPECT2(1,2);
1227   EXPECTRGB(2,3);
1228   EXPECTRGB(3,4);
1229   EXPECTRGB(4,FAILDIG);
1230
1231   /** NUMPRS_DECIMAL **/
1232
1233   /* With flag, consumes decimal point */
1234   CONVERT("1.1", NUMPRS_DECIMAL);
1235   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1236   EXPECT2(1,1);
1237   EXPECTRGB(2,FAILDIG);
1238
1239   /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1240   CONVERT("1.", NUMPRS_DECIMAL);
1241   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1242   EXPECT2(1,FAILDIG);
1243
1244   /* Consumes only one decimal point */
1245   CONVERT("1.1.", NUMPRS_DECIMAL);
1246   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1247   EXPECT2(1,1);
1248   EXPECTRGB(2,FAILDIG);
1249
1250   /** NUMPRS_EXPONENT **/
1251
1252   /* Without flag, doesn't consume exponent */
1253   CONVERT("1e1", 0);
1254   EXPECT(1,0,0,1,0,0);
1255   EXPECT2(1,FAILDIG);
1256
1257   /* With flag, consumes exponent */
1258   CONVERT("1e1", NUMPRS_EXPONENT);
1259   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1260   EXPECT2(1,FAILDIG);
1261
1262   /* Negative exponents are accepted without flags */
1263   CONVERT("1e-1", NUMPRS_EXPONENT);
1264   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1265   EXPECT2(1,FAILDIG);
1266
1267   /* As are positive exponents and leading exponent 0s */
1268   CONVERT("1e+01", NUMPRS_EXPONENT);
1269   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1270   EXPECT2(1,FAILDIG);
1271
1272   /* The same for zero exponents */
1273   CONVERT("1e0", NUMPRS_EXPONENT);
1274   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1275   EXPECT2(1,FAILDIG);
1276
1277   /* Sign on a zero exponent doesn't matter */
1278   CONVERT("1e+0", NUMPRS_EXPONENT);
1279   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1280   EXPECT2(1,FAILDIG);
1281
1282   CONVERT("1e-0", NUMPRS_EXPONENT);
1283   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1284   EXPECT2(1,FAILDIG);
1285
1286   /* Doesn't consume a real number exponent */
1287   CONVERT("1e1.", NUMPRS_EXPONENT);
1288   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1289   EXPECT2(1,FAILDIG);
1290
1291   /* Powers of 10 are calculated from the position of any decimal point */
1292   CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1293   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1294   EXPECT2(1,5);
1295
1296   CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1297   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1298   EXPECT2(1,5);
1299
1300   /** NUMPRS_USE_ALL **/
1301
1302   /* Flag expects all digits */
1303   CONVERT("0", NUMPRS_USE_ALL);
1304   EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1305   EXPECT2(0,FAILDIG);
1306
1307   /* Rejects anything trailing */
1308   CONVERT("0 ", NUMPRS_USE_ALL);
1309   EXPECTFAIL;
1310   EXPECT2(0,FAILDIG);
1311
1312   /* Unless consumed by trailing flag */
1313   CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1314   EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1315   EXPECT2(0,FAILDIG);
1316
1317   /** Combinations **/
1318
1319   /* Leading whitespace and plus, doesn't consume trailing whitespace */
1320   CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1321   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1322   EXPECT2(0,FAILDIG);
1323
1324   /* Order of whitespace and plus is unimportant */
1325   CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1326   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1327   EXPECT2(0,FAILDIG);
1328
1329   /* Leading whitespace can be repeated */
1330   CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1331   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1332   EXPECT2(0,FAILDIG);
1333
1334   /* But plus/minus etc. cannot */
1335   CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1336   EXPECTFAIL;
1337   EXPECTRGB(0,FAILDIG);
1338
1339   /* Inexact is not set if trailing zeros are removed */
1340   CONVERTN("10", 1, 0);
1341   EXPECT(1,0,0,2,0,1);
1342   EXPECT2(1,FAILDIG);
1343
1344   /* Make sure a leading 0 is stripped but decimals after it get read */
1345   CONVERT("-0.51", NUMPRS_STD);
1346   EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1347   EXPECT2(5,1);
1348
1349   /* Keep trailing zeros on whole number part of a decimal */
1350   CONVERT("10.1", NUMPRS_STD);
1351   EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1352   EXPECT2(1,0);
1353   EXPECTRGB(2,1);
1354
1355   /* Zeros after decimal sign */
1356   CONVERT("0.01", NUMPRS_STD);
1357   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1358   EXPECT2(1,FAILDIG);
1359
1360   /* Trailing zeros after decimal part */
1361   CONVERT("0.10", NUMPRS_STD);
1362   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1363   EXPECT2(1,0);
1364 }
1365
1366 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1367
1368 /* Macros for converting and testing the result of VarNumFromParseNum */
1369 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1370 #undef CONVERT
1371 #define CONVERT(a,b,c,d,e,f,bits) \
1372     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1373     np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1374 static const char *szFailOverflow = "Expected overflow, hres = %08x\n";
1375 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1376 static const char *szFailOk = "Call failed, hres = %08x\n";
1377 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1378   if (hres == (HRESULT)S_OK)
1379 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1380 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1381   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1382 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1383   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1384 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1385   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1386 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1387   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1388 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1389   ok(V_I4(&vOut) == val, "Expected i4 = %d, got %d\n", (LONG)val, V_I4(&vOut)); }
1390 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1391   ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
1392 #define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1393   ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
1394      (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
1395 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1396   ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
1397       (DWORD)((ULONG64)val >> 32), (DWORD)(ULONG64)val, (DWORD)(V_UI8(&vOut) >> 32), (DWORD)V_UI8(&vOut)); }
1398 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1399   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1400 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1401   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1402 #define CY_MULTIPLIER 10000
1403 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1404   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = 0x%x%08x, got 0x%x%08x\n", \
1405       (DWORD)((LONG64)val >> 23), (DWORD)(LONG64)val, (DWORD)(V_CY(&vOut).int64 >>32), (DWORD)V_CY(&vOut).int64); }
1406 #define EXPECT_DECIMAL(valHi, valMid, valLo) EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
1407       ok((V_DECIMAL(&vOut).Hi32 == valHi) && (S1(U1(V_DECIMAL(&vOut))).Mid32 == valMid) && \
1408       (S1(U1(V_DECIMAL(&vOut))).Lo32 == valLo),                      \
1409   "Expected decimal = %x/0x%x%08x, got %x/0x%x%08x\n", valHi, valMid, valLo, \
1410       V_DECIMAL(&vOut).Hi32, S1(U1(V_DECIMAL(&vOut))).Mid32, S1(U1(V_DECIMAL(&vOut))).Lo32); }
1411
1412 static void test_VarNumFromParseNum(void)
1413 {
1414   HRESULT hres;
1415   NUMPARSE np;
1416   BYTE rgb[128];
1417   VARIANT vOut;
1418
1419   CHECKPTR(VarNumFromParseNum);
1420
1421   /* Convert the number 1 to different types */
1422   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1423   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1424   /* Prefers a signed type to unsigned of the same size */
1425   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1426   /* But takes the smaller size if possible */
1427   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1428
1429   /* Try different integer sizes */
1430 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1431
1432   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1433   /* 127 */
1434   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1435   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1436   /* 128 */
1437   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1438   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1439   /* 255 */
1440   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1441   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1442   /* 256 */
1443   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1444   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1445   /* 32767 */
1446   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1447   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1448   /* 32768 */
1449   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1450   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1451
1452   /* Assume the above pattern holds for remaining positive integers; test negative */
1453
1454   /* -128 */
1455   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1456   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1457   /* -129 */
1458   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1459   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1460   /* -32768 */
1461   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1462   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1463   /* -32768 */
1464   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1465   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1466
1467   /* Assume the above pattern holds for remaining negative integers */
1468
1469   /* Test hexadecimal conversions */
1470   SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
1471   /* 0x7f */
1472   SETRGB(0, 7); SETRGB(1, 0xf);
1473   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
1474   SETRGB(0, 7); SETRGB(1, 0xf);
1475   CONVERT(2,0,0,2,4,0, VTBIT_DECIMAL); EXPECT_DECIMAL(0,0,0x7f);
1476   /* 0x7fff */
1477   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1478   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
1479   /* 0x7fffffff */
1480   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1481   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1482   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
1483   /* 0x7fffffffffffffff (64 bits) */
1484   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1485   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1486   SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
1487   SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
1488   if (HAVE_OLEAUT32_I8)
1489   {
1490     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1491        truncate the number to the smallest integer size requested:
1492        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
1493     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffff,0xffffffff);
1494   }
1495
1496   /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
1497   /* 0x82 */
1498   SETRGB(0, 8); SETRGB(1, 2);
1499   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
1500   EXPECT_I1((signed char)0x82);
1501   /* 0x8002 */
1502   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1503   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
1504   EXPECT_I2((signed short)0x8002);
1505   /* 0x80000002 */
1506   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1507   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1508   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
1509   /* 0x8000000000000002 (64 bits) */
1510   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1511   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1512   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1513   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1514   if (HAVE_OLEAUT32_I8)
1515   {
1516     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1517        truncate the number to the smallest integer size requested:
1518        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
1519        EXPECT_I2((signed short)0x0002); */
1520     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1521   }
1522
1523   /* Test (preservation of) hi-bit with STRICT type requesting */
1524   /* 0x82 */
1525   SETRGB(0, 8); SETRGB(1, 2);
1526   CONVERT(2,0,0,2,4,0, VTBIT_I1);
1527   EXPECT_I1((signed char)0x82);
1528   /* 0x8002 */
1529   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1530   CONVERT(4,0,0,4,4,0, VTBIT_I2);
1531   EXPECT_I2((signed short)0x8002);
1532   /* 0x80000002 */
1533   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1534   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1535   CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
1536   /* 0x8000000000000002 (64 bits) */
1537   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1538   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1539   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1540   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1541   if (HAVE_OLEAUT32_I8)
1542   {
1543     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1544   }
1545   /* Assume the above pattern holds for numbers with hi-bit set */
1546
1547   /* Negative numbers overflow if we have only unsigned outputs */
1548   /* -1 */
1549   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1550   /* -0.6 */
1551   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1552
1553   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1554   /* -0.5 */
1555   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1556
1557   /* Floating point zero is OK */
1558   /* 0.00000000E0 */
1559   SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
1560   EXPECT_R8(0.0);
1561
1562   /* Float is acceptable for an integer input value */
1563   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1564   /* As is double */
1565   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1566   /* As is currency */
1567   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1568
1569   /* Float is preferred over double */
1570   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1571
1572   /* Double is preferred over currency */
1573   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1574
1575   /* Currency is preferred over decimal */
1576   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1577 }
1578
1579
1580 static void test_UdateFromDate( int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y,
1581                                 WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)
1582 {
1583     UDATE ud;
1584     HRESULT res;
1585
1586     memset(&ud, 0, sizeof(ud));
1587     res = pVarUdateFromDate(dt, flags, &ud);
1588     ok_(__FILE__,line)(r == res && (res != S_OK || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
1589                        ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
1590                        ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)),
1591                        "%.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",
1592                        dt, r, d, m, y, h, mn, s, ms, dw, dy,
1593                        res, ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
1594                        ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
1595 }
1596 #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)
1597
1598 static void test_VarUdateFromDate(void)
1599 {
1600   CHECKPTR(VarUdateFromDate);
1601   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
1602   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
1603   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
1604   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
1605   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
1606   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1607   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
1608   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
1609
1610   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1611   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1612   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1613
1614   /* Times */
1615   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
1616   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
1617   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
1618   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1619   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1620
1621   /* Test handling of times on dates prior to the epoch */
1622   DT2UD(-5.25,0,S_OK,25,12,1899,6,0,0,0,1,359);
1623   DT2UD(-5.9999884259259,0,S_OK,25,12,1899,23,59,59,0,1,359);
1624   /* This just demostrates the non-linear nature of values prior to the epoch */
1625   DT2UD(-4.0,0,S_OK,26,12,1899,0,0,0,0,2,360);
1626   /* Numerical oddity: for 0.0 < x < 1.0, x and -x represent the same datetime */
1627   DT2UD(-0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1628   DT2UD(0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1629 }
1630
1631
1632 static void test_DateFromUDate( int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms,
1633                                 WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt )
1634 {
1635     UDATE ud;
1636     double out;
1637     HRESULT res;
1638
1639     ud.st.wYear = y;
1640     ud.st.wMonth = m;
1641     ud.st.wDay = d;
1642     ud.st.wHour = h;
1643     ud.st.wMinute = mn;
1644     ud.st.wSecond = s;
1645     ud.st.wMilliseconds = ms;
1646     ud.st.wDayOfWeek = dw;
1647     ud.wDayOfYear = dy;
1648     res = pVarDateFromUdate(&ud, flags, &out);
1649     ok_(__FILE__,line)(r == res && (r != S_OK || EQ_DOUBLE(out, dt)),
1650                        "expected %x, %.16g, got %x, %.16g\n", r, dt, res, out);
1651 }
1652 #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)
1653
1654 static void test_VarDateFromUdate(void)
1655 {
1656   CHECKPTR(VarDateFromUdate);
1657   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
1658   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
1659   UD2T(2,1,1980,0,0,0,0,4,5,0,S_OK,29222.0);      /* 2 Jan 1980 */
1660   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
1661   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
1662   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
1663   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
1664   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
1665   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
1666   UD2T(1,1,-10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0);/* < -9999 => err  */
1667
1668   UD2T(30,12,1899,0,0,0,0,0,0,0,S_OK,0.0); /* 30 Dec 1899 0:00:00  */
1669   UD2T(30,12,1899,0,0,0,999,0,0,0,S_OK,0.0); /* Ignore milliseconds  */
1670
1671   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963);             /* 6:18:02 PM */
1672   UD2T(1,300,1980,18,1,16,0,2,1,0,S_OK,38322.75087962963);           /* Test fwdrolled month */
1673   UD2T(300,1,1980,18,1,16,0,2,1,0,S_OK,29520.75087962963);           /* Test fwdrolled days */
1674   UD2T(0,1,1980,42,1,16,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled hours */
1675   UD2T(1,1,1980,17,61,16,0,2,1,0,S_OK,29221.75087962963);            /* Test fwdrolled minutes */
1676   UD2T(1,1,1980,18,0,76,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled seconds */
1677   UD2T(1,-300,1980,18,1,16,0,2,1,0,S_OK,20059.75087962963);          /* Test backrolled month */
1678   UD2T(-300,1,1980,18,1,16,0,2,1,0,S_OK,28920.75087962963);          /* Test backrolled days */
1679   UD2T(3,1,1980,-30,1,16,0,2,1,0,S_OK,29221.75087962963);            /* Test backrolled hours */
1680   UD2T(1,1,1980,20,-119,16,0,2,1,0,S_OK,29221.75087962963);          /* Test backrolled minutes */
1681   UD2T(1,1,1980,18,3,-104,0,2,1,0,S_OK,29221.75087962963);           /* Test backrolled seconds */
1682   UD2T(1,12001,-1020,18,1,16,0,0,0,0,S_OK,29221.75087962963);        /* Test rolled year and month */
1683   UD2T(1,-23,1982,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled month */
1684   UD2T(-59,3,1980,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled days */
1685   UD2T(1,1,0,0,0,0,0,0,0,0,S_OK,36526);                              /* Test zero year */
1686   UD2T(0,0,1980,0,0,0,0,0,0,0,S_OK,29189);                           /* Test zero day and month */
1687   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);                         /* Test zero day = LastDayOfMonth */
1688   UD2T(-1,1,1980,18,1,16,0,0,0,0,S_OK,29219.75087962963);            /* Test day -1 = LastDayOfMonth - 1 */
1689   UD2T(1,1,-1,18,1,16,0,0,0,0,S_OK,36161.75087962963);               /* Test year -1 = 1999 */
1690   UD2T(1,-1,1980,18,1,16,0,0,0,0,S_OK,29160.7508796296);             /* Test month -1 = 11 */
1691   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);                        /* Rolls fwd to 1/1/1981 */
1692
1693   /* Test handling of times on dates prior to the epoch */
1694   UD2T(25,12,1899,6,0,0,0,1,359,0,S_OK,-5.25);
1695   UD2T(25,12,1899,23,59,59,0,1,359,0,S_OK,-5.9999884259259);
1696   /* This just demostrates the non-linear nature of values prior to the epoch */
1697   UD2T(26,12,1899,0,0,0,0,2,360,0,S_OK,-4.0);
1698   /* for DATE values 0.0 < x < 1.0, x and -x represent the same datetime */
1699   /* but when converting to DATE, prefer the positive versions */
1700   UD2T(30,12,1899,6,0,0,0,6,364,0,S_OK,0.25);
1701 }
1702
1703 static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1704                        WORD s, WORD ms, INT r, double dt)
1705 {
1706     SYSTEMTIME st;
1707     double out;
1708     INT res;
1709
1710     st.wYear = y;
1711     st.wMonth = m;
1712     st.wDay = d;
1713     st.wHour = h;
1714     st.wMinute = mn;
1715     st.wSecond = s;
1716     st.wMilliseconds = ms;
1717     st.wDayOfWeek = 0;
1718     res = pSystemTimeToVariantTime(&st, &out);
1719     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1720                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1721 }
1722 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)
1723
1724 static void test_SystemTimeToVariantTime(void)
1725 {
1726   CHECKPTR(SystemTimeToVariantTime);
1727   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1728   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1729   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
1730   ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1731   ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* year < 100 is 1900+year! */
1732 }
1733
1734 static void test_dt2st(int line, double dt, INT r, WORD d, WORD m, WORD y,
1735                        WORD h, WORD mn, WORD s, WORD ms)
1736 {
1737   SYSTEMTIME st;
1738   INT res;
1739
1740   memset(&st, 0, sizeof(st));
1741   res = pVariantTimeToSystemTime(dt, &st);
1742   ok_(__FILE__,line)(r == res &&
1743                      (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
1744                              st.wHour == h && st.wMinute == mn &&
1745                              st.wSecond == s && st.wMilliseconds == ms)),
1746                      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
1747                      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
1748                      st.wYear, st.wHour, st.wMinute, st.wSecond,
1749                      st.wMilliseconds);
1750 }
1751 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)
1752
1753 static void test_VariantTimeToSystemTime(void)
1754 {
1755   CHECKPTR(VariantTimeToSystemTime);
1756   DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1757   DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1758 }
1759
1760 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1761 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1762
1763 static void test_dos2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1764                         WORD s, INT r, double dt)
1765 {
1766     unsigned short dosDate, dosTime;
1767     double out;
1768     INT res;
1769
1770     out = 0.0;
1771     dosDate = MKDOSDATE(d, m, y);
1772     dosTime = MKDOSTIME(h, mn, s);
1773     res = pDosDateTimeToVariantTime(dosDate, dosTime, &out);
1774     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1775                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1776 }
1777 #define DOS2DT(d,m,y,h,mn,s,r,dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)
1778
1779 static void test_DosDateTimeToVariantTime(void)
1780 {
1781   CHECKPTR(DosDateTimeToVariantTime);
1782
1783   /* Date */
1784   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1785   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1786   /* Dates are limited to the dos date max of 31/12/2099 */
1787   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1788   /* Days and months of 0 cause date to roll back 1 day or month */
1789   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1790   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
1791   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1792   /* Days > days in the month cause date to roll forward 1 month */
1793   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1794   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1795   /* Takes leap years into account when rolling forward */
1796   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1797   /* Months > 12 cause an error */
1798   DOS2DT(2,13,1980,0,0,0,0,0.0);
1799
1800   /* Time */
1801   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1802   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1803   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1804   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid minutes */
1805   DOS2DT(1,1,1980,0,0,60,0,0.0);               /* Invalid seconds */
1806   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1807   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
1808
1809   DOS2DT(1,1,1980,0,0,1,1,29221.0);
1810   DOS2DT(2,1,1980,0,0,0,1,29222.0);
1811   DOS2DT(2,1,1980,0,0,0,1,29222.0);
1812   DOS2DT(31,12,1990,0,0,0,1,33238.0);
1813   DOS2DT(31,12,90,0,0,0,1,40543.0);
1814   DOS2DT(30,12,1899,0,0,0,1,46751.0);
1815   DOS2DT(1,1,100,0,0,0,1,43831.0);
1816   DOS2DT(31,12,9999,0,0,0,1,59901.0);
1817   DOS2DT(1,1,10000,0,0,0,1,59902.0);
1818   DOS2DT(1,1,-10000,0,0,0,1,48214.0);
1819
1820   DOS2DT(30,12,1899,0,0,0,1,46751.0);
1821   DOS2DT(30,12,1899,0,0,1,1,46751.0);
1822
1823   DOS2DT(1,1,1980,18,1,16,1,29221.75087962963);
1824   DOS2DT(1,300,1980,18,1,16,1,29556.75087962963);
1825   DOS2DT(300,1,1980,18,1,16,1,29232.75087962963);
1826   DOS2DT(0,1,1980,42,1,16,1,29220.4175462963);
1827   DOS2DT(1,1,1980,17,61,16,0,0.0);
1828   DOS2DT(1,1,1980,18,0,76,1,29221.75013888889);
1829   DOS2DT(1,-300,1980,18,1,16,1,29312.75087962963);
1830   DOS2DT(-300,1,1980,18,1,16,1,29240.75087962963);
1831   DOS2DT(3,1,1980,-30,1,16,1,29223.08421296296);
1832   DOS2DT(1,1,1980,20,-119,16,1,29221.83976851852);
1833   DOS2DT(1,1,1980,18,3,-104,1,29221.75236111111);
1834   DOS2DT(1,12001,-1020,18,1,16,1,55519.75087962963);
1835   DOS2DT(1,-23,1982,18,1,16,1,30195.75087962963);
1836   DOS2DT(-59,3,1980,18,1,16,1,29285.75087962963);
1837   DOS2DT(1,1,0,0,0,0,1,54058.0);
1838   DOS2DT(0,0,1980,0,0,0,1,29189.0);
1839   DOS2DT(0,1,1980,0,0,0,1,29220.0);
1840   DOS2DT(-1,1,1980,18,1,16,1,29251.75087962963);
1841   DOS2DT(1,1,-1,18,1,16,1,53693.75087962963);
1842   DOS2DT(1,-1,1980,18,1,16,0,0);
1843 }
1844
1845 static void test_dt2dos(int line, double dt, INT r, WORD d, WORD m, WORD y,
1846                         WORD h, WORD mn, WORD s)
1847 {
1848     unsigned short dosDate, dosTime, expDosDate, expDosTime;
1849     INT res;
1850
1851     dosTime = dosDate = 0;
1852     expDosDate = MKDOSDATE(d,m,y);
1853     expDosTime = MKDOSTIME(h,mn,s);
1854     res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime);
1855     ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
1856                        "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
1857                        dt, r, expDosDate, expDosDate & 0x1f,
1858                        (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
1859                        expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
1860                        (expDosTime & 0x1f),
1861                        res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
1862                        1980 + (dosDate >> 9), dosTime, dosTime >> 11,
1863                        (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
1864 }
1865 #define DT2DOS(dt,r,d,m,y,h,mn,s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)
1866
1867 static void test_VariantTimeToDosDateTime(void)
1868 {
1869   CHECKPTR(VariantTimeToDosDateTime);
1870
1871   /* Date */
1872   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
1873   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1874   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
1875   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
1876
1877   /* Time */
1878   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1879   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1880   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1881   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1882 }
1883
1884 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1885
1886 #define VARABS(vt,val,rvt,rval)                  \
1887     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
1888     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1889     test_var_call1( __LINE__, pVarAbs, &v, &exp )
1890
1891 static void test_VarAbs(void)
1892 {
1893     static WCHAR szNum[] = {'-','1','.','1','\0' };
1894     char buff[8];
1895     HRESULT hres;
1896     VARIANT v, vDst, exp;
1897     size_t i;
1898
1899     CHECKPTR(VarAbs);
1900
1901     /* Test all possible V_VT values.
1902      */
1903     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1904     {
1905         VARTYPE vt;
1906
1907         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1908         {
1909             HRESULT hExpected = DISP_E_BADVARTYPE;
1910
1911             SKIPTESTS(vt);
1912
1913             memset(&v, 0, sizeof(v));
1914             V_VT(&v) = vt | ExtraFlags[i];
1915             V_VT(&vDst) = VT_EMPTY;
1916
1917             hres = pVarAbs(&v,&vDst);
1918             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1919                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1920                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1921             {
1922                 hExpected = DISP_E_TYPEMISMATCH;
1923             }
1924             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1925             {
1926                 hExpected = DISP_E_BADVARTYPE;
1927             }
1928             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1929                 hExpected = S_OK;
1930
1931             /* Native always fails on some vartypes that should be valid. don't
1932              * check that Wine does the same; these are bugs in native.
1933              */
1934             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1935                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1936                 continue;
1937             ok(hres == hExpected, "VarAbs: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
1938                hExpected, hres, vt, ExtraFlags[i]);
1939         }
1940     }
1941
1942     /* BOOL->I2, BSTR->R8, all others remain the same */
1943     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1944     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1945     VARABS(EMPTY,0,I2,0);
1946     VARABS(EMPTY,1,I2,0);
1947     VARABS(NULL,0,NULL,0);
1948     VARABS(NULL,1,NULL,0);
1949     VARABS(I2,1,I2,1);
1950     VARABS(I2,-1,I2,1);
1951     VARABS(I4,1,I4,1);
1952     VARABS(I4,-1,I4,1);
1953     VARABS(UI1,1,UI1,1);
1954     VARABS(R4,1,R4,1);
1955     VARABS(R4,-1,R4,1);
1956     VARABS(R8,1,R8,1);
1957     VARABS(R8,-1,R8,1);
1958     VARABS(DATE,1,DATE,1);
1959     VARABS(DATE,-1,DATE,1);
1960     V_VT(&v) = VT_CY;
1961     V_CY(&v).int64 = -10000;
1962     memset(&vDst,0,sizeof(vDst));
1963     hres = pVarAbs(&v,&vDst);
1964     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1965        "VarAbs(CY): expected 0x0 got 0x%X\n", hres);
1966     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1967     if (buff[1])
1968     {
1969         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1970         return;
1971     } else {
1972         szNum[2] = buff[0];
1973     }
1974     V_VT(&v) = VT_BSTR;
1975     V_BSTR(&v) = (BSTR)szNum;
1976     memset(&vDst,0,sizeof(vDst));
1977     hres = pVarAbs(&v,&vDst);
1978     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1979        "VarAbs: expected 0x0,%d,%g, got 0x%X,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1980 }
1981
1982 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
1983
1984 #define VARNOT(vt,val,rvt,rval)                  \
1985     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
1986     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1987     test_var_call1( __LINE__, pVarNot, &v, &exp )
1988
1989 static void test_VarNot(void)
1990 {
1991     static const WCHAR szNum0[] = {'0','\0' };
1992     static const WCHAR szNum1[] = {'1','\0' };
1993     HRESULT hres;
1994     VARIANT v, exp, vDst;
1995     DECIMAL *pdec = &V_DECIMAL(&v);
1996     CY *pcy = &V_CY(&v);
1997     size_t i;
1998
1999     CHECKPTR(VarNot);
2000
2001     /* Test all possible V_VT values */
2002     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2003     {
2004         VARTYPE vt;
2005
2006         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2007         {
2008             HRESULT hExpected = DISP_E_BADVARTYPE;
2009
2010             SKIPTESTS(vt);
2011
2012             memset(&v, 0, sizeof(v));
2013             V_VT(&v) = vt | ExtraFlags[i];
2014             V_VT(&vDst) = VT_EMPTY;
2015
2016             switch (V_VT(&v))
2017             {
2018             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
2019             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
2020             case VT_R4:  case VT_R8:
2021             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2022             case VT_DATE: case VT_CY:
2023                 hExpected = S_OK;
2024                 break;
2025             case VT_I8: case VT_UI8:
2026                 if (HAVE_OLEAUT32_I8)
2027                     hExpected = S_OK;
2028                 break;
2029             case VT_RECORD:
2030                 if (HAVE_OLEAUT32_RECORD)
2031                     hExpected = DISP_E_TYPEMISMATCH;
2032                 break;
2033             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
2034                 hExpected = DISP_E_TYPEMISMATCH;
2035                 break;
2036             default:
2037                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
2038                    hExpected = DISP_E_TYPEMISMATCH;
2039                 break;
2040             }
2041
2042             hres = pVarNot(&v,&vDst);
2043             ok(hres == hExpected, "VarNot: expected 0x%X, got 0x%X vt %d|0x%X\n",
2044                hExpected, hres, vt, ExtraFlags[i]);
2045         }
2046     }
2047     /* Test the values returned by all cases that can succeed */
2048     VARNOT(EMPTY,0,I2,-1);
2049     VARNOT(EMPTY,1,I2,-1);
2050     VARNOT(NULL,0,NULL,0);
2051     VARNOT(NULL,1,NULL,0);
2052     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
2053     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
2054     VARNOT(I1,-1,I4,0);
2055     VARNOT(I1,0,I4,-1);
2056     VARNOT(I2,-1,I2,0);
2057     VARNOT(I2,0,I2,-1);
2058     VARNOT(I2,1,I2,-2);
2059     VARNOT(I4,1,I4,-2);
2060     VARNOT(I4,0,I4,-1);
2061     VARNOT(UI1,1,UI1,254);
2062     VARNOT(UI1,0,UI1,255);
2063     VARNOT(UI2,0,I4,-1);
2064     VARNOT(UI2,1,I4,-2);
2065     VARNOT(UI4,0,I4,-1);
2066     VARNOT(UI4,1,I4,-2);
2067     VARNOT(INT,0,I4,-1);
2068     VARNOT(INT,1,I4,-2);
2069     VARNOT(UINT,0,I4,-1);
2070     VARNOT(UINT,1,I4,-2);
2071     if (HAVE_OLEAUT32_I8)
2072     {
2073         VARNOT(I8,1,I8,-2);
2074         VARNOT(I8,0,I8,-1);
2075         VARNOT(UI8,0,I4,-1);
2076         VARNOT(UI8,1,I4,-2);
2077     }
2078     VARNOT(R4,1,I4,-2);
2079     VARNOT(R4,0,I4,-1);
2080     VARNOT(R8,1,I4,-2);
2081     VARNOT(R8,0,I4,-1);
2082     VARNOT(DATE,1,I4,-2);
2083     VARNOT(DATE,0,I4,-1);
2084     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
2085     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
2086     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
2087     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
2088
2089     V_VT(&v) = VT_DECIMAL;
2090     S(U(*pdec)).sign = DECIMAL_NEG;
2091     S(U(*pdec)).scale = 0;
2092     pdec->Hi32 = 0;
2093     S1(U1(*pdec)).Mid32 = 0;
2094     S1(U1(*pdec)).Lo32 = 1;
2095     VARNOT(DECIMAL,*pdec,I4,0);
2096
2097     pcy->int64 = 10000;
2098     VARNOT(CY,*pcy,I4,-2);
2099
2100     pcy->int64 = 0;
2101     VARNOT(CY,*pcy,I4,-1);
2102
2103     pcy->int64 = -1;
2104     VARNOT(CY,*pcy,I4,-1);
2105 }
2106
2107 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
2108
2109 #define VARSUB(vt1,val1,vt2,val2,rvt,rval)               \
2110         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2111         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2112         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2113         test_var_call2( __LINE__, pVarSub, &left, &right, &exp )
2114
2115 static void test_VarSub(void)
2116 {
2117     VARIANT left, right, exp, result, cy, dec;
2118     VARTYPE i;
2119     BSTR lbstr, rbstr;
2120     HRESULT hres, expectedhres;
2121     double r;
2122
2123     CHECKPTR(VarSub);
2124
2125     lbstr = SysAllocString(sz12);
2126     rbstr = SysAllocString(sz12);
2127
2128     VariantInit(&left);
2129     VariantInit(&right);
2130     VariantInit(&result);
2131
2132     /* Test all possible flag/vt combinations & the resulting vt type */
2133     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2134     {
2135
2136         VARTYPE leftvt, rightvt, resvt;
2137
2138         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
2139         {
2140
2141             SKIPTESTS(leftvt);
2142
2143             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
2144             {
2145
2146                 SKIPTESTS(rightvt);
2147                 expectedhres = S_OK;
2148
2149                 memset(&left, 0, sizeof(left));
2150                 memset(&right, 0, sizeof(right));
2151                 V_VT(&left) = leftvt | ExtraFlags[i];
2152                 if (leftvt == VT_BSTR)
2153                     V_BSTR(&left) = lbstr;
2154                 V_VT(&right) = rightvt | ExtraFlags[i];
2155                 if (rightvt == VT_BSTR)
2156                     V_BSTR(&right) = rbstr;
2157                 V_VT(&result) = VT_EMPTY;
2158
2159                 /* All extra flags produce errors */
2160                 if (ExtraFlags[i] == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
2161                     ExtraFlags[i] == (VT_VECTOR|VT_RESERVED) ||
2162                     ExtraFlags[i] == (VT_VECTOR|VT_BYREF) ||
2163                     ExtraFlags[i] == (VT_BYREF|VT_RESERVED) ||
2164                     ExtraFlags[i] == VT_VECTOR ||
2165                     ExtraFlags[i] == VT_BYREF ||
2166                     ExtraFlags[i] == VT_RESERVED)
2167                 {
2168                     expectedhres = DISP_E_BADVARTYPE;
2169                     resvt = VT_EMPTY;
2170                 }
2171                 else if (ExtraFlags[i] >= VT_ARRAY)
2172                 {
2173                     expectedhres = DISP_E_TYPEMISMATCH;
2174                     resvt = VT_EMPTY;
2175                 }
2176                 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
2177                    VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
2178                 else if (!IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
2179                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
2180                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
2181                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
2182                     leftvt == VT_I1 || rightvt == VT_I1 ||
2183                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
2184                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
2185                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
2186                     leftvt == VT_INT || rightvt == VT_INT ||
2187                     leftvt == VT_UINT || rightvt == VT_UINT ||
2188                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
2189                     leftvt == VT_RECORD || rightvt == VT_RECORD)
2190                 {
2191                     if (leftvt == VT_RECORD && rightvt == VT_I8)
2192                     {
2193                         if (HAVE_OLEAUT32_I8)
2194                             expectedhres = DISP_E_TYPEMISMATCH;
2195                         else
2196                             expectedhres = DISP_E_BADVARTYPE;
2197                     }
2198                     else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
2199                         expectedhres = DISP_E_TYPEMISMATCH;
2200                     else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
2201                         expectedhres = DISP_E_TYPEMISMATCH;
2202                     else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
2203                         expectedhres = DISP_E_TYPEMISMATCH;
2204                     else if (leftvt == VT_RECORD && rightvt > VT_UI1)
2205                         expectedhres = DISP_E_BADVARTYPE;
2206                     else
2207                         expectedhres = DISP_E_BADVARTYPE;
2208                     resvt = VT_EMPTY;
2209                 }
2210                 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
2211                     (leftvt == VT_DISPATCH && rightvt == VT_NULL))
2212                     resvt = VT_NULL;
2213                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
2214                     leftvt == VT_ERROR || rightvt == VT_ERROR)
2215                 {
2216                     resvt = VT_EMPTY;
2217                     expectedhres = DISP_E_TYPEMISMATCH;
2218                 }
2219                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
2220                     resvt = VT_NULL;
2221                 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
2222                     (leftvt == VT_DATE && rightvt == VT_DATE) ||
2223                     (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
2224                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
2225                     resvt = VT_R8;
2226                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
2227                     resvt = VT_DECIMAL;
2228                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
2229                     resvt = VT_DATE;
2230                 else if (leftvt == VT_CY || rightvt == VT_CY)
2231                     resvt = VT_CY;
2232                 else if (leftvt == VT_R8 || rightvt == VT_R8)
2233                     resvt = VT_R8;
2234                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
2235                     resvt = VT_R8;
2236                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
2237                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
2238                         leftvt == VT_I8 || rightvt == VT_I8)
2239                         resvt = VT_R8;
2240                     else
2241                         resvt = VT_R4;
2242                 }
2243                 else if (leftvt == VT_I8 || rightvt == VT_I8)
2244                     resvt = VT_I8;
2245                 else if (leftvt == VT_I4 || rightvt == VT_I4)
2246                     resvt = VT_I4;
2247                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
2248                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
2249                     (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
2250                     resvt = VT_I2;
2251                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
2252                     resvt = VT_UI1;
2253                 else
2254                 {
2255                     resvt = VT_EMPTY;
2256                     expectedhres = DISP_E_TYPEMISMATCH;
2257                 }
2258
2259                 hres = pVarSub(&left, &right, &result);
2260
2261                 ok(hres == expectedhres && V_VT(&result) == resvt,
2262                     "VarSub: %d|0x%X, %d|0x%X: Expected failure 0x%X, "
2263                     "got 0x%X, expected vt %d got vt %d\n",
2264                     leftvt, ExtraFlags[i], rightvt, ExtraFlags[i],
2265                     expectedhres, hres, resvt, V_VT(&result));
2266             }
2267         }
2268     }
2269
2270     /* Test returned values */
2271     VARSUB(I4,4,I4,2,I4,2);
2272     VARSUB(I2,4,I2,2,I2,2);
2273     VARSUB(I2,-13,I4,5,I4,-18);
2274     VARSUB(I4,-13,I4,5,I4,-18);
2275     VARSUB(I2,7,R4,0.5f,R4,6.5f);
2276     VARSUB(R4,0.5f,I4,5,R8,-4.5);
2277     VARSUB(R8,7.1,BOOL,0,R8,7.1);
2278     VARSUB(BSTR,lbstr,I2,4,R8,8);
2279     VARSUB(BSTR,lbstr,BOOL,1,R8,11);
2280     VARSUB(BSTR,lbstr,R4,0.1f,R8,11.9);
2281     VARSUB(R4,0.2f,BSTR,rbstr,R8,-11.8);
2282     VARSUB(DATE,2.25,I4,7,DATE,-4.75);
2283     VARSUB(DATE,1.25,R4,-1.7f,DATE,2.95);
2284
2285     VARSUB(UI1, UI1_MAX, UI1, UI1_MAX, UI1, 0);
2286     VARSUB(I2, I2_MAX, I2, I2_MAX, I2, 0);
2287     VARSUB(I2, I2_MIN, I2, I2_MIN, I2, 0);
2288     VARSUB(I4, I4_MAX, I4, I4_MAX, I4, 0);
2289     VARSUB(I4, I4_MIN, I4, I4_MIN, I4, 0);
2290     VARSUB(R4, R4_MAX, R4, R4_MAX, R4, 0.0f);
2291     VARSUB(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX - R4_MIN);
2292     VARSUB(R4, R4_MIN, R4, R4_MIN, R4, 0.0f);
2293     VARSUB(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX - R8_MIN);
2294     VARSUB(R8, R8_MIN, R8, R8_MIN, R8, 0.0);
2295
2296     /* Manually test BSTR + BSTR */
2297     V_VT(&left) = VT_BSTR;
2298     V_BSTR(&left) = lbstr;
2299     V_VT(&right) = VT_BSTR;
2300     V_BSTR(&right) = rbstr;
2301     hres = VarSub(&left, &right, &result);
2302     ok(hres == S_OK && V_VT(&result) == VT_R8,
2303         "VarSub: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
2304     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0),
2305         "VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
2306
2307     /* Manually test some VT_CY and VT_DECIMAL variants */
2308     V_VT(&cy) = VT_CY;
2309     hres = VarCyFromI4(4711, &V_CY(&cy));
2310     ok(hres == S_OK, "VarCyFromI4 failed!\n");
2311     V_VT(&dec) = VT_DECIMAL;
2312     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
2313     ok(hres == S_OK, "VarDecFromR4 failed!\n");
2314     memset(&left, 0, sizeof(left));
2315     memset(&right, 0, sizeof(right));
2316     V_VT(&left) = VT_I4;
2317     V_I4(&left) = -11;
2318     V_VT(&right) = VT_UI1;
2319     V_UI1(&right) = 9;
2320
2321     hres = VarSub(&cy, &right, &result);
2322     ok(hres == S_OK && V_VT(&result) == VT_CY,
2323         "VarSub: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
2324     hres = VarR8FromCy(V_CY(&result), &r);
2325     ok(hres == S_OK && EQ_DOUBLE(r, 4702),
2326         "VarSub: CY value %f, expected %f\n", r, (double)4720);
2327
2328     hres = VarSub(&left, &dec, &result);
2329     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
2330         "VarSub: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
2331     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
2332     ok(hres == S_OK && EQ_DOUBLE(r, -6.8),
2333         "VarSub: DECIMAL value %f, expected %f\n", r, (double)-15.2);
2334
2335     SysFreeString(lbstr);
2336     SysFreeString(rbstr);
2337 }
2338
2339 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2340
2341 static void test_Mod( int line, VARIANT *left, VARIANT *right, VARIANT *expected, HRESULT expres )
2342 {
2343     VARIANT result;
2344     HRESULT hres;
2345
2346     memset( &result, 0, sizeof(result) );
2347     hres = pVarMod( left, right, &result );
2348     ok_(__FILE__,line)( hres == expres, "wrong result %x/%x\n", hres, expres );
2349     if (hres == S_OK)
2350         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
2351                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
2352 }
2353
2354 #define VARMOD(vt1,vt2,val1,val2,rvt,rval)               \
2355         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2356         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2357         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2358         test_var_call2( __LINE__, pVarMod, &left, &right, &exp )
2359
2360 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected)         \
2361         V_VT(&left) = VT_##vt1; V_I4(&left) = val1;           \
2362         V_VT(&right) = VT_##vt2; V_I4(&right) = val2;         \
2363         V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval;             \
2364         test_Mod( __LINE__, &left, &right, &exp, hexpected )
2365
2366 static void test_VarMod(void)
2367 {
2368   VARIANT v1, v2, vDst, left, right, exp;
2369   HRESULT hres;
2370   HRESULT hexpected = 0;
2371   static const WCHAR szNum0[] = {'1','2','5','\0'};
2372   static const WCHAR szNum1[] = {'1','0','\0'};
2373   int l, r;
2374   BOOL lFound, rFound;
2375   BOOL lValid;
2376   BSTR strNum0, strNum1;
2377
2378   CHECKPTR(VarMod);
2379
2380   VARMOD(I1,BOOL,100,10,I4,0);
2381   VARMOD(I1,I1,100,10,I4,0);
2382   VARMOD(I1,UI1,100,10,I4,0);
2383   VARMOD(I1,I2,100,10,I4,0);
2384   VARMOD(I1,UI2,100,10,I4,0);
2385   VARMOD(I1,I4,100,10,I4,0);
2386   VARMOD(I1,UI4,100,10,I4,0);
2387   VARMOD(I1,R4,100,10,I4,0);
2388   VARMOD(I1,R8,100,10,I4,0);
2389
2390   VARMOD(UI1,BOOL,100,10,I2,0);
2391   VARMOD(UI1,I1,100,10,I4,0);
2392   VARMOD(UI1,UI1,100,10,UI1,0);
2393   VARMOD(UI1,I2,100,10,I2,0);
2394   VARMOD(UI1,UI2,100,10,I4,0);
2395   VARMOD(UI1,I4,100,10,I4,0);
2396   VARMOD(UI1,UI4,100,10,I4,0);
2397   VARMOD(UI1,R4,100,10,I4,0);
2398   VARMOD(UI1,R8,100,10,I4,0);
2399
2400   VARMOD(I2,BOOL,100,10,I2,0);
2401   VARMOD(I2,I1,100,10,I4,0);
2402   VARMOD(I2,UI1,100,10,I2,0);
2403   VARMOD(I2,I2,100,10,I2,0);
2404   VARMOD(I2,UI2,100,10,I4,0);
2405   VARMOD(I2,I4,100,10,I4,0);
2406   VARMOD(I2,UI4,100,10,I4,0);
2407   VARMOD(I2,R4,100,10,I4,0);
2408   VARMOD(I2,R8,100,10,I4,0);
2409
2410   VARMOD(I4,BOOL,100,10,I4,0);
2411   VARMOD(I4,I1,100,10,I4,0);
2412   VARMOD(I4,UI1,100,10,I4,0);
2413   VARMOD(I4,I2,100,10,I4,0);
2414   VARMOD(I4,UI2,100,10,I4,0);
2415   VARMOD(I4,I4,100,10,I4,0);
2416   VARMOD(I4,UI4,100,10,I4,0);
2417   VARMOD(I4,R4,100,10,I4,0);
2418   VARMOD(I4,R8,100,10,I4,0);
2419   VARMOD(UI4,BOOL,100,10,I4,0);
2420   VARMOD(UI4,I1,100,10,I4,0);
2421   VARMOD(UI4,UI1,100,10,I4,0);
2422   VARMOD(UI4,I2,100,10,I4,0);
2423   VARMOD(UI4,UI2,100,10,I4,0);
2424   VARMOD(UI4,I4,100,10,I4,0);
2425   VARMOD(UI4,UI4,100,10,I4,0);
2426   VARMOD(UI4,R4,100,10,I4,0);
2427   VARMOD(UI4,R8,100,10,I4,0);
2428   VARMOD(R4,BOOL,100,10,I4,0);
2429   VARMOD(R4,I1,100,10,I4,0);
2430   VARMOD(R4,UI1,100,10,I4,0);
2431   VARMOD(R4,I2,100,10,I4,0);
2432   VARMOD(R4,UI2,100,10,I4,0);
2433   VARMOD(R4,I4,100,10,I4,0);
2434   VARMOD(R4,UI4,100,10,I4,0);
2435   VARMOD(R4,R4,100,10,I4,0);
2436   VARMOD(R4,R8,100,10,I4,0);
2437   VARMOD(R8,BOOL,100,10,I4,0);
2438   VARMOD(R8,I1,100,10,I4,0);
2439   VARMOD(R8,UI1,100,10,I4,0);
2440   VARMOD(R8,I2,100,10,I4,0);
2441   VARMOD(R8,UI2,100,10,I4,0);
2442   VARMOD(R8,I4,100,10,I4,0);
2443   VARMOD(R8,UI4,100,10,I4,0);
2444   VARMOD(R8,R4,100,10,I4,0);
2445   VARMOD(R8,R8,100,10,I4,0);
2446
2447   VARMOD(INT,INT,100,10,I4,0);
2448   VARMOD(INT,UINT,100,10,I4,0);
2449
2450   VARMOD(BOOL,BOOL,100,10,I2,0);
2451   VARMOD(BOOL,I1,100,10,I4,0);
2452   VARMOD(BOOL,UI1,100,10,I2,0);
2453   VARMOD(BOOL,I2,100,10,I2,0);
2454   VARMOD(BOOL,UI2,100,10,I4,0);
2455   VARMOD(BOOL,I4,100,10,I4,0);
2456   VARMOD(BOOL,UI4,100,10,I4,0);
2457   VARMOD(BOOL,R4,100,10,I4,0);
2458   VARMOD(BOOL,R8,100,10,I4,0);
2459   VARMOD(BOOL,DATE,100,10,I4,0);
2460
2461   VARMOD(DATE,BOOL,100,10,I4,0);
2462   VARMOD(DATE,I1,100,10,I4,0);
2463   VARMOD(DATE,UI1,100,10,I4,0);
2464   VARMOD(DATE,I2,100,10,I4,0);
2465   VARMOD(DATE,UI2,100,10,I4,0);
2466   VARMOD(DATE,I4,100,10,I4,0);
2467   VARMOD(DATE,UI4,100,10,I4,0);
2468   VARMOD(DATE,R4,100,10,I4,0);
2469   VARMOD(DATE,R8,100,10,I4,0);
2470   VARMOD(DATE,DATE,100,10,I4,0);
2471
2472   strNum0 = SysAllocString(szNum0);
2473   strNum1 = SysAllocString(szNum1);
2474   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5);
2475   VARMOD(BSTR,I1,strNum0,10,I4,5);
2476   VARMOD(BSTR,I2,strNum0,10,I4,5);
2477   VARMOD(BSTR,I4,strNum0,10,I4,5);
2478   VARMOD(BSTR,R4,strNum0,10,I4,5);
2479   VARMOD(BSTR,R8,strNum0,10,I4,5);
2480   VARMOD(I4,BSTR,125,strNum1,I4,5);
2481
2482   if (HAVE_OLEAUT32_I8)
2483   {
2484     VARMOD(BOOL,I8,100,10,I8,0);
2485     VARMOD(I1,I8,100,10,I8,0);
2486     VARMOD(UI1,I8,100,10,I8,0);
2487     VARMOD(I2,I8,100,10,I8,0);
2488     VARMOD(I4,I8,100,10,I8,0);
2489     VARMOD(UI4,I8,100,10,I8,0);
2490     VARMOD(R4,I8,100,10,I8,0);
2491     VARMOD(R8,I8,100,10,I8,0);
2492     VARMOD(DATE,I8,100,10,I8,0);
2493
2494     VARMOD(I8,BOOL,100,10,I8,0);
2495     VARMOD(I8,I1,100,10,I8,0);
2496     VARMOD(I8,UI1,100,10,I8,0);
2497     VARMOD(I8,I2,100,10,I8,0);
2498     VARMOD(I8,UI2,100,10,I8,0);
2499     VARMOD(I8,I4,100,10,I8,0);
2500     VARMOD(I8,UI4,100,10,I8,0);
2501     VARMOD(I8,R4,100,10,I8,0);
2502     VARMOD(I8,R8,100,10,I8,0);
2503     VARMOD(I8,I8,100,10,I8,0);
2504
2505     VARMOD(BSTR,I8,strNum0,10,I8,5);
2506   }
2507
2508   /* test all combinations of types */
2509   for(l = 0; l < VT_BSTR_BLOB; l++)
2510   {
2511     SKIPTESTS(l);
2512
2513     for(r = 0; r < VT_BSTR_BLOB; r++)
2514     {
2515       SKIPTESTS(r);
2516
2517       if(l == VT_BSTR) continue;
2518       if(l == VT_DISPATCH) continue;
2519       if(r == VT_BSTR) continue;
2520       if(r == VT_DISPATCH) continue;
2521
2522       lFound = TRUE;
2523       lValid = TRUE;
2524       switch(l)
2525         {
2526         case VT_EMPTY:
2527         case VT_NULL:
2528         case VT_I1:
2529         case VT_UI1:
2530         case VT_I2:
2531         case VT_UI2:
2532         case VT_I4:
2533         case VT_I8:
2534         case VT_UI4:
2535         case VT_UI8:
2536         case VT_INT:
2537         case VT_UINT:
2538         case VT_R4:
2539         case VT_R8:
2540         case VT_BOOL:
2541         case VT_DATE:
2542         case VT_CY:
2543         case VT_DECIMAL:
2544           hexpected = S_OK;
2545           break;
2546         case VT_ERROR:
2547         case VT_VARIANT:
2548         case VT_UNKNOWN:
2549         case VT_RECORD:
2550           lValid = FALSE;
2551           break;
2552         default:
2553           lFound = FALSE;
2554           hexpected = DISP_E_BADVARTYPE;
2555           break;
2556         }
2557
2558       rFound = TRUE;
2559       switch(r)
2560         {
2561         case VT_EMPTY:
2562         case VT_NULL:
2563         case VT_I1:
2564         case VT_UI1:
2565         case VT_I2:
2566         case VT_UI2:
2567         case VT_I4:
2568         case VT_I8:
2569         case VT_UI4:
2570         case VT_UI8:
2571         case VT_INT:
2572         case VT_UINT:
2573         case VT_R4:
2574         case VT_R8:
2575         case VT_BOOL:
2576         case VT_DATE:
2577         case VT_DECIMAL:
2578         case VT_CY:
2579           hexpected = S_OK;
2580           break;
2581         case VT_ERROR:
2582         case VT_VARIANT:
2583         case VT_UNKNOWN:
2584         case VT_RECORD:
2585           break;
2586         default:
2587           rFound = FALSE;
2588           break;
2589         }
2590
2591       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2592       {
2593         hexpected = DISP_E_TYPEMISMATCH;
2594       } else if((l == VT_EMPTY) && (r == VT_NULL))
2595       {
2596         hexpected = S_OK;
2597       } else if((l == VT_NULL) && (r == VT_EMPTY))
2598       {
2599         hexpected = S_OK;
2600       } else if((l == VT_EMPTY) && (r == VT_CY))
2601       {
2602         hexpected = S_OK;
2603       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2604       {
2605         hexpected = DISP_E_TYPEMISMATCH;
2606       } else if((r == VT_EMPTY) && lFound && lValid)
2607       {
2608         hexpected = DISP_E_DIVBYZERO;
2609       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2610       {
2611         hexpected = DISP_E_TYPEMISMATCH;
2612       } else if((l == VT_NULL) && (r == VT_NULL))
2613       {
2614         hexpected = S_OK;
2615       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2616       {
2617         hexpected = DISP_E_TYPEMISMATCH;
2618       } else if((l == VT_NULL) && (r == VT_RECORD))
2619       {
2620         hexpected = DISP_E_TYPEMISMATCH;
2621       } else if((l == VT_I8) && (r == VT_DECIMAL))
2622       {
2623         hexpected = S_OK;
2624       } else if((l == VT_DECIMAL) && (r == VT_I8))
2625       {
2626         hexpected = S_OK;
2627       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2628       {
2629         hexpected = DISP_E_TYPEMISMATCH;
2630       } else if((l == VT_NULL) && rFound)
2631       {
2632         hexpected = S_OK;
2633       } else if(l == VT_RECORD)
2634       {
2635         hexpected = DISP_E_TYPEMISMATCH;
2636       } else if((r == VT_RECORD) && lValid && lFound)
2637       {
2638         hexpected = DISP_E_TYPEMISMATCH;
2639       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2640       {
2641         hexpected = DISP_E_DIVBYZERO;
2642       } else if((l == VT_CY) && !rFound)
2643       {
2644         hexpected = DISP_E_BADVARTYPE;
2645       } else if(lFound && !rFound)
2646       {
2647         hexpected = DISP_E_BADVARTYPE;
2648       } else if(!lFound && rFound)
2649       {
2650         hexpected = DISP_E_BADVARTYPE;
2651       } else if((r == VT_NULL) && lFound && lValid)
2652       {
2653         hexpected = S_OK;
2654       } else if((l == VT_NULL) || (r == VT_NULL))
2655       {
2656         hexpected = DISP_E_BADVARTYPE;
2657       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2658       {
2659         hexpected = DISP_E_BADVARTYPE;
2660       } else if(lFound && !rFound)
2661       {
2662         hexpected = DISP_E_BADVARTYPE;
2663       } else if(!lFound && !rFound)
2664       {
2665         hexpected = DISP_E_BADVARTYPE;
2666       }
2667
2668       V_VT(&v1) = l;
2669       V_VT(&v2) = r;
2670
2671       if(l == VT_CY)
2672         V_CY(&v1).int64 = 1000000;
2673       else if(l == VT_R4)
2674         V_R4(&v1) = 100;
2675       else if(l == VT_R8)
2676         V_R8(&v1) = 100;
2677       else if(l == VT_UI8)
2678         V_UI8(&v1) = 100;
2679       else if(l == VT_I8)
2680         V_I8(&v1) = 100;
2681       else if(l == VT_DATE)
2682         V_DATE(&v1) = 1000;
2683       else if (l == VT_DECIMAL)
2684       {
2685         V_DECIMAL(&v1).Hi32 = 0;
2686         U1(V_DECIMAL(&v1)).Lo64 = 100;
2687         U(V_DECIMAL(&v1)).signscale = 0;
2688       }
2689       else
2690         V_I4(&v1) = 10000;
2691
2692       if(r == VT_CY)
2693         V_CY(&v2).int64 = 10000;
2694       else if(r == VT_R4)
2695         V_R4(&v2) = 100;
2696       else if(r == VT_R8)
2697         V_R8(&v2) = 100;
2698       else if(r == VT_UI8)
2699         V_UI8(&v2) = 100;
2700       else if(r == VT_I8)
2701         V_I8(&v2) = 100;
2702       else if(r == VT_DATE)
2703         V_DATE(&v2) = 1000;
2704       else if (r == VT_DECIMAL)
2705       {
2706         V_DECIMAL(&v2).Hi32 = 0;
2707         U1(V_DECIMAL(&v2)).Lo64 = 100;
2708         U(V_DECIMAL(&v2)).signscale = 0;
2709       }
2710       else
2711         V_I4(&v2) = 10000;
2712
2713       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2714       {
2715         hres = pVarMod(&v1,&v2,&vDst);
2716         ok(hres == hexpected,
2717            "VarMod: expected 0x%x, got 0x%X for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2718       }
2719     }
2720   }
2721
2722
2723   /****************************/
2724   /* test some bad parameters */
2725   VARMOD(I4,I4,-1,-1,I4,0);
2726
2727   /* test modulus with zero */
2728   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2729
2730   VARMOD(I4,I4,0,10,I4,0); /* test 0 mod 10 */
2731
2732   /* right parameter is type empty */
2733   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2734
2735   /* left parameter is type empty */
2736   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2737
2738   /* mod with a null left value */
2739   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2740
2741   /* mod with a null right value */
2742   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2743
2744   /* void left value */
2745   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2746
2747   /* void right value */
2748   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2749
2750   /* null left value, void right value */
2751   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2752
2753   /* void left value, null right value */
2754   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2755
2756   /* some currencies */
2757   V_VT(&v1) = VT_CY;
2758   V_VT(&v2) = VT_CY;
2759   V_CY(&v1).int64 = 100000;
2760   V_CY(&v2).int64 = 100000;
2761   hres = pVarMod(&v1,&v2,&vDst);
2762   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2763      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2764
2765   V_VT(&v1) = VT_I4;
2766   V_VT(&v2) = VT_CY;
2767   V_I4(&v1) = 100;
2768   V_CY(&v2).int64 = 100000;
2769   hres = pVarMod(&v1,&v2,&vDst);
2770   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2771      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2772
2773   /* some decimals */
2774   V_VT(&v1) = VT_DECIMAL;
2775   V_VT(&v2) = VT_DECIMAL;
2776   VarDecFromI4(100, &V_DECIMAL(&v1));
2777   VarDecFromI4(10, &V_DECIMAL(&v2));
2778   hres = pVarMod(&v1,&v2,&vDst);
2779   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2780      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2781
2782   V_VT(&v1) = VT_I4;
2783   V_VT(&v2) = VT_DECIMAL;
2784   V_I4(&v1) = 100;
2785   VarDecFromI4(10, &V_DECIMAL(&v2));
2786   hres = pVarMod(&v1,&v2,&vDst);
2787   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2788      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2789
2790   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2791
2792   /* test that an error results in the type of the result changing but not its value */
2793   V_VT(&v1) = VT_UNKNOWN;
2794   V_VT(&v2) = VT_EMPTY;
2795   V_I4(&v1) = 100;
2796   V_CY(&v2).int64 = 100000;
2797   V_VT(&vDst) = VT_I4;
2798   V_I4(&vDst) = 1231;
2799   hres = pVarMod(&v1,&v2,&vDst);
2800   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2801      "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));
2802
2803
2804   /* test some invalid types */
2805   /*TODO: not testing VT_DISPATCH */
2806   if (HAVE_OLEAUT32_I8)
2807   {
2808     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2809   }
2810   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2811   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2812   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2813   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2814   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2815   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2816   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2817   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2818   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2819   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2820   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2821   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2822   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2823   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2824   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2825   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2826   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2827   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2828   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2829   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2830   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2831   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2832   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2833   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2834
2835   /* test some more invalid types */
2836   V_VT(&v1) = 456;
2837   V_VT(&v2) = 234;
2838   V_I4(&v1) = 100;
2839   V_I4(&v2)=  10;
2840   hres = pVarMod(&v1,&v2,&vDst);
2841   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY,
2842      "VarMod: expected 0x%x,%d, got 0x%X,%d\n", DISP_E_BADVARTYPE, VT_EMPTY, hres, V_VT(&vDst));
2843
2844   SysFreeString(strNum0);
2845   SysFreeString(strNum1);
2846 }
2847
2848 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2849
2850 #define VARFIX(vt,val,rvt,rval)                  \
2851     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2852     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2853     test_var_call1( __LINE__, pVarFix, &v, &exp )
2854
2855 static void test_VarFix(void)
2856 {
2857     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2858     HRESULT hres;
2859     VARIANT v, exp, vDst;
2860     DECIMAL *pdec = &V_DECIMAL(&v);
2861     CY *pcy = &V_CY(&v);
2862     size_t i;
2863
2864     CHECKPTR(VarFix);
2865
2866     /* Test all possible V_VT values */
2867     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2868     {
2869         VARTYPE vt;
2870
2871         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2872         {
2873             HRESULT bFail = TRUE;
2874
2875             SKIPTESTS(vt);
2876
2877             memset(&v, 0, sizeof(v));
2878             V_VT(&v) = vt | ExtraFlags[i];
2879             V_VT(&vDst) = VT_EMPTY;
2880
2881             switch (V_VT(&v))
2882             {
2883               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2884               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2885               case VT_DATE: case VT_CY:
2886                 bFail = FALSE;
2887                 break;
2888               case VT_I8:
2889                 if (HAVE_OLEAUT32_I8)
2890                   bFail = FALSE;
2891                 break;
2892             }
2893
2894             hres = pVarFix(&v,&vDst);
2895             if (bFail)
2896               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2897                  "VarFix: expected failure, got 0x%X vt %d|0x%X\n",
2898                  hres, vt, ExtraFlags[i]);
2899             else
2900                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%X vt %d|0x%X\n",
2901                     hres, vt, ExtraFlags[i]);
2902         }
2903     }
2904
2905     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2906     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2907     VARFIX(BOOL,1,I2,1);
2908     VARFIX(UI1,1,UI1,1);
2909     VARFIX(I2,-1,I2,-1);
2910     VARFIX(I4,-1,I4,-1);
2911     if (HAVE_OLEAUT32_I8)
2912     {
2913         VARFIX(I8,-1,I8,-1);
2914     }
2915     VARFIX(R4,1.4f,R4,1);
2916     VARFIX(R4,1.5f,R4,1);
2917     VARFIX(R4,1.6f,R4,1);
2918     VARFIX(R4,-1.4f,R4,-1);
2919     VARFIX(R4,-1.5f,R4,-1);
2920     VARFIX(R4,-1.6f,R4,-1);
2921     /* DATE & R8 round as for R4 */
2922     VARFIX(DATE,-1,DATE,-1);
2923     VARFIX(R8,-1,R8,-1);
2924     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2925
2926     V_VT(&v) = VT_EMPTY;
2927     hres = pVarFix(&v,&vDst);
2928     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2929        "VarFix: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
2930        hres, V_VT(&vDst), V_I2(&vDst));
2931
2932     V_VT(&v) = VT_NULL;
2933     hres = pVarFix(&v,&vDst);
2934     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2935        "VarFix: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
2936
2937     V_VT(&v) = VT_DECIMAL;
2938     S(U(*pdec)).sign = DECIMAL_NEG;
2939     S(U(*pdec)).scale = 0;
2940     pdec->Hi32 = 0;
2941     S1(U1(*pdec)).Mid32 = 0;
2942     S1(U1(*pdec)).Lo32 = 1;
2943     hres = pVarFix(&v,&vDst);
2944     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
2945        "VarFix: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
2946        hres, V_VT(&vDst));
2947
2948     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2949
2950     V_VT(&v) = VT_CY;
2951     pcy->int64 = -10000;
2952     hres = pVarFix(&v,&vDst);
2953     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2954        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2955
2956     V_VT(&v) = VT_CY;
2957     pcy->int64 = -16000;
2958     hres = pVarFix(&v,&vDst);
2959     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2960        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2961 }
2962
2963 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2964
2965 #define VARINT(vt,val,rvt,rval)                  \
2966     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2967     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2968     test_var_call1( __LINE__, pVarInt, &v, &exp )
2969
2970 static void test_VarInt(void)
2971 {
2972     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2973     HRESULT hres;
2974     VARIANT v, exp, vDst;
2975     DECIMAL *pdec = &V_DECIMAL(&v);
2976     CY *pcy = &V_CY(&v);
2977     size_t i;
2978
2979     CHECKPTR(VarInt);
2980
2981     /* Test all possible V_VT values */
2982     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2983     {
2984         VARTYPE vt;
2985
2986         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2987         {
2988             HRESULT bFail = TRUE;
2989
2990             SKIPTESTS(vt);
2991
2992             memset(&v, 0, sizeof(v));
2993             V_VT(&v) = vt | ExtraFlags[i];
2994             V_VT(&vDst) = VT_EMPTY;
2995
2996             switch (V_VT(&v))
2997             {
2998               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2999               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3000               case VT_DATE: case VT_CY:
3001                 bFail = FALSE;
3002                 break;
3003               case VT_I8:
3004                 if (HAVE_OLEAUT32_I8)
3005                   bFail = FALSE;
3006                 break;
3007             }
3008
3009             hres = pVarInt(&v,&vDst);
3010             if (bFail)
3011               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3012                  "VarInt: expected failure, got 0x%X vt %d|0x%X\n",
3013                  hres, vt, ExtraFlags[i]);
3014             else
3015                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%X vt %d|0x%X\n",
3016                     hres, vt, ExtraFlags[i]);
3017         }
3018     }
3019
3020     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
3021     VARINT(BOOL,VARIANT_FALSE,I2,0);
3022     VARINT(BOOL,1,I2,1);
3023     VARINT(UI1,1,UI1,1);
3024     VARINT(I2,-1,I2,-1);
3025     VARINT(I4,-1,I4,-1);
3026     if (HAVE_OLEAUT32_I8)
3027     {
3028         VARINT(I8,-1,I8,-1);
3029     }
3030     VARINT(R4,1.4f,R4,1);
3031     VARINT(R4,1.5f,R4,1);
3032     VARINT(R4,1.6f,R4,1);
3033     VARINT(R4,-1.4f,R4,-2); /* Note these 3 are different from VarFix */
3034     VARINT(R4,-1.5f,R4,-2);
3035     VARINT(R4,-1.6f,R4,-2);
3036     /* DATE & R8 round as for R4 */
3037     VARINT(DATE,-1,DATE,-1);
3038     VARINT(R8,-1,R8,-1);
3039     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
3040
3041     V_VT(&v) = VT_EMPTY;
3042     hres = pVarInt(&v,&vDst);
3043     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3044        "VarInt: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3045        hres, V_VT(&vDst), V_I2(&vDst));
3046
3047     V_VT(&v) = VT_NULL;
3048     hres = pVarInt(&v,&vDst);
3049     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3050        "VarInt: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3051
3052     V_VT(&v) = VT_DECIMAL;
3053     S(U(*pdec)).sign = DECIMAL_NEG;
3054     S(U(*pdec)).scale = 0;
3055     pdec->Hi32 = 0;
3056     S1(U1(*pdec)).Mid32 = 0;
3057     S1(U1(*pdec)).Lo32 = 1;
3058     hres = pVarInt(&v,&vDst);
3059     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
3060        "VarInt: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
3061        hres, V_VT(&vDst));
3062
3063     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
3064
3065     V_VT(&v) = VT_CY;
3066     pcy->int64 = -10000;
3067     hres = pVarInt(&v,&vDst);
3068     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
3069        "VarInt: VT_CY wrong, hres=0x%X\n", hres);
3070
3071     V_VT(&v) = VT_CY;
3072     pcy->int64 = -11000;
3073     hres = pVarInt(&v,&vDst);
3074     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
3075        "VarInt: VT_CY wrong, hres=0x%X 0x%x%08x\n",
3076        hres, (DWORD)(V_CY(&vDst).int64 >> 32), (DWORD)V_CY(&vDst).int64);
3077 }
3078
3079 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
3080
3081 #define VARNEG(vt,val,rvt,rval)                  \
3082     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3083     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3084     test_var_call1( __LINE__, pVarNeg, &v, &exp )
3085
3086 static void test_VarNeg(void)
3087 {
3088     static const WCHAR szNumMinus1[] = {'-','1','\0' };
3089     static const WCHAR szNum1[] = {'1','\0' };
3090     HRESULT hres;
3091     VARIANT v, exp, vDst;
3092     DECIMAL *pdec = &V_DECIMAL(&v);
3093     CY *pcy = &V_CY(&v);
3094     size_t i;
3095
3096     CHECKPTR(VarNeg);
3097
3098     /* Test all possible V_VT values. But don't test the exact return values
3099      * except for success/failure, since M$ made a hash of them in the
3100      * native version. This at least ensures (as with all tests here) that
3101      * we will notice if/when new vtypes/flags are added in native.
3102      */
3103     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3104     {
3105         VARTYPE vt;
3106
3107         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3108         {
3109             HRESULT bFail = TRUE;
3110
3111             SKIPTESTS(vt);
3112
3113             memset(&v, 0, sizeof(v));
3114             V_VT(&v) = vt | ExtraFlags[i];
3115             V_VT(&vDst) = VT_EMPTY;
3116
3117             switch (V_VT(&v))
3118             {
3119             case VT_UI1: case VT_I2: case VT_I4:
3120             case VT_R4:  case VT_R8:
3121             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3122             case VT_DATE: case VT_CY:
3123                 bFail = FALSE;
3124                 break;
3125             case VT_I8:
3126                 if (HAVE_OLEAUT32_I8)
3127                     bFail = FALSE;
3128             }
3129
3130             hres = pVarNeg(&v,&vDst);
3131             if (bFail)
3132                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3133                    "VarNeg: expected failure, got 0x%X vt %d|0x%X\n",
3134                    hres, vt, ExtraFlags[i]);
3135             else
3136                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%X vt %d|0x%X\n",
3137                     hres, vt, ExtraFlags[i]);
3138         }
3139     }
3140
3141     VARNEG(BOOL,VARIANT_TRUE,I2,1);
3142     VARNEG(BOOL,VARIANT_FALSE,I2,0);
3143     VARNEG(BOOL,1,I2,-1);
3144     VARNEG(UI1,1,I2,-1);
3145     VARNEG(UI1,254,I2,-254);
3146     VARNEG(I2,-32768,I4,32768);
3147     VARNEG(I2,-1,I2,1);
3148     VARNEG(I2,1,I2,-1);
3149     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
3150     VARNEG(I4,-1,I4,1);
3151     VARNEG(I4,1,I4,-1);
3152     if (HAVE_OLEAUT32_I8)
3153     {
3154         VARNEG(I8,1,I8,-1);
3155         VARNEG(I8,-1,I8,1);
3156     }
3157     VARNEG(R4,1,R4,-1);
3158     VARNEG(R4,-1,R4,1);
3159     VARNEG(DATE,1,DATE,-1);
3160     VARNEG(DATE,-1,DATE,1);
3161     VARNEG(R8,1,R8,-1);
3162     VARNEG(R8,-1,R8,1);
3163     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
3164     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
3165
3166     V_VT(&v) = VT_EMPTY;
3167     hres = pVarNeg(&v,&vDst);
3168     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3169        "VarNeg: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3170        hres, V_VT(&vDst), V_I2(&vDst));
3171
3172     V_VT(&v) = VT_NULL;
3173     hres = pVarNeg(&v,&vDst);
3174     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3175        "VarNeg: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3176
3177     V_VT(&v) = VT_DECIMAL;
3178     S(U(*pdec)).sign = DECIMAL_NEG;
3179     S(U(*pdec)).scale = 0;
3180     pdec->Hi32 = 0;
3181     S1(U1(*pdec)).Mid32 = 0;
3182     S1(U1(*pdec)).Lo32 = 1;
3183     hres = pVarNeg(&v,&vDst);
3184     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3185        S(U(V_DECIMAL(&vDst))).sign == 0,
3186        "VarNeg: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3187        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3188
3189     S(U(*pdec)).sign = 0;
3190     hres = pVarNeg(&v,&vDst);
3191     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3192        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3193        "VarNeg: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3194        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3195
3196     V_VT(&v) = VT_CY;
3197     pcy->int64 = -10000;
3198     hres = pVarNeg(&v,&vDst);
3199     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3200        "VarNeg: VT_CY wrong, hres=0x%X\n", hres);
3201 }
3202
3203 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
3204
3205 static void test_Round( int line, VARIANT *arg, int deci, VARIANT *expected )
3206 {
3207     VARIANT result;
3208     HRESULT hres;
3209
3210     memset( &result, 0, sizeof(result) );
3211     hres = pVarRound( arg, deci, &result );
3212     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
3213     if (hres == S_OK)
3214         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
3215                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
3216 }
3217 #define VARROUND(vt,val,deci,rvt,rval)           \
3218     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3219     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3220     test_Round( __LINE__, &v, deci, &exp )
3221
3222 static void test_VarRound(void)
3223 {
3224     static WCHAR szNumMin[] = {'-','1','.','4','4','9','\0' };
3225     static WCHAR szNum[] = {'1','.','4','5','1','\0' };
3226     HRESULT hres;
3227     VARIANT v, exp, vDst;
3228     CY *pcy = &V_CY(&v);
3229     char buff[8];
3230
3231     CHECKPTR(VarRound);
3232
3233     /* first check valid integer types */
3234     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
3235     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
3236     VARROUND(BOOL,1,0,I2,1);
3237     VARROUND(UI1,1,0,UI1,1);
3238     VARROUND(UI1,254,0,UI1,254);
3239     VARROUND(I2,-32768,0,I2,-32768);
3240     VARROUND(I2,-1,0,I2,-1);
3241     VARROUND(I2,1,0,I2,1);
3242     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
3243     VARROUND(I4,-1,0,I4,-1);
3244     VARROUND(I4,1,0,I4,1);
3245
3246
3247     /* MSDN states that rounding of R4/R8 is dependent on the underlying
3248      * bit pattern of the number and so is architecture dependent. In this
3249      * case Wine returns .2 (which is more correct) and Native returns .3
3250      */
3251
3252     VARROUND(R4,1.0f,0,R4,1.0f);
3253     VARROUND(R4,-1.0f,0,R4,-1.0f);
3254     VARROUND(R8,1.0,0,R8,1.0);
3255     VARROUND(R8,-1.0,0,R8,-1.0);
3256
3257     /* floating point numbers aren't exactly equal and we can't just
3258      * compare the first few digits. */
3259     VARROUND(DATE,1.451,1,DATE,1.5);
3260     VARROUND(DATE,-1.449,1,DATE,-1.4);
3261
3262     /* replace the decimal separator */
3263     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
3264     if (!buff[1]) {
3265         szNumMin[2] = buff[0];
3266         szNum[1] = buff[0];
3267         VARROUND(BSTR,(BSTR)szNumMin,1,R8,-1.40);
3268         VARROUND(BSTR,(BSTR)szNum,1,R8,1.50);
3269     } else {
3270         skip("Skipping VarRound(BSTR) as decimal separator is '%s'\n", buff);
3271     }
3272
3273     VARROUND(R4,1.23456f,0,R4,1.0f);
3274     VARROUND(R4,1.23456f,1,R4,1.2f);
3275     VARROUND(R4,1.23456f,2,R4,1.23f);
3276     VARROUND(R4,1.23456f,3,R4,1.235f);
3277     VARROUND(R4,1.23456f,4,R4,1.2346f);
3278     VARROUND(R4,-1.23456f,0,R4,-1.0f);
3279     VARROUND(R4,-1.23456f,1,R4,-1.2f);
3280     VARROUND(R4,-1.23456f,2,R4,-1.23f);
3281     VARROUND(R4,-1.23456f,3,R4,-1.235f);
3282     VARROUND(R4,-1.23456f,4,R4,-1.2346f);
3283
3284     VARROUND(R8,1.23456,0,R8,1.0);
3285     VARROUND(R8,1.23456,1,R8,1.2);
3286     VARROUND(R8,1.23456,2,R8,1.23);
3287     VARROUND(R8,1.23456,3,R8,1.235);
3288     VARROUND(R8,1.23456,4,R8,1.2346);
3289     VARROUND(R8,-1.23456,0,R8,-1.0);
3290     VARROUND(R8,-1.23456,1,R8,-1.2);
3291     VARROUND(R8,-1.23456,2,R8,-1.23);
3292     VARROUND(R8,-1.23456,3,R8,-1.235);
3293     VARROUND(R8,-1.23456,4,R8,-1.2346);
3294
3295     V_VT(&v) = VT_EMPTY;
3296     hres = pVarRound(&v,0,&vDst);
3297     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3298         "VarRound: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3299         hres, V_VT(&vDst), V_I2(&vDst));
3300
3301     V_VT(&v) = VT_NULL;
3302     hres = pVarRound(&v,0,&vDst);
3303     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3304         "VarRound: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3305
3306     /* not yet implemented so no use testing yet
3307     todo_wine {
3308         DECIMAL *pdec = &V_DECIMAL(&v);
3309         V_VT(&v) = VT_DECIMAL;
3310         S(U(*pdec)).sign = DECIMAL_NEG;
3311         S(U(*pdec)).scale = 0;
3312         pdec->Hi32 = 0;
3313         S1(U1(*pdec)).Mid32 = 0;
3314         S1(U1(*pdec)).Lo32 = 1;
3315         hres = pVarRound(&v,0,&vDst);
3316         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3317             S(U(V_DECIMAL(&vDst))).sign == 0,
3318             "VarRound: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3319             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3320
3321         S(U(*pdec)).sign = 0;
3322         hres = pVarRound(&v,0,&vDst);
3323         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3324             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3325             "VarRound: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3326             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3327     }
3328     */
3329
3330     V_VT(&v) = VT_CY;
3331     pcy->int64 = 10000;
3332     hres = pVarRound(&v,0,&vDst);
3333     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3334         "VarRound: VT_CY wrong, hres=0x%X\n", hres);
3335
3336 }
3337
3338 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
3339
3340 #define VARXOR(vt1,val1,vt2,val2,rvt,rval)               \
3341         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3342         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3343         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3344         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3345
3346 #define VARXORCY(vt1,val1,val2,rvt,rval)                 \
3347         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3348         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3349         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3350         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3351
3352 static void test_VarXor(void)
3353 {
3354     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3355     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3356     VARIANT left, right, exp, result;
3357     BSTR lbstr, rbstr;
3358     VARTYPE i;
3359     HRESULT hres;
3360
3361     CHECKPTR(VarXor);
3362
3363     /* Test all possible flag/vt combinations & the resulting vt type */
3364     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3365     {
3366         VARTYPE leftvt, rightvt, resvt;
3367
3368         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3369         {
3370
3371             SKIPTESTS(leftvt);
3372
3373             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3374             {
3375                 BOOL bFail = FALSE;
3376
3377                 SKIPTESTS(rightvt);
3378
3379                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3380                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3381                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3382                     continue;
3383
3384                 memset(&left, 0, sizeof(left));
3385                 memset(&right, 0, sizeof(right));
3386                 V_VT(&left) = leftvt | ExtraFlags[i];
3387                 V_VT(&right) = rightvt | ExtraFlags[i];
3388                 V_VT(&result) = VT_EMPTY;
3389                 resvt = VT_I4;
3390
3391                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3392                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3393                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3394                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3395                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3396                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3397                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3398                 {
3399                     bFail = TRUE;
3400                 }
3401                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3402                 {
3403                     if (leftvt == rightvt ||
3404                         leftvt == VT_I2 || rightvt == VT_I2 ||
3405                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3406                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3407                         resvt = VT_I2;
3408                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3409                         resvt = VT_NULL;
3410                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3411                         resvt = VT_I8;
3412                 }
3413                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3414                 {
3415                     resvt = VT_NULL;
3416                 }
3417                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3418                 {
3419                     if (leftvt == rightvt)
3420                         resvt = VT_UI1;
3421                     else if (leftvt == rightvt ||
3422                         leftvt == VT_I2 || rightvt == VT_I2 ||
3423                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3424                     {
3425                         resvt = VT_I2;
3426                     }
3427                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3428                         resvt = VT_I8;
3429                 }
3430                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3431                 {
3432                     if (leftvt == rightvt ||
3433                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3434                         resvt = VT_I2;
3435                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3436                         resvt = VT_I8;
3437                 }
3438                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3439                 {
3440                     resvt = VT_BOOL;
3441                 }
3442                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3443                 {
3444                     if (leftvt == VT_INT || rightvt == VT_INT)
3445                         bFail = TRUE;
3446                     else
3447                         resvt = VT_I8;
3448                 }
3449                 hres = pVarXor(&left, &right, &result);
3450                 if (bFail)
3451                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3452                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
3453                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3454                        V_VT(&result));
3455                 else
3456                     ok(hres == S_OK && V_VT(&result) == resvt,
3457                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
3458                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3459                        V_VT(&result));
3460             }
3461         }
3462     }
3463
3464     /* Test returned values
3465      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3466      */
3467     VARXOR(EMPTY,0,EMPTY,0,I2,0);
3468     VARXOR(EMPTY,1,EMPTY,0,I2,0);
3469     VARXOR(EMPTY,0,NULL,0,NULL,0);
3470     VARXOR(EMPTY,0,I1,0,I4,0);
3471     VARXOR(EMPTY,0,I1,1,I4,1);
3472     VARXOR(EMPTY,0,UI1,0,I2,0);
3473     VARXOR(EMPTY,0,UI1,1,I2,1);
3474     VARXOR(EMPTY,0,I2,0,I2,0);
3475     VARXOR(EMPTY,0,I2,1,I2,1);
3476     VARXOR(EMPTY,0,UI2,0,I4,0);
3477     VARXOR(EMPTY,0,UI2,1,I4,1);
3478     VARXOR(EMPTY,0,I4,0,I4,0);
3479     VARXOR(EMPTY,0,I4,1,I4,1);
3480     VARXOR(EMPTY,0,UI4,0,I4,0);
3481     VARXOR(EMPTY,0,UI4,1,I4,1);
3482     if (HAVE_OLEAUT32_I8)
3483     {
3484         VARXOR(EMPTY,0,I8,0,I8,0);
3485         VARXOR(EMPTY,0,I8,1,I8,1);
3486         VARXOR(EMPTY,0,UI8,0,I4,0);
3487         VARXOR(EMPTY,0,UI8,1,I4,1);
3488     }
3489     VARXOR(EMPTY,0,INT,0,I4,0);
3490     VARXOR(EMPTY,0,INT,1,I4,1);
3491     VARXOR(EMPTY,0,UINT,0,I4,0);
3492     VARXOR(EMPTY,0,UINT,1,I4,1);
3493     VARXOR(EMPTY,0,BOOL,0,I2,0);
3494     VARXOR(EMPTY,0,BOOL,1,I2,1);
3495     VARXOR(EMPTY,0,R4,0,I4,0);
3496     VARXOR(EMPTY,0,R4,1,I4,1);
3497     VARXOR(EMPTY,0,R8,0,I4,0);
3498     VARXOR(EMPTY,0,R8,1,I4,1);
3499     rbstr = SysAllocString(szFalse);
3500     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3501     SysFreeString(rbstr);
3502     rbstr = SysAllocString(szTrue);
3503     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3504     VARXORCY(EMPTY,0,10000,I4,1);
3505     SysFreeString(rbstr);
3506
3507     /* NULL OR 0 = NULL. NULL OR n = n */
3508     VARXOR(NULL,0,NULL,0,NULL,0);
3509     VARXOR(NULL,1,NULL,0,NULL,0);
3510     VARXOR(NULL,0,I1,0,NULL,0);
3511     VARXOR(NULL,0,I1,1,NULL,0);
3512     VARXOR(NULL,0,UI1,0,NULL,0);
3513     VARXOR(NULL,0,UI1,1,NULL,0);
3514     VARXOR(NULL,0,I2,0,NULL,0);
3515     VARXOR(NULL,0,I2,1,NULL,0);
3516     VARXOR(NULL,0,UI2,0,NULL,0);
3517     VARXOR(NULL,0,UI2,1,NULL,0);
3518     VARXOR(NULL,0,I4,0,NULL,0);
3519     VARXOR(NULL,0,I4,1,NULL,0);
3520     VARXOR(NULL,0,UI4,0,NULL,0);
3521     VARXOR(NULL,0,UI4,1,NULL,0);
3522     if (HAVE_OLEAUT32_I8)
3523     {
3524         VARXOR(NULL,0,I8,0,NULL,0);
3525         VARXOR(NULL,0,I8,1,NULL,0);
3526         VARXOR(NULL,0,UI8,0,NULL,0);
3527         VARXOR(NULL,0,UI8,1,NULL,0);
3528     }
3529     VARXOR(NULL,0,INT,0,NULL,0);
3530     VARXOR(NULL,0,INT,1,NULL,0);
3531     VARXOR(NULL,0,UINT,0,NULL,0);
3532     VARXOR(NULL,0,UINT,1,NULL,0);
3533     VARXOR(NULL,0,BOOL,0,NULL,0);
3534     VARXOR(NULL,0,BOOL,1,NULL,0);
3535     VARXOR(NULL,0,R4,0,NULL,0);
3536     VARXOR(NULL,0,R4,1,NULL,0);
3537     VARXOR(NULL,0,R8,0,NULL,0);
3538     VARXOR(NULL,0,R8,1,NULL,0);
3539     rbstr = SysAllocString(szFalse);
3540     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3541     SysFreeString(rbstr);
3542     rbstr = SysAllocString(szTrue);
3543     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3544     SysFreeString(rbstr);
3545     VARXORCY(NULL,0,10000,NULL,0);
3546     VARXORCY(NULL,0,0,NULL,0);
3547
3548     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3549     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3550     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3551     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3552     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3553     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3554     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3555     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3556     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3557     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3558     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3559     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3560     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3561     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3562     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3563     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3564     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3565     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3566     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3567     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3568     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3569     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3570     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3571     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3572     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3573     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3574     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3575     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3576     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3577     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3578     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3579     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3580     if (HAVE_OLEAUT32_I8)
3581     {
3582         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3583         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3584         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3585         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3586          * to I4 is performed.
3587          */
3588         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3589         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3590         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3591     }
3592     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3593     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3594     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3595     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3596     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3597     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3598     rbstr = SysAllocString(szFalse);
3599     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3600     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3601     SysFreeString(rbstr);
3602     rbstr = SysAllocString(szTrue);
3603     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3604     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3605     SysFreeString(rbstr);
3606     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3607     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3608     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3609
3610     VARXOR(I1,-1,I1,-1,I4,0);
3611     VARXOR(I1,-1,I1,0,I4,-1);
3612     VARXOR(I1,0,I1,0,I4,0);
3613     VARXOR(I1,-1,UI1,255,I4,-256);
3614     VARXOR(I1,-1,UI1,0,I4,-1);
3615     VARXOR(I1,0,UI1,0,I4,0);
3616     VARXOR(I1,-1,I2,-1,I4,0);
3617     VARXOR(I1,-1,I2,0,I4,-1);
3618     VARXOR(I1,0,I2,0,I4,0);
3619     VARXOR(I1,-1,UI2,65535,I4,-65536);
3620     VARXOR(I1,-1,UI2,0,I4,-1);
3621     VARXOR(I1,0,UI2,0,I4,0);
3622     VARXOR(I1,-1,I4,-1,I4,0);
3623     VARXOR(I1,-1,I4,0,I4,-1);
3624     VARXOR(I1,0,I4,0,I4,0);
3625     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3626     VARXOR(I1,-1,UI4,0,I4,-1);
3627     VARXOR(I1,0,UI4,0,I4,0);
3628     VARXOR(I1,-1,R4,-1,I4,0);
3629     VARXOR(I1,-1,R4,0,I4,-1);
3630     VARXOR(I1,0,R4,0,I4,0);
3631     VARXOR(I1,-1,R8,-1,I4,0);
3632     VARXOR(I1,-1,R8,0,I4,-1);
3633     VARXOR(I1,0,R8,0,I4,0);
3634     VARXOR(I1,-1,DATE,-1,I4,0);
3635     VARXOR(I1,-1,DATE,0,I4,-1);
3636     VARXOR(I1,0,DATE,0,I4,0);
3637     if (HAVE_OLEAUT32_I8)
3638     {
3639         VARXOR(I1,-1,I8,-1,I8,0);
3640         VARXOR(I1,-1,I8,0,I8,-1);
3641         VARXOR(I1,0,I8,0,I8,0);
3642         VARXOR(I1,-1,UI8,0,I4,-1);
3643         VARXOR(I1,0,UI8,0,I4,0);
3644     }
3645     VARXOR(I1,-1,INT,-1,I4,0);
3646     VARXOR(I1,-1,INT,0,I4,-1);
3647     VARXOR(I1,0,INT,0,I4,0);
3648     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3649     VARXOR(I1,-1,UINT,0,I4,-1);
3650     VARXOR(I1,0,UINT,0,I4,0);
3651     rbstr = SysAllocString(szFalse);
3652     VARXOR(I1,0,BSTR,rbstr,I4,0);
3653     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3654     SysFreeString(rbstr);
3655     rbstr = SysAllocString(szTrue);
3656     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3657     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3658     SysFreeString(rbstr);
3659     VARXORCY(I1,-1,10000,I4,-2);
3660     VARXORCY(I1,-1,0,I4,-1);
3661     VARXORCY(I1,0,0,I4,0);
3662
3663     VARXOR(UI1,255,UI1,255,UI1,0);
3664     VARXOR(UI1,255,UI1,0,UI1,255);
3665     VARXOR(UI1,0,UI1,0,UI1,0);
3666     VARXOR(UI1,255,I2,-1,I2,-256);
3667     VARXOR(UI1,255,I2,0,I2,255);
3668     VARXOR(UI1,0,I2,0,I2,0);
3669     VARXOR(UI1,255,UI2,65535,I4,65280);
3670     VARXOR(UI1,255,UI2,0,I4,255);
3671     VARXOR(UI1,0,UI2,0,I4,0);
3672     VARXOR(UI1,255,I4,-1,I4,-256);
3673     VARXOR(UI1,255,I4,0,I4,255);
3674     VARXOR(UI1,0,I4,0,I4,0);
3675     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3676     VARXOR(UI1,255,UI4,0,I4,255);
3677     VARXOR(UI1,0,UI4,0,I4,0);
3678     VARXOR(UI1,255,R4,-1,I4,-256);
3679     VARXOR(UI1,255,R4,0,I4,255);
3680     VARXOR(UI1,0,R4,0,I4,0);
3681     VARXOR(UI1,255,R8,-1,I4,-256);
3682     VARXOR(UI1,255,R8,0,I4,255);
3683     VARXOR(UI1,0,R8,0,I4,0);
3684     VARXOR(UI1,255,DATE,-1,I4,-256);
3685     VARXOR(UI1,255,DATE,0,I4,255);
3686     VARXOR(UI1,0,DATE,0,I4,0);
3687     if (HAVE_OLEAUT32_I8)
3688     {
3689         VARXOR(UI1,255,I8,-1,I8,-256);
3690         VARXOR(UI1,255,I8,0,I8,255);
3691         VARXOR(UI1,0,I8,0,I8,0);
3692         VARXOR(UI1,255,UI8,0,I4,255);
3693         VARXOR(UI1,0,UI8,0,I4,0);
3694     }
3695     VARXOR(UI1,255,INT,-1,I4,-256);
3696     VARXOR(UI1,255,INT,0,I4,255);
3697     VARXOR(UI1,0,INT,0,I4,0);
3698     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3699     VARXOR(UI1,255,UINT,0,I4,255);
3700     VARXOR(UI1,0,UINT,0,I4,0);
3701     rbstr = SysAllocString(szFalse);
3702     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3703     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3704     SysFreeString(rbstr);
3705     rbstr = SysAllocString(szTrue);
3706     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3707     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3708     SysFreeString(rbstr);
3709     VARXORCY(UI1,255,10000,I4,254);
3710     VARXORCY(UI1,255,0,I4,255);
3711     VARXORCY(UI1,0,0,I4,0);
3712
3713     VARXOR(I2,-1,I2,-1,I2,0);
3714     VARXOR(I2,-1,I2,0,I2,-1);
3715     VARXOR(I2,0,I2,0,I2,0);
3716     VARXOR(I2,-1,UI2,65535,I4,-65536);
3717     VARXOR(I2,-1,UI2,0,I4,-1);
3718     VARXOR(I2,0,UI2,0,I4,0);
3719     VARXOR(I2,-1,I4,-1,I4,0);
3720     VARXOR(I2,-1,I4,0,I4,-1);
3721     VARXOR(I2,0,I4,0,I4,0);
3722     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3723     VARXOR(I2,-1,UI4,0,I4,-1);
3724     VARXOR(I2,0,UI4,0,I4,0);
3725     VARXOR(I2,-1,R4,-1,I4,0);
3726     VARXOR(I2,-1,R4,0,I4,-1);
3727     VARXOR(I2,0,R4,0,I4,0);
3728     VARXOR(I2,-1,R8,-1,I4,0);
3729     VARXOR(I2,-1,R8,0,I4,-1);
3730     VARXOR(I2,0,R8,0,I4,0);
3731     VARXOR(I2,-1,DATE,-1,I4,0);
3732     VARXOR(I2,-1,DATE,0,I4,-1);
3733     VARXOR(I2,0,DATE,0,I4,0);
3734     if (HAVE_OLEAUT32_I8)
3735     {
3736         VARXOR(I2,-1,I8,-1,I8,0);
3737         VARXOR(I2,-1,I8,0,I8,-1);
3738         VARXOR(I2,0,I8,0,I8,0);
3739         VARXOR(I2,-1,UI8,0,I4,-1);
3740         VARXOR(I2,0,UI8,0,I4,0);
3741     }
3742     VARXOR(I2,-1,INT,-1,I4,0);
3743     VARXOR(I2,-1,INT,0,I4,-1);
3744     VARXOR(I2,0,INT,0,I4,0);
3745     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3746     VARXOR(I2,-1,UINT,0,I4,-1);
3747     VARXOR(I2,0,UINT,0,I4,0);
3748     rbstr = SysAllocString(szFalse);
3749     VARXOR(I2,0,BSTR,rbstr,I2,0);
3750     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3751     SysFreeString(rbstr);
3752     rbstr = SysAllocString(szTrue);
3753     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3754     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3755     SysFreeString(rbstr);
3756     VARXORCY(I2,-1,10000,I4,-2);
3757     VARXORCY(I2,-1,0,I4,-1);
3758     VARXORCY(I2,0,0,I4,0);
3759
3760     VARXOR(UI2,65535,UI2,65535,I4,0);
3761     VARXOR(UI2,65535,UI2,0,I4,65535);
3762     VARXOR(UI2,0,UI2,0,I4,0);
3763     VARXOR(UI2,65535,I4,-1,I4,-65536);
3764     VARXOR(UI2,65535,I4,0,I4,65535);
3765     VARXOR(UI2,0,I4,0,I4,0);
3766     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3767     VARXOR(UI2,65535,UI4,0,I4,65535);
3768     VARXOR(UI2,0,UI4,0,I4,0);
3769     VARXOR(UI2,65535,R4,-1,I4,-65536);
3770     VARXOR(UI2,65535,R4,0,I4,65535);
3771     VARXOR(UI2,0,R4,0,I4,0);
3772     VARXOR(UI2,65535,R8,-1,I4,-65536);
3773     VARXOR(UI2,65535,R8,0,I4,65535);
3774     VARXOR(UI2,0,R8,0,I4,0);
3775     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3776     VARXOR(UI2,65535,DATE,0,I4,65535);
3777     VARXOR(UI2,0,DATE,0,I4,0);
3778     if (HAVE_OLEAUT32_I8)
3779     {
3780         VARXOR(UI2,65535,I8,-1,I8,-65536);
3781         VARXOR(UI2,65535,I8,0,I8,65535);
3782         VARXOR(UI2,0,I8,0,I8,0);
3783         VARXOR(UI2,65535,UI8,0,I4,65535);
3784         VARXOR(UI2,0,UI8,0,I4,0);
3785     }
3786     VARXOR(UI2,65535,INT,-1,I4,-65536);
3787     VARXOR(UI2,65535,INT,0,I4,65535);
3788     VARXOR(UI2,0,INT,0,I4,0);
3789     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3790     VARXOR(UI2,65535,UINT,0,I4,65535);
3791     VARXOR(UI2,0,UINT,0,I4,0);
3792     rbstr = SysAllocString(szFalse);
3793     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3794     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3795     SysFreeString(rbstr);
3796     rbstr = SysAllocString(szTrue);
3797     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3798     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3799     SysFreeString(rbstr);
3800     VARXORCY(UI2,65535,10000,I4,65534);
3801     VARXORCY(UI2,65535,0,I4,65535);
3802     VARXORCY(UI2,0,0,I4,0);
3803
3804     VARXOR(I4,-1,I4,-1,I4,0);
3805     VARXOR(I4,-1,I4,0,I4,-1);
3806     VARXOR(I4,0,I4,0,I4,0);
3807     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3808     VARXOR(I4,-1,UI4,0,I4,-1);
3809     VARXOR(I4,0,UI4,0,I4,0);
3810     VARXOR(I4,-1,R4,-1,I4,0);
3811     VARXOR(I4,-1,R4,0,I4,-1);
3812     VARXOR(I4,0,R4,0,I4,0);
3813     VARXOR(I4,-1,R8,-1,I4,0);
3814     VARXOR(I4,-1,R8,0,I4,-1);
3815     VARXOR(I4,0,R8,0,I4,0);
3816     VARXOR(I4,-1,DATE,-1,I4,0);
3817     VARXOR(I4,-1,DATE,0,I4,-1);
3818     VARXOR(I4,0,DATE,0,I4,0);
3819     if (HAVE_OLEAUT32_I8)
3820     {
3821         VARXOR(I4,-1,I8,-1,I8,0);
3822         VARXOR(I4,-1,I8,0,I8,-1);
3823         VARXOR(I4,0,I8,0,I8,0);
3824         VARXOR(I4,-1,UI8,0,I4,-1);
3825         VARXOR(I4,0,UI8,0,I4,0);
3826     }
3827     VARXOR(I4,-1,INT,-1,I4,0);
3828     VARXOR(I4,-1,INT,0,I4,-1);
3829     VARXOR(I4,0,INT,0,I4,0);
3830     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3831     VARXOR(I4,-1,UINT,0,I4,-1);
3832     VARXOR(I4,0,UINT,0,I4,0);
3833     rbstr = SysAllocString(szFalse);
3834     VARXOR(I4,0,BSTR,rbstr,I4,0);
3835     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3836     SysFreeString(rbstr);
3837     rbstr = SysAllocString(szTrue);
3838     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3839     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3840     SysFreeString(rbstr);
3841     VARXORCY(I4,-1,10000,I4,-2);
3842     VARXORCY(I4,-1,0,I4,-1);
3843     VARXORCY(I4,0,0,I4,0);
3844
3845     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3846     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3847     VARXOR(UI4,0,UI4,0,I4,0);
3848     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3849     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3850     VARXOR(UI4,0,R4,0,I4,0);
3851     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3852     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3853     VARXOR(UI4,0,R8,0,I4,0);
3854     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3855     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3856     VARXOR(UI4,0,DATE,0,I4,0);
3857     if (HAVE_OLEAUT32_I8)
3858     {
3859         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3860         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3861         VARXOR(UI4,0,I8,0,I8,0);
3862         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3863         VARXOR(UI4,0,UI8,0,I4,0);
3864     }
3865     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3866     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3867     VARXOR(UI4,0,INT,0,I4,0);
3868     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3869     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3870     VARXOR(UI4,0,UINT,0,I4,0);
3871     rbstr = SysAllocString(szFalse);
3872     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3873     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3874     SysFreeString(rbstr);
3875     rbstr = SysAllocString(szTrue);
3876     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3877     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3878     SysFreeString(rbstr);
3879     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3880     VARXORCY(UI4,0xffffffff,0,I4,-1);
3881     VARXORCY(UI4,0,0,I4,0);
3882
3883     VARXOR(R4,-1,R4,-1,I4,0);
3884     VARXOR(R4,-1,R4,0,I4,-1);
3885     VARXOR(R4,0,R4,0,I4,0);
3886     VARXOR(R4,-1,R8,-1,I4,0);
3887     VARXOR(R4,-1,R8,0,I4,-1);
3888     VARXOR(R4,0,R8,0,I4,0);
3889     VARXOR(R4,-1,DATE,-1,I4,0);
3890     VARXOR(R4,-1,DATE,0,I4,-1);
3891     VARXOR(R4,0,DATE,0,I4,0);
3892     if (HAVE_OLEAUT32_I8)
3893     {
3894         VARXOR(R4,-1,I8,-1,I8,0);
3895         VARXOR(R4,-1,I8,0,I8,-1);
3896         VARXOR(R4,0,I8,0,I8,0);
3897         VARXOR(R4,-1,UI8,0,I4,-1);
3898         VARXOR(R4,0,UI8,0,I4,0);
3899     }
3900     VARXOR(R4,-1,INT,-1,I4,0);
3901     VARXOR(R4,-1,INT,0,I4,-1);
3902     VARXOR(R4,0,INT,0,I4,0);
3903     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3904     VARXOR(R4,-1,UINT,0,I4,-1);
3905     VARXOR(R4,0,UINT,0,I4,0);
3906     rbstr = SysAllocString(szFalse);
3907     VARXOR(R4,0,BSTR,rbstr,I4,0);
3908     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3909     SysFreeString(rbstr);
3910     rbstr = SysAllocString(szTrue);
3911     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3912     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3913     SysFreeString(rbstr);
3914     VARXORCY(R4,-1,10000,I4,-2);
3915     VARXORCY(R4,-1,0,I4,-1);
3916     VARXORCY(R4,0,0,I4,0);
3917
3918     VARXOR(R8,-1,R8,-1,I4,0);
3919     VARXOR(R8,-1,R8,0,I4,-1);
3920     VARXOR(R8,0,R8,0,I4,0);
3921     VARXOR(R8,-1,DATE,-1,I4,0);
3922     VARXOR(R8,-1,DATE,0,I4,-1);
3923     VARXOR(R8,0,DATE,0,I4,0);
3924     if (HAVE_OLEAUT32_I8)
3925     {
3926         VARXOR(R8,-1,I8,-1,I8,0);
3927         VARXOR(R8,-1,I8,0,I8,-1);
3928         VARXOR(R8,0,I8,0,I8,0);
3929         VARXOR(R8,-1,UI8,0,I4,-1);
3930         VARXOR(R8,0,UI8,0,I4,0);
3931     }
3932     VARXOR(R8,-1,INT,-1,I4,0);
3933     VARXOR(R8,-1,INT,0,I4,-1);
3934     VARXOR(R8,0,INT,0,I4,0);
3935     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3936     VARXOR(R8,-1,UINT,0,I4,-1);
3937     VARXOR(R8,0,UINT,0,I4,0);
3938     rbstr = SysAllocString(szFalse);
3939     VARXOR(R8,0,BSTR,rbstr,I4,0);
3940     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3941     SysFreeString(rbstr);
3942     rbstr = SysAllocString(szTrue);
3943     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3944     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3945     SysFreeString(rbstr);
3946     VARXORCY(R8,-1,10000,I4,-2);
3947     VARXORCY(R8,-1,0,I4,-1);
3948     VARXORCY(R8,0,0,I4,0);
3949
3950     VARXOR(DATE,-1,DATE,-1,I4,0);
3951     VARXOR(DATE,-1,DATE,0,I4,-1);
3952     VARXOR(DATE,0,DATE,0,I4,0);
3953     if (HAVE_OLEAUT32_I8)
3954     {
3955         VARXOR(DATE,-1,I8,-1,I8,0);
3956         VARXOR(DATE,-1,I8,0,I8,-1);
3957         VARXOR(DATE,0,I8,0,I8,0);
3958         VARXOR(DATE,-1,UI8,0,I4,-1);
3959         VARXOR(DATE,0,UI8,0,I4,0);
3960     }
3961     VARXOR(DATE,-1,INT,-1,I4,0);
3962     VARXOR(DATE,-1,INT,0,I4,-1);
3963     VARXOR(DATE,0,INT,0,I4,0);
3964     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3965     VARXOR(DATE,-1,UINT,0,I4,-1);
3966     VARXOR(DATE,0,UINT,0,I4,0);
3967     rbstr = SysAllocString(szFalse);
3968     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3969     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3970     SysFreeString(rbstr);
3971     rbstr = SysAllocString(szTrue);
3972     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3973     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3974     SysFreeString(rbstr);
3975     VARXORCY(DATE,-1,10000,I4,-2);
3976     VARXORCY(DATE,-1,0,I4,-1);
3977     VARXORCY(DATE,0,0,I4,0);
3978
3979     if (HAVE_OLEAUT32_I8)
3980     {
3981         VARXOR(I8,-1,I8,-1,I8,0);
3982         VARXOR(I8,-1,I8,0,I8,-1);
3983         VARXOR(I8,0,I8,0,I8,0);
3984         VARXOR(I8,-1,UI8,0,I8,-1);
3985         VARXOR(I8,0,UI8,0,I8,0);
3986         VARXOR(I8,-1,UINT,0,I8,-1);
3987         VARXOR(I8,0,UINT,0,I8,0);
3988         rbstr = SysAllocString(szFalse);
3989         VARXOR(I8,0,BSTR,rbstr,I8,0);
3990         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
3991         SysFreeString(rbstr);
3992         rbstr = SysAllocString(szTrue);
3993         VARXOR(I8,0,BSTR,rbstr,I8,-1);
3994         VARXOR(I8,-1,BSTR,rbstr,I8,0);
3995         SysFreeString(rbstr);
3996         VARXORCY(I8,-1,10000,I8,-2);
3997         VARXORCY(I8,-1,0,I8,-1);
3998         VARXORCY(I8,0,0,I8,0);
3999
4000         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
4001         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
4002         VARXOR(UI8,0,UI8,0,I4,0);
4003         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
4004         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
4005         VARXOR(UI8,0,INT,0,I4,0);
4006         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
4007         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
4008         VARXOR(UI8,0,UINT,0,I4,0);
4009         rbstr = SysAllocString(szFalse);
4010         VARXOR(UI8,0,BSTR,rbstr,I4,0);
4011         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4012         SysFreeString(rbstr);
4013         rbstr = SysAllocString(szTrue);
4014         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
4015         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
4016         SysFreeString(rbstr);
4017         VARXORCY(UI8,0xffff,10000,I4,65534);
4018         VARXORCY(UI8,0xffff,0,I4,0xffff);
4019         VARXORCY(UI8,0,0,I4,0);
4020     }
4021
4022     VARXOR(INT,-1,INT,-1,I4,0);
4023     VARXOR(INT,-1,INT,0,I4,-1);
4024     VARXOR(INT,0,INT,0,I4,0);
4025     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
4026     VARXOR(INT,-1,UINT,0,I4,-1);
4027     VARXOR(INT,0,UINT,0,I4,0);
4028     rbstr = SysAllocString(szFalse);
4029     VARXOR(INT,0,BSTR,rbstr,I4,0);
4030     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
4031     SysFreeString(rbstr);
4032     rbstr = SysAllocString(szTrue);
4033     VARXOR(INT,0,BSTR,rbstr,I4,-1);
4034     VARXOR(INT,-1,BSTR,rbstr,I4,0);
4035     SysFreeString(rbstr);
4036     VARXORCY(INT,-1,10000,I4,-2);
4037     VARXORCY(INT,-1,0,I4,-1);
4038     VARXORCY(INT,0,0,I4,0);
4039
4040     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
4041     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
4042     VARXOR(UINT,0,UINT,0,I4,0);
4043     rbstr = SysAllocString(szFalse);
4044     VARXOR(UINT,0,BSTR,rbstr,I4,0);
4045     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4046     SysFreeString(rbstr);
4047     rbstr = SysAllocString(szTrue);
4048     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
4049     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
4050     SysFreeString(rbstr);
4051     VARXORCY(UINT,0xffff,10000,I4,65534);
4052     VARXORCY(UINT,0xffff,0,I4,0xffff);
4053     VARXORCY(UINT,0,0,I4,0);
4054
4055     lbstr = SysAllocString(szFalse);
4056     rbstr = SysAllocString(szFalse);
4057     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4058     SysFreeString(rbstr);
4059     rbstr = SysAllocString(szTrue);
4060     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4061     SysFreeString(lbstr);
4062     lbstr = SysAllocString(szTrue);
4063     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
4064     VARXORCY(BSTR,lbstr,10000,I4,-2);
4065     SysFreeString(lbstr);
4066     lbstr = SysAllocString(szFalse);
4067     VARXORCY(BSTR,lbstr,10000,I4,1);
4068     SysFreeString(lbstr);
4069     SysFreeString(rbstr);
4070 }
4071
4072 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
4073
4074 #define VAROR(vt1,val1,vt2,val2,rvt,rval)                \
4075         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4076         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4077         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4078         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4079
4080 #define VARORCY(vt1,val1,val2,rvt,rval)                  \
4081         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4082         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
4083         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4084         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4085
4086 static void test_VarOr(void)
4087 {
4088     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
4089     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
4090     VARIANT left, right, exp, result;
4091     BSTR lbstr, rbstr;
4092     VARTYPE i;
4093     HRESULT hres;
4094
4095     CHECKPTR(VarOr);
4096
4097     /* Test all possible flag/vt combinations & the resulting vt type */
4098     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4099     {
4100         VARTYPE leftvt, rightvt, resvt;
4101
4102         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4103         {
4104
4105             SKIPTESTS(leftvt);
4106
4107             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4108             {
4109                 BOOL bFail = FALSE;
4110
4111                 SKIPTESTS(rightvt);
4112
4113                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4114                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4115                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4116                     continue;
4117
4118                 memset(&left, 0, sizeof(left));
4119                 memset(&right, 0, sizeof(right));
4120                 V_VT(&left) = leftvt | ExtraFlags[i];
4121                 V_VT(&right) = rightvt | ExtraFlags[i];
4122                 V_VT(&result) = VT_EMPTY;
4123                 resvt = VT_I4;
4124
4125                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4126                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4127                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4128                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4129                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4130                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4131                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4132                 {
4133                     bFail = TRUE;
4134                 }
4135                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4136                 {
4137                     if (leftvt == rightvt ||
4138                         leftvt == VT_I2 || rightvt == VT_I2 ||
4139                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4140                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4141                         resvt = VT_I2;
4142                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4143                         resvt = VT_NULL;
4144                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4145                         resvt = VT_I8;
4146                 }
4147                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4148                 {
4149                     resvt = VT_NULL;
4150                 }
4151                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4152                 {
4153                     if (leftvt == rightvt)
4154                         resvt = VT_UI1;
4155                     else if (leftvt == rightvt ||
4156                         leftvt == VT_I2 || rightvt == VT_I2 ||
4157                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4158                     {
4159                         resvt = VT_I2;
4160                     }
4161                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4162                         resvt = VT_I8;
4163                 }
4164                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4165                 {
4166                     if (leftvt == rightvt ||
4167                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4168                         resvt = VT_I2;
4169                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4170                         resvt = VT_I8;
4171                 }
4172                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4173                 {
4174                     resvt = VT_BOOL;
4175                 }
4176                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4177                 {
4178                     if (leftvt == VT_INT || rightvt == VT_INT)
4179                         bFail = TRUE;
4180                     else
4181                         resvt = VT_I8;
4182                 }
4183                 hres = pVarOr(&left, &right, &result);
4184                 if (bFail)
4185                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4186                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4187                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4188                        V_VT(&result));
4189                 else
4190                     ok(hres == S_OK && V_VT(&result) == resvt,
4191                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4192                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4193                        V_VT(&result));
4194             }
4195         }
4196     }
4197
4198     /* Test returned values. Since we know the returned type is correct
4199      * and that we handle all combinations of invalid types, just check
4200      * that good type combinations produce the desired value.
4201      * FIXME: Test VT_DECIMAL/VT_DISPATCH
4202      */
4203     VAROR(EMPTY,0,EMPTY,0,I2,0);
4204     VAROR(EMPTY,1,EMPTY,0,I2,0);
4205     VAROR(EMPTY,0,NULL,0,NULL,0);
4206     VAROR(EMPTY,0,I1,0,I4,0);
4207     VAROR(EMPTY,0,I1,1,I4,1);
4208     VAROR(EMPTY,0,UI1,0,I2,0);
4209     VAROR(EMPTY,0,UI1,1,I2,1);
4210     VAROR(EMPTY,0,I2,0,I2,0);
4211     VAROR(EMPTY,0,I2,1,I2,1);
4212     VAROR(EMPTY,0,UI2,0,I4,0);
4213     VAROR(EMPTY,0,UI2,1,I4,1);
4214     VAROR(EMPTY,0,I4,0,I4,0);
4215     VAROR(EMPTY,0,I4,1,I4,1);
4216     VAROR(EMPTY,0,UI4,0,I4,0);
4217     VAROR(EMPTY,0,UI4,1,I4,1);
4218     if (HAVE_OLEAUT32_I8)
4219     {
4220         VAROR(EMPTY,0,I8,0,I8,0);
4221         VAROR(EMPTY,0,I8,1,I8,1);
4222         VAROR(EMPTY,0,UI8,0,I4,0);
4223         VAROR(EMPTY,0,UI8,1,I4,1);
4224     }
4225     VAROR(EMPTY,0,INT,0,I4,0);
4226     VAROR(EMPTY,0,INT,1,I4,1);
4227     VAROR(EMPTY,0,UINT,0,I4,0);
4228     VAROR(EMPTY,0,UINT,1,I4,1);
4229     VAROR(EMPTY,0,BOOL,0,I2,0);
4230     VAROR(EMPTY,0,BOOL,1,I2,1);
4231     VAROR(EMPTY,0,R4,0,I4,0);
4232     VAROR(EMPTY,0,R4,1,I4,1);
4233     VAROR(EMPTY,0,R8,0,I4,0);
4234     VAROR(EMPTY,0,R8,1,I4,1);
4235     rbstr = SysAllocString(szFalse);
4236     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
4237     SysFreeString(rbstr);
4238     rbstr = SysAllocString(szTrue);
4239     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
4240     SysFreeString(rbstr);
4241     VARORCY(EMPTY,0,10000,I4,1);
4242
4243     /* NULL OR 0 = NULL. NULL OR n = n */
4244     VAROR(NULL,0,NULL,0,NULL,0);
4245     VAROR(NULL,1,NULL,0,NULL,0);
4246     VAROR(NULL,0,I1,0,NULL,0);
4247     VAROR(NULL,0,I1,1,I4,1);
4248     VAROR(NULL,0,UI1,0,NULL,0);
4249     VAROR(NULL,0,UI1,1,UI1,1);
4250     VAROR(NULL,0,I2,0,NULL,0);
4251     VAROR(NULL,0,I2,1,I2,1);
4252     VAROR(NULL,0,UI2,0,NULL,0);
4253     VAROR(NULL,0,UI2,1,I4,1);
4254     VAROR(NULL,0,I4,0,NULL,0);
4255     VAROR(NULL,0,I4,1,I4,1);
4256     VAROR(NULL,0,UI4,0,NULL,0);
4257     VAROR(NULL,0,UI4,1,I4,1);
4258     if (HAVE_OLEAUT32_I8)
4259     {
4260         VAROR(NULL,0,I8,0,NULL,0);
4261         VAROR(NULL,0,I8,1,I8,1);
4262         VAROR(NULL,0,UI8,0,NULL,0);
4263         VAROR(NULL,0,UI8,1,I4,1);
4264     }
4265     VAROR(NULL,0,INT,0,NULL,0);
4266     VAROR(NULL,0,INT,1,I4,1);
4267     VAROR(NULL,0,UINT,0,NULL,0);
4268     VAROR(NULL,0,UINT,1,I4,1);
4269     VAROR(NULL,0,BOOL,0,NULL,0);
4270     VAROR(NULL,0,BOOL,1,BOOL,1);
4271     VAROR(NULL,0,R4,0,NULL,0);
4272     VAROR(NULL,0,R4,1,I4,1);
4273     VAROR(NULL,0,R8,0,NULL,0);
4274     VAROR(NULL,0,R8,1,I4,1);
4275     rbstr = SysAllocString(szFalse);
4276     VAROR(NULL,0,BSTR,rbstr,NULL,0);
4277     SysFreeString(rbstr);
4278     rbstr = SysAllocString(szTrue);
4279     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
4280     SysFreeString(rbstr);
4281     VARORCY(NULL,0,10000,I4,1);
4282     VARORCY(NULL,0,0,NULL,0);
4283
4284     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4285     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4286     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4287     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4288     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4289     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
4290     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4291     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4292     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
4293     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4294     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4295     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
4296     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4297     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4298     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
4299     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4300     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4301     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
4302     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4303     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4304     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
4305     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4306     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4307     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
4308     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4309     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4310     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
4311     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4312     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4313     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
4314     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4315     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4316     if (HAVE_OLEAUT32_I8)
4317     {
4318         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
4319         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4320         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4321         /* This returns DISP_E_OVERFLOW which indicates that a conversion
4322          * to I4 is performed.
4323          */
4324         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4325         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4326         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4327     }
4328     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
4329     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4330     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4331     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
4332     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4333     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4334     rbstr = SysAllocString(szFalse);
4335     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4336     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4337     SysFreeString(rbstr);
4338     rbstr = SysAllocString(szTrue);
4339     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4340     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4341     SysFreeString(rbstr);
4342     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
4343     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4344     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
4345
4346     VAROR(I1,-1,I1,-1,I4,-1);
4347     VAROR(I1,-1,I1,0,I4,-1);
4348     VAROR(I1,0,I1,0,I4,0);
4349     VAROR(I1,-1,UI1,255,I4,-1);
4350     VAROR(I1,-1,UI1,0,I4,-1);
4351     VAROR(I1,0,UI1,0,I4,0);
4352     VAROR(I1,-1,I2,-1,I4,-1);
4353     VAROR(I1,-1,I2,0,I4,-1);
4354     VAROR(I1,0,I2,0,I4,0);
4355     VAROR(I1,-1,UI2,65535,I4,-1);
4356     VAROR(I1,-1,UI2,0,I4,-1);
4357     VAROR(I1,0,UI2,0,I4,0);
4358     VAROR(I1,-1,I4,-1,I4,-1);
4359     VAROR(I1,-1,I4,0,I4,-1);
4360     VAROR(I1,0,I4,0,I4,0);
4361     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
4362     VAROR(I1,-1,UI4,0,I4,-1);
4363     VAROR(I1,0,UI4,0,I4,0);
4364     VAROR(I1,-1,R4,-1,I4,-1);
4365     VAROR(I1,-1,R4,0,I4,-1);
4366     VAROR(I1,0,R4,0,I4,0);
4367     VAROR(I1,-1,R8,-1,I4,-1);
4368     VAROR(I1,-1,R8,0,I4,-1);
4369     VAROR(I1,0,R8,0,I4,0);
4370     VAROR(I1,-1,DATE,-1,I4,-1);
4371     VAROR(I1,-1,DATE,0,I4,-1);
4372     VAROR(I1,0,DATE,0,I4,0);
4373     if (HAVE_OLEAUT32_I8)
4374     {
4375         VAROR(I1,-1,I8,-1,I8,-1);
4376         VAROR(I1,-1,I8,0,I8,-1);
4377         VAROR(I1,0,I8,0,I8,0);
4378         VAROR(I1,-1,UI8,0,I4,-1);
4379         VAROR(I1,0,UI8,0,I4,0);
4380     }
4381     VAROR(I1,-1,INT,-1,I4,-1);
4382     VAROR(I1,-1,INT,0,I4,-1);
4383     VAROR(I1,0,INT,0,I4,0);
4384     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
4385     VAROR(I1,-1,UINT,0,I4,-1);
4386     VAROR(I1,0,UINT,0,I4,0);
4387     rbstr = SysAllocString(szFalse);
4388     VAROR(I1,0,BSTR,rbstr,I4,0);
4389     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4390     SysFreeString(rbstr);
4391     rbstr = SysAllocString(szTrue);
4392     VAROR(I1,0,BSTR,rbstr,I4,-1);
4393     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4394     SysFreeString(rbstr);
4395     VARORCY(I1,-1,10000,I4,-1);
4396     VARORCY(I1,-1,0,I4,-1);
4397     VARORCY(I1,0,0,I4,0);
4398
4399     VAROR(UI1,255,UI1,255,UI1,255);
4400     VAROR(UI1,255,UI1,0,UI1,255);
4401     VAROR(UI1,0,UI1,0,UI1,0);
4402     VAROR(UI1,255,I2,-1,I2,-1);
4403     VAROR(UI1,255,I2,0,I2,255);
4404     VAROR(UI1,0,I2,0,I2,0);
4405     VAROR(UI1,255,UI2,65535,I4,65535);
4406     VAROR(UI1,255,UI2,0,I4,255);
4407     VAROR(UI1,0,UI2,0,I4,0);
4408     VAROR(UI1,255,I4,-1,I4,-1);
4409     VAROR(UI1,255,I4,0,I4,255);
4410     VAROR(UI1,0,I4,0,I4,0);
4411     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4412     VAROR(UI1,255,UI4,0,I4,255);
4413     VAROR(UI1,0,UI4,0,I4,0);
4414     VAROR(UI1,255,R4,-1,I4,-1);
4415     VAROR(UI1,255,R4,0,I4,255);
4416     VAROR(UI1,0,R4,0,I4,0);
4417     VAROR(UI1,255,R8,-1,I4,-1);
4418     VAROR(UI1,255,R8,0,I4,255);
4419     VAROR(UI1,0,R8,0,I4,0);
4420     VAROR(UI1,255,DATE,-1,I4,-1);
4421     VAROR(UI1,255,DATE,0,I4,255);
4422     VAROR(UI1,0,DATE,0,I4,0);
4423     if (HAVE_OLEAUT32_I8)
4424     {
4425         VAROR(UI1,255,I8,-1,I8,-1);
4426         VAROR(UI1,255,I8,0,I8,255);
4427         VAROR(UI1,0,I8,0,I8,0);
4428         VAROR(UI1,255,UI8,0,I4,255);
4429         VAROR(UI1,0,UI8,0,I4,0);
4430     }
4431     VAROR(UI1,255,INT,-1,I4,-1);
4432     VAROR(UI1,255,INT,0,I4,255);
4433     VAROR(UI1,0,INT,0,I4,0);
4434     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4435     VAROR(UI1,255,UINT,0,I4,255);
4436     VAROR(UI1,0,UINT,0,I4,0);
4437     rbstr = SysAllocString(szFalse);
4438     VAROR(UI1,0,BSTR,rbstr,I2,0);
4439     VAROR(UI1,255,BSTR,rbstr,I2,255);
4440     SysFreeString(rbstr);
4441     rbstr = SysAllocString(szTrue);
4442     VAROR(UI1,0,BSTR,rbstr,I2,-1);
4443     VAROR(UI1,255,BSTR,rbstr,I2,-1);
4444     SysFreeString(rbstr);
4445     VARORCY(UI1,255,10000,I4,255);
4446     VARORCY(UI1,255,0,I4,255);
4447     VARORCY(UI1,0,0,I4,0);
4448
4449     VAROR(I2,-1,I2,-1,I2,-1);
4450     VAROR(I2,-1,I2,0,I2,-1);
4451     VAROR(I2,0,I2,0,I2,0);
4452     VAROR(I2,-1,UI2,65535,I4,-1);
4453     VAROR(I2,-1,UI2,0,I4,-1);
4454     VAROR(I2,0,UI2,0,I4,0);
4455     VAROR(I2,-1,I4,-1,I4,-1);
4456     VAROR(I2,-1,I4,0,I4,-1);
4457     VAROR(I2,0,I4,0,I4,0);
4458     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4459     VAROR(I2,-1,UI4,0,I4,-1);
4460     VAROR(I2,0,UI4,0,I4,0);
4461     VAROR(I2,-1,R4,-1,I4,-1);
4462     VAROR(I2,-1,R4,0,I4,-1);
4463     VAROR(I2,0,R4,0,I4,0);
4464     VAROR(I2,-1,R8,-1,I4,-1);
4465     VAROR(I2,-1,R8,0,I4,-1);
4466     VAROR(I2,0,R8,0,I4,0);
4467     VAROR(I2,-1,DATE,-1,I4,-1);
4468     VAROR(I2,-1,DATE,0,I4,-1);
4469     VAROR(I2,0,DATE,0,I4,0);
4470     if (HAVE_OLEAUT32_I8)
4471     {
4472         VAROR(I2,-1,I8,-1,I8,-1);
4473         VAROR(I2,-1,I8,0,I8,-1);
4474         VAROR(I2,0,I8,0,I8,0);
4475         VAROR(I2,-1,UI8,0,I4,-1);
4476         VAROR(I2,0,UI8,0,I4,0);
4477     }
4478     VAROR(I2,-1,INT,-1,I4,-1);
4479     VAROR(I2,-1,INT,0,I4,-1);
4480     VAROR(I2,0,INT,0,I4,0);
4481     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4482     VAROR(I2,-1,UINT,0,I4,-1);
4483     VAROR(I2,0,UINT,0,I4,0);
4484     rbstr = SysAllocString(szFalse);
4485     VAROR(I2,0,BSTR,rbstr,I2,0);
4486     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4487     SysFreeString(rbstr);
4488     rbstr = SysAllocString(szTrue);
4489     VAROR(I2,0,BSTR,rbstr,I2,-1);
4490     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4491     SysFreeString(rbstr);
4492     VARORCY(I2,-1,10000,I4,-1);
4493     VARORCY(I2,-1,0,I4,-1);
4494     VARORCY(I2,0,0,I4,0);
4495
4496     VAROR(UI2,65535,UI2,65535,I4,65535);
4497     VAROR(UI2,65535,UI2,0,I4,65535);
4498     VAROR(UI2,0,UI2,0,I4,0);
4499     VAROR(UI2,65535,I4,-1,I4,-1);
4500     VAROR(UI2,65535,I4,0,I4,65535);
4501     VAROR(UI2,0,I4,0,I4,0);
4502     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4503     VAROR(UI2,65535,UI4,0,I4,65535);
4504     VAROR(UI2,0,UI4,0,I4,0);
4505     VAROR(UI2,65535,R4,-1,I4,-1);
4506     VAROR(UI2,65535,R4,0,I4,65535);
4507     VAROR(UI2,0,R4,0,I4,0);
4508     VAROR(UI2,65535,R8,-1,I4,-1);
4509     VAROR(UI2,65535,R8,0,I4,65535);
4510     VAROR(UI2,0,R8,0,I4,0);
4511     VAROR(UI2,65535,DATE,-1,I4,-1);
4512     VAROR(UI2,65535,DATE,0,I4,65535);
4513     VAROR(UI2,0,DATE,0,I4,0);
4514     if (HAVE_OLEAUT32_I8)
4515     {
4516         VAROR(UI2,65535,I8,-1,I8,-1);
4517         VAROR(UI2,65535,I8,0,I8,65535);
4518         VAROR(UI2,0,I8,0,I8,0);
4519         VAROR(UI2,65535,UI8,0,I4,65535);
4520         VAROR(UI2,0,UI8,0,I4,0);
4521     }
4522     VAROR(UI2,65535,INT,-1,I4,-1);
4523     VAROR(UI2,65535,INT,0,I4,65535);
4524     VAROR(UI2,0,INT,0,I4,0);
4525     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4526     VAROR(UI2,65535,UINT,0,I4,65535);
4527     VAROR(UI2,0,UINT,0,I4,0);
4528     rbstr = SysAllocString(szFalse);
4529     VAROR(UI2,0,BSTR,rbstr,I4,0);
4530     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4531     SysFreeString(rbstr);
4532     rbstr = SysAllocString(szTrue);
4533     VAROR(UI2,0,BSTR,rbstr,I4,-1);
4534     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4535     SysFreeString(rbstr);
4536     VARORCY(UI2,65535,10000,I4,65535);
4537     VARORCY(UI2,65535,0,I4,65535);
4538     VARORCY(UI2,0,0,I4,0);
4539
4540     VAROR(I4,-1,I4,-1,I4,-1);
4541     VAROR(I4,-1,I4,0,I4,-1);
4542     VAROR(I4,0,I4,0,I4,0);
4543     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4544     VAROR(I4,-1,UI4,0,I4,-1);
4545     VAROR(I4,0,UI4,0,I4,0);
4546     VAROR(I4,-1,R4,-1,I4,-1);
4547     VAROR(I4,-1,R4,0,I4,-1);
4548     VAROR(I4,0,R4,0,I4,0);
4549     VAROR(I4,-1,R8,-1,I4,-1);
4550     VAROR(I4,-1,R8,0,I4,-1);
4551     VAROR(I4,0,R8,0,I4,0);
4552     VAROR(I4,-1,DATE,-1,I4,-1);
4553     VAROR(I4,-1,DATE,0,I4,-1);
4554     VAROR(I4,0,DATE,0,I4,0);
4555     if (HAVE_OLEAUT32_I8)
4556     {
4557         VAROR(I4,-1,I8,-1,I8,-1);
4558         VAROR(I4,-1,I8,0,I8,-1);
4559         VAROR(I4,0,I8,0,I8,0);
4560         VAROR(I4,-1,UI8,0,I4,-1);
4561         VAROR(I4,0,UI8,0,I4,0);
4562     }
4563     VAROR(I4,-1,INT,-1,I4,-1);
4564     VAROR(I4,-1,INT,0,I4,-1);
4565     VAROR(I4,0,INT,0,I4,0);
4566     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4567     VAROR(I4,-1,UINT,0,I4,-1);
4568     VAROR(I4,0,UINT,0,I4,0);
4569     rbstr = SysAllocString(szFalse);
4570     VAROR(I4,0,BSTR,rbstr,I4,0);
4571     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4572     SysFreeString(rbstr);
4573     rbstr = SysAllocString(szTrue);
4574     VAROR(I4,0,BSTR,rbstr,I4,-1);
4575     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4576     SysFreeString(rbstr);
4577     VARORCY(I4,-1,10000,I4,-1);
4578     VARORCY(I4,-1,0,I4,-1);
4579     VARORCY(I4,0,0,I4,0);
4580
4581     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4582     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4583     VAROR(UI4,0,UI4,0,I4,0);
4584     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4585     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4586     VAROR(UI4,0,R4,0,I4,0);
4587     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4588     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4589     VAROR(UI4,0,R8,0,I4,0);
4590     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4591     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4592     VAROR(UI4,0,DATE,0,I4,0);
4593     if (HAVE_OLEAUT32_I8)
4594     {
4595         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4596         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4597         VAROR(UI4,0,I8,0,I8,0);
4598         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4599         VAROR(UI4,0,UI8,0,I4,0);
4600     }
4601     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4602     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4603     VAROR(UI4,0,INT,0,I4,0);
4604     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4605     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4606     VAROR(UI4,0,UINT,0,I4,0);
4607     rbstr = SysAllocString(szFalse);
4608     VAROR(UI4,0,BSTR,rbstr,I4,0);
4609     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4610     SysFreeString(rbstr);
4611     rbstr = SysAllocString(szTrue);
4612     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4613     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4614     SysFreeString(rbstr);
4615     VARORCY(UI4,0xffffffff,10000,I4,-1);
4616     VARORCY(UI4,0xffffffff,0,I4,-1);
4617     VARORCY(UI4,0,0,I4,0);
4618
4619     VAROR(R4,-1,R4,-1,I4,-1);
4620     VAROR(R4,-1,R4,0,I4,-1);
4621     VAROR(R4,0,R4,0,I4,0);
4622     VAROR(R4,-1,R8,-1,I4,-1);
4623     VAROR(R4,-1,R8,0,I4,-1);
4624     VAROR(R4,0,R8,0,I4,0);
4625     VAROR(R4,-1,DATE,-1,I4,-1);
4626     VAROR(R4,-1,DATE,0,I4,-1);
4627     VAROR(R4,0,DATE,0,I4,0);
4628     if (HAVE_OLEAUT32_I8)
4629     {
4630         VAROR(R4,-1,I8,-1,I8,-1);
4631         VAROR(R4,-1,I8,0,I8,-1);
4632         VAROR(R4,0,I8,0,I8,0);
4633         VAROR(R4,-1,UI8,0,I4,-1);
4634         VAROR(R4,0,UI8,0,I4,0);
4635     }
4636     VAROR(R4,-1,INT,-1,I4,-1);
4637     VAROR(R4,-1,INT,0,I4,-1);
4638     VAROR(R4,0,INT,0,I4,0);
4639     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4640     VAROR(R4,-1,UINT,0,I4,-1);
4641     VAROR(R4,0,UINT,0,I4,0);
4642     rbstr = SysAllocString(szFalse);
4643     VAROR(R4,0,BSTR,rbstr,I4,0);
4644     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4645     SysFreeString(rbstr);
4646     rbstr = SysAllocString(szTrue);
4647     VAROR(R4,0,BSTR,rbstr,I4,-1);
4648     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4649     SysFreeString(rbstr);
4650     VARORCY(R4,-1,10000,I4,-1);
4651     VARORCY(R4,-1,0,I4,-1);
4652     VARORCY(R4,0,0,I4,0);
4653
4654     VAROR(R8,-1,R8,-1,I4,-1);
4655     VAROR(R8,-1,R8,0,I4,-1);
4656     VAROR(R8,0,R8,0,I4,0);
4657     VAROR(R8,-1,DATE,-1,I4,-1);
4658     VAROR(R8,-1,DATE,0,I4,-1);
4659     VAROR(R8,0,DATE,0,I4,0);
4660     if (HAVE_OLEAUT32_I8)
4661     {
4662         VAROR(R8,-1,I8,-1,I8,-1);
4663         VAROR(R8,-1,I8,0,I8,-1);
4664         VAROR(R8,0,I8,0,I8,0);
4665         VAROR(R8,-1,UI8,0,I4,-1);
4666         VAROR(R8,0,UI8,0,I4,0);
4667     }
4668     VAROR(R8,-1,INT,-1,I4,-1);
4669     VAROR(R8,-1,INT,0,I4,-1);
4670     VAROR(R8,0,INT,0,I4,0);
4671     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4672     VAROR(R8,-1,UINT,0,I4,-1);
4673     VAROR(R8,0,UINT,0,I4,0);
4674     rbstr = SysAllocString(szFalse);
4675     VAROR(R8,0,BSTR,rbstr,I4,0);
4676     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4677     SysFreeString(rbstr);
4678     rbstr = SysAllocString(szTrue);
4679     VAROR(R8,0,BSTR,rbstr,I4,-1);
4680     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4681     SysFreeString(rbstr);
4682     VARORCY(R8,-1,10000,I4,-1);
4683     VARORCY(R8,-1,0,I4,-1);
4684     VARORCY(R8,0,0,I4,0);
4685
4686     VAROR(DATE,-1,DATE,-1,I4,-1);
4687     VAROR(DATE,-1,DATE,0,I4,-1);
4688     VAROR(DATE,0,DATE,0,I4,0);
4689     if (HAVE_OLEAUT32_I8)
4690     {
4691         VAROR(DATE,-1,I8,-1,I8,-1);
4692         VAROR(DATE,-1,I8,0,I8,-1);
4693         VAROR(DATE,0,I8,0,I8,0);
4694         VAROR(DATE,-1,UI8,0,I4,-1);
4695         VAROR(DATE,0,UI8,0,I4,0);
4696     }
4697     VAROR(DATE,-1,INT,-1,I4,-1);
4698     VAROR(DATE,-1,INT,0,I4,-1);
4699     VAROR(DATE,0,INT,0,I4,0);
4700     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4701     VAROR(DATE,-1,UINT,0,I4,-1);
4702     VAROR(DATE,0,UINT,0,I4,0);
4703     rbstr = SysAllocString(szFalse);
4704     VAROR(DATE,0,BSTR,rbstr,I4,0);
4705     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4706     SysFreeString(rbstr);
4707     rbstr = SysAllocString(szTrue);
4708     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4709     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4710     SysFreeString(rbstr);
4711     VARORCY(DATE,-1,10000,I4,-1);
4712     VARORCY(DATE,-1,0,I4,-1);
4713     VARORCY(DATE,0,0,I4,0);
4714
4715     if (HAVE_OLEAUT32_I8)
4716     {
4717         VAROR(I8,-1,I8,-1,I8,-1);
4718         VAROR(I8,-1,I8,0,I8,-1);
4719         VAROR(I8,0,I8,0,I8,0);
4720         VAROR(I8,-1,UI8,0,I8,-1);
4721         VAROR(I8,0,UI8,0,I8,0);
4722         /* These overflow under native and Wine
4723         VAROR(I8,-1,INT,-1,I4,-1);
4724         VAROR(I8,-1,INT,0,I4,-1);
4725         VAROR(I8,0,INT,0,I4,0); */
4726         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4727         VAROR(I8,-1,UINT,0,I8,-1);
4728         VAROR(I8,0,UINT,0,I8,0);
4729         rbstr = SysAllocString(szFalse);
4730         VAROR(I8,0,BSTR,rbstr,I8,0);
4731         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4732         SysFreeString(rbstr);
4733         rbstr = SysAllocString(szTrue);
4734         VAROR(I8,0,BSTR,rbstr,I8,-1);
4735         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4736         SysFreeString(rbstr);
4737         VARORCY(I8,-1,10000,I8,-1);
4738         VARORCY(I8,-1,0,I8,-1);
4739         VARORCY(I8,0,0,I8,0);
4740
4741         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4742         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4743         VAROR(UI8,0,UI8,0,I4,0);
4744         VAROR(UI8,0xffff,INT,-1,I4,-1);
4745         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4746         VAROR(UI8,0,INT,0,I4,0);
4747         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4748         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4749         VAROR(UI8,0,UINT,0,I4,0);
4750         rbstr = SysAllocString(szFalse);
4751         VAROR(UI8,0,BSTR,rbstr,I4,0);
4752         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4753         SysFreeString(rbstr);
4754         rbstr = SysAllocString(szTrue);
4755         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4756         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4757         SysFreeString(rbstr);
4758         VARORCY(UI8,0xffff,10000,I4,0xffff);
4759         VARORCY(UI8,0xffff,0,I4,0xffff);
4760         VARORCY(UI8,0,0,I4,0);
4761     }
4762
4763     VAROR(INT,-1,INT,-1,I4,-1);
4764     VAROR(INT,-1,INT,0,I4,-1);
4765     VAROR(INT,0,INT,0,I4,0);
4766     VAROR(INT,-1,UINT,0xffff,I4,-1);
4767     VAROR(INT,-1,UINT,0,I4,-1);
4768     VAROR(INT,0,UINT,0,I4,0);
4769     rbstr = SysAllocString(szFalse);
4770     VAROR(INT,0,BSTR,rbstr,I4,0);
4771     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4772     SysFreeString(rbstr);
4773     rbstr = SysAllocString(szTrue);
4774     VAROR(INT,0,BSTR,rbstr,I4,-1);
4775     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4776     SysFreeString(rbstr);
4777     VARORCY(INT,-1,10000,I4,-1);
4778     VARORCY(INT,-1,0,I4,-1);
4779     VARORCY(INT,0,0,I4,0);
4780
4781     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4782     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4783     VAROR(UINT,0,UINT,0,I4,0);
4784     rbstr = SysAllocString(szFalse);
4785     VAROR(UINT,0,BSTR,rbstr,I4,0);
4786     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4787     SysFreeString(rbstr);
4788     rbstr = SysAllocString(szTrue);
4789     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4790     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4791     SysFreeString(rbstr);
4792     VARORCY(UINT,0xffff,10000,I4,0xffff);
4793     VARORCY(UINT,0xffff,0,I4,0xffff);
4794     VARORCY(UINT,0,0,I4,0);
4795
4796     lbstr = SysAllocString(szFalse);
4797     rbstr = SysAllocString(szFalse);
4798     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4799     SysFreeString(rbstr);
4800     rbstr = SysAllocString(szTrue);
4801     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4802     SysFreeString(lbstr);
4803     lbstr = SysAllocString(szTrue);
4804     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4805     VARORCY(BSTR,lbstr,10000,I4,-1);
4806     SysFreeString(lbstr);
4807     lbstr = SysAllocString(szFalse);
4808     VARORCY(BSTR,lbstr,10000,I4,1);
4809     SysFreeString(lbstr);
4810     SysFreeString(rbstr);
4811 }
4812
4813 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4814
4815 #define VAREQV(vt1,val1,vt2,val2,rvt,rval)           \
4816     V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4817     V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4818     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4819     test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )
4820
4821 static void test_VarEqv(void)
4822 {
4823     VARIANT left, right, exp, result;
4824     VARTYPE i;
4825     HRESULT hres;
4826
4827     CHECKPTR(VarEqv);
4828
4829     /* Test all possible flag/vt combinations & the resulting vt type */
4830     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4831     {
4832         VARTYPE leftvt, rightvt, resvt;
4833
4834         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4835         {
4836             SKIPTESTS(leftvt);
4837
4838             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4839             {
4840                 BOOL bFail = FALSE;
4841
4842                 SKIPTESTS(rightvt);
4843
4844                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4845                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4846                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4847                     continue;
4848
4849                 memset(&left, 0, sizeof(left));
4850                 memset(&right, 0, sizeof(right));
4851                 V_VT(&left) = leftvt | ExtraFlags[i];
4852                 V_VT(&right) = rightvt | ExtraFlags[i];
4853                 V_VT(&result) = VT_EMPTY;
4854                 resvt = VT_I4;
4855
4856                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4857                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4858                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4859                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4860                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4861                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4862                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4863                 {
4864                     bFail = TRUE;
4865                 }
4866                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4867                 {
4868                     if (leftvt == rightvt ||
4869                         leftvt == VT_I2 || rightvt == VT_I2 ||
4870                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4871                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4872                         resvt = VT_I2;
4873                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4874                         resvt = VT_NULL;
4875                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4876                         resvt = VT_I8;
4877                 }
4878                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4879                 {
4880                     resvt = VT_NULL;
4881                 }
4882                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4883                 {
4884                     if (leftvt == rightvt)
4885                         resvt = VT_UI1;
4886                     else if (leftvt == rightvt ||
4887                         leftvt == VT_I2 || rightvt == VT_I2 ||
4888                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4889                     {
4890                         resvt = VT_I2;
4891                     }
4892                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4893                         resvt = VT_I8;
4894                 }
4895                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4896                 {
4897                     if (leftvt == rightvt ||
4898                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4899                         resvt = VT_I2;
4900                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4901                         resvt = VT_I8;
4902                 }
4903                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4904                 {
4905                     resvt = VT_BOOL;
4906                 }
4907                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4908                 {
4909                     if (leftvt == VT_INT || rightvt == VT_INT)
4910                         bFail = TRUE;
4911                     else
4912                         resvt = VT_I8;
4913                 }
4914                 hres = pVarEqv(&left, &right, &result);
4915                 if (bFail)
4916                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4917                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4918                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4919                        V_VT(&result));
4920                 else
4921                     ok(hres == S_OK && V_VT(&result) == resvt,
4922                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4923                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4924                        V_VT(&result));
4925             }
4926         }
4927     }
4928
4929     /* Test returned values */
4930     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4931     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4932     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4933     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4934     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4935     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4936     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4937     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4938     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4939     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4940     VAREQV(BOOL,6,I2,7,I2,-2);
4941     VAREQV(UI1,1,UI1,1,UI1,255);
4942     VAREQV(UI1,1,UI1,0,UI1,254);
4943     VAREQV(UI1,0,UI1,1,UI1,254);
4944     if (HAVE_OLEAUT32_I8)
4945     {
4946         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4947         VAREQV(UI4,5,I8,19,I8,-23);
4948         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4949     }
4950 }
4951
4952 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4953
4954 #define VARMUL(vt1,val1,vt2,val2,rvt,rval)               \
4955         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4956         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4957         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4958         test_var_call2( __LINE__, pVarMul, &left, &right, &exp )
4959
4960 static void test_VarMul(void)
4961 {
4962     VARIANT left, right, exp, result, cy, dec;
4963     VARTYPE i;
4964     BSTR lbstr, rbstr;
4965     HRESULT hres;
4966     double r;
4967
4968     CHECKPTR(VarMul);
4969
4970     lbstr = SysAllocString(sz12);
4971     rbstr = SysAllocString(sz12);
4972
4973     /* Test all possible flag/vt combinations & the resulting vt type */
4974     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4975     {
4976         VARTYPE leftvt, rightvt, resvt;
4977
4978         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4979         {
4980
4981             SKIPTESTS(leftvt);
4982
4983             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4984             {
4985                 BOOL bFail = FALSE;
4986
4987                 SKIPTESTS(rightvt);
4988
4989                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4990                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4991                     continue;
4992
4993                 memset(&left, 0, sizeof(left));
4994                 memset(&right, 0, sizeof(right));
4995                 V_VT(&left) = leftvt | ExtraFlags[i];
4996                 if (leftvt == VT_BSTR)
4997                     V_BSTR(&left) = lbstr;
4998                 V_VT(&right) = rightvt | ExtraFlags[i];
4999                 if (rightvt == VT_BSTR)
5000                     V_BSTR(&right) = rbstr;
5001                 V_VT(&result) = VT_EMPTY;
5002                 resvt = VT_UNKNOWN;
5003
5004                 /* Don't ask me why but native VarMul cannot handle:
5005                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5006                    Tested with DCOM98, Win2k, WinXP */
5007                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5008                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5009                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5010                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5011                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5012                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5013                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5014                     leftvt == VT_I1 || rightvt == VT_I1 ||
5015                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5016                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5017                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5018                     leftvt == VT_INT || rightvt == VT_INT ||
5019                     leftvt == VT_UINT || rightvt == VT_UINT) {
5020                     bFail = TRUE;
5021                 }
5022
5023                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5024                     resvt = VT_NULL;
5025                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5026                     resvt = VT_DECIMAL;
5027                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
5028                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
5029                          leftvt == VT_DATE || rightvt == VT_DATE)
5030                     resvt = VT_R8;
5031                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
5032                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5033                         leftvt == VT_I8 || rightvt == VT_I8 ||
5034                         leftvt == VT_CY || rightvt == VT_CY)
5035                         resvt = VT_R8;
5036                     else
5037                         resvt = VT_R4;
5038                 } else if (leftvt == VT_CY || rightvt == VT_CY)
5039                     resvt = VT_CY;
5040                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5041                     resvt = VT_I8;
5042                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5043                     resvt = VT_I4;
5044                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5045                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5046                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5047                     resvt = VT_I2;
5048                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5049                     resvt = VT_UI1;
5050
5051                 hres = pVarMul(&left, &right, &result);
5052                 if (bFail) {
5053                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5054                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5055                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5056                        V_VT(&result));
5057                 } else {
5058                     ok(hres == S_OK && V_VT(&result) == resvt,
5059                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5060                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5061                        V_VT(&result));
5062                 }
5063             }
5064         }
5065     }
5066
5067     /* Test returned values */
5068     VARMUL(I4,4,I4,2,I4,8);
5069     VARMUL(I2,4,I2,2,I2,8);
5070     VARMUL(I2,-13,I4,5,I4,-65);
5071     VARMUL(I4,-13,I4,5,I4,-65);
5072     VARMUL(I2,7,R4,0.5f,R4,3.5f);
5073     VARMUL(R4,0.5f,I4,5,R8,2.5);
5074     VARMUL(R8,7.1,BOOL,0,R8,0);
5075     VARMUL(BSTR,lbstr,I2,4,R8,48);
5076     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
5077     VARMUL(BSTR,lbstr,R4,0.1f,R8,1.2);
5078     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
5079     VARMUL(R4,0.2f,BSTR,rbstr,R8,2.4);
5080     VARMUL(DATE,2.25,I4,7,R8,15.75);
5081
5082     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
5083     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
5084     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
5085     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
5086     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
5087     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
5088     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
5089     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
5090     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
5091     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
5092     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
5093     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
5094
5095     /* Manuly test some VT_CY and VT_DECIMAL variants */
5096     V_VT(&cy) = VT_CY;
5097     hres = VarCyFromI4(4711, &V_CY(&cy));
5098     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5099     V_VT(&dec) = VT_DECIMAL;
5100     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5101     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5102     memset(&left, 0, sizeof(left));
5103     memset(&right, 0, sizeof(right));
5104     V_VT(&left) = VT_I4;
5105     V_I4(&left) = -11;
5106     V_VT(&right) = VT_UI1;
5107     V_UI1(&right) = 9;
5108
5109     hres = VarMul(&cy, &right, &result);
5110     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5111     hres = VarR8FromCy(V_CY(&result), &r);
5112     ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
5113
5114     hres = VarMul(&left, &dec, &result);
5115     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5116     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5117     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
5118
5119     SysFreeString(lbstr);
5120     SysFreeString(rbstr);
5121 }
5122
5123 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
5124
5125 #define VARADD(vt1,val1,vt2,val2,rvt,rval)               \
5126         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5127         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5128         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5129         test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )
5130
5131 static void test_VarAdd(void)
5132 {
5133     VARIANT left, right, exp, result, cy, dec;
5134     VARTYPE i;
5135     BSTR lbstr, rbstr;
5136     HRESULT hres;
5137     double r;
5138
5139     CHECKPTR(VarAdd);
5140
5141     lbstr = SysAllocString(sz12);
5142     rbstr = SysAllocString(sz12);
5143
5144     /* Test all possible flag/vt combinations & the resulting vt type */
5145     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5146     {
5147         VARTYPE leftvt, rightvt, resvt;
5148
5149         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5150         {
5151
5152             SKIPTESTS(leftvt);
5153
5154             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5155             {
5156                 BOOL bFail = FALSE;
5157
5158                 SKIPTESTS(rightvt);
5159
5160                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5161                     continue;
5162
5163                 memset(&left, 0, sizeof(left));
5164                 memset(&right, 0, sizeof(right));
5165                 V_VT(&left) = leftvt | ExtraFlags[i];
5166                 if (leftvt == VT_BSTR)
5167                     V_BSTR(&left) = lbstr;
5168                 V_VT(&right) = rightvt | ExtraFlags[i];
5169                 if (rightvt == VT_BSTR)
5170                     V_BSTR(&right) = rbstr;
5171                 V_VT(&result) = VT_EMPTY;
5172                 resvt = VT_ERROR;
5173
5174                 /* Don't ask me why but native VarAdd cannot handle:
5175                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5176                    Tested with DCOM98, Win2k, WinXP */
5177                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5178                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5179                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5180                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5181                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5182                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5183                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5184                     leftvt == VT_I1 || rightvt == VT_I1 ||
5185                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5186                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5187                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5188                     leftvt == VT_INT || rightvt == VT_INT ||
5189                     leftvt == VT_UINT || rightvt == VT_UINT) {
5190                     bFail = TRUE;
5191                 }
5192
5193                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5194                     resvt = VT_NULL;
5195                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
5196                     bFail = TRUE;
5197                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5198                     resvt = VT_DECIMAL;
5199                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
5200                     resvt = VT_DATE;
5201                 else if (leftvt == VT_CY || rightvt == VT_CY)
5202                     resvt = VT_CY;
5203                 else if (leftvt == VT_R8 || rightvt == VT_R8)
5204                     resvt = VT_R8;
5205                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
5206                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
5207                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5208                         resvt = VT_BSTR;
5209                     else
5210                         resvt = VT_R8;
5211                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
5212                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5213                         leftvt == VT_I8 || rightvt == VT_I8)
5214                         resvt = VT_R8;
5215                     else
5216                         resvt = VT_R4;
5217                 }
5218                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5219                     resvt = VT_I8;
5220                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5221                     resvt = VT_I4;
5222                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5223                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5224                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5225                     resvt = VT_I2;
5226                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5227                     resvt = VT_UI1;
5228
5229                 hres = pVarAdd(&left, &right, &result);
5230                 if (bFail) {
5231                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5232                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5233                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5234                        V_VT(&result));
5235                 } else {
5236                     ok(hres == S_OK && V_VT(&result) == resvt,
5237                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5238                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5239                        V_VT(&result));
5240                 }
5241                 /* Note, we don't clear left/right deliberately here */
5242                 VariantClear(&result);
5243             }
5244         }
5245     }
5246
5247     /* Test returned values */
5248     VARADD(I4,4,I4,2,I4,6);
5249     VARADD(I2,4,I2,2,I2,6);
5250     VARADD(I2,-13,I4,5,I4,-8);
5251     VARADD(I4,-13,I4,5,I4,-8);
5252     VARADD(I2,7,R4,0.5f,R4,7.5f);
5253     VARADD(R4,0.5f,I4,5,R8,5.5);
5254     VARADD(R8,7.1,BOOL,0,R8,7.1);
5255     VARADD(BSTR,lbstr,I2,4,R8,16);
5256     VARADD(BSTR,lbstr,BOOL,1,R8,13);
5257     VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
5258     VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
5259     VARADD(DATE,2.25,I4,7,DATE,9.25);
5260     VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
5261
5262     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
5263     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
5264     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
5265     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
5266     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
5267     VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
5268     VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
5269     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
5270     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
5271     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
5272     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
5273     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
5274
5275     /* Manually test BSTR + BSTR */
5276     V_VT(&left) = VT_BSTR;
5277     V_BSTR(&left) = lbstr;
5278     V_VT(&right) = VT_BSTR;
5279     V_BSTR(&right) = rbstr;
5280     hres = VarAdd(&left, &right, &result);
5281     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
5282     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
5283     ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
5284     VariantClear(&result);
5285
5286     /* Manuly test some VT_CY and VT_DECIMAL variants */
5287     V_VT(&cy) = VT_CY;
5288     hres = VarCyFromI4(4711, &V_CY(&cy));
5289     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5290     V_VT(&dec) = VT_DECIMAL;
5291     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5292     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5293     memset(&left, 0, sizeof(left));
5294     memset(&right, 0, sizeof(right));
5295     V_VT(&left) = VT_I4;
5296     V_I4(&left) = -11;
5297     V_VT(&right) = VT_UI1;
5298     V_UI1(&right) = 9;
5299
5300     hres = VarAdd(&cy, &right, &result);
5301     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5302     hres = VarR8FromCy(V_CY(&result), &r);
5303     ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
5304
5305     hres = VarAdd(&left, &dec, &result);
5306     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5307     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5308     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
5309     VariantClear(&result);
5310
5311     SysFreeString(lbstr);
5312     SysFreeString(rbstr);
5313 }
5314
5315 static void test_VarCat(void)
5316 {
5317     LCID lcid;
5318     VARIANT left, right, result, expected, expected_broken;
5319     static const WCHAR sz34[] = {'3','4','\0'};
5320     static const WCHAR sz1234[] = {'1','2','3','4','\0'};
5321     static const WCHAR date_sz12[] = {'9','/','3','0','/','1','9','8','0','1','2','\0'};
5322     static const WCHAR date_sz12_broken[] = {'9','/','3','0','/','8','0','1','2','\0'};
5323     static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
5324     static const WCHAR sz12_date_broken[] = {'1','2','9','/','3','0','/','8','0','\0'};
5325     static const WCHAR sz_empty[] = {'\0'};
5326     TCHAR orig_date_format[128];
5327     VARTYPE leftvt, rightvt, resultvt;
5328     HRESULT hres;
5329     HRESULT expected_error_num;
5330
5331     /* Set date format for testing */
5332     lcid = LOCALE_USER_DEFAULT;
5333     GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
5334     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
5335
5336     VariantInit(&left);
5337     VariantInit(&right);
5338     VariantInit(&result);
5339     VariantInit(&expected);
5340
5341     /* Check expected types for all combinations */
5342     for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5343     {
5344
5345         SKIPTESTS(leftvt);
5346
5347         /* Check if we need/have support for I8 and/or UI8 */
5348         if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5349             continue;
5350
5351         for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5352         {
5353
5354             SKIPTESTS(rightvt);
5355             expected_error_num = S_OK;
5356             resultvt = VT_EMPTY;
5357
5358             if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5359                 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN  ||
5360                 leftvt == VT_RECORD || rightvt == VT_RECORD  ||
5361                 leftvt == 15 || rightvt == 15 /* Undefined type */)
5362                 continue;
5363
5364             /* Check if we need/have support for I8 and/or UI8 */
5365             if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5366                 continue;
5367
5368             if (leftvt == VT_NULL && rightvt == VT_NULL)
5369                 resultvt = VT_NULL;
5370             else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
5371                 rightvt == VT_DATE || rightvt == VT_DECIMAL))
5372                 expected_error_num = DISP_E_TYPEMISMATCH;
5373             else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
5374                 leftvt == VT_R4 || leftvt == VT_R8 ||
5375                 leftvt == VT_CY || leftvt == VT_BOOL ||
5376                 leftvt == VT_BSTR || leftvt == VT_I1 ||
5377                 leftvt == VT_UI1 || leftvt == VT_UI2 ||
5378                 leftvt == VT_UI4 || leftvt == VT_I8 ||
5379                 leftvt == VT_UI8 || leftvt == VT_INT ||
5380                 leftvt == VT_UINT || leftvt == VT_EMPTY ||
5381                 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
5382                 leftvt == VT_DATE)
5383                 &&
5384                 (rightvt == VT_I2 || rightvt == VT_I4 ||
5385                 rightvt == VT_R4 || rightvt == VT_R8 ||
5386                 rightvt == VT_CY || rightvt == VT_BOOL ||
5387                 rightvt == VT_BSTR || rightvt == VT_I1 ||
5388                 rightvt == VT_UI1 || rightvt == VT_UI2 ||
5389                 rightvt == VT_UI4 || rightvt == VT_I8 ||
5390                 rightvt == VT_UI8 || rightvt == VT_INT ||
5391                 rightvt == VT_UINT || rightvt == VT_EMPTY ||
5392                 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
5393                 rightvt == VT_DATE))
5394                 resultvt = VT_BSTR;
5395             else if (rightvt == VT_ERROR && leftvt < VT_VOID)
5396                 expected_error_num = DISP_E_TYPEMISMATCH;
5397             else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
5398                 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
5399                 expected_error_num = DISP_E_TYPEMISMATCH;
5400             else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
5401                 rightvt == VT_DECIMAL)
5402                 expected_error_num = DISP_E_BADVARTYPE;
5403             else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
5404                 expected_error_num = DISP_E_TYPEMISMATCH;
5405             else if (leftvt == VT_VARIANT)
5406                 expected_error_num = DISP_E_TYPEMISMATCH;
5407             else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
5408                 leftvt == VT_NULL || leftvt ==  VT_I2 ||
5409                 leftvt == VT_I4 || leftvt == VT_R4 ||
5410                 leftvt == VT_R8 || leftvt == VT_CY ||
5411                 leftvt == VT_DATE || leftvt == VT_BSTR ||
5412                 leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
5413                 leftvt == VT_I1 || leftvt == VT_UI1 ||
5414                 leftvt == VT_UI2 || leftvt == VT_UI4 ||
5415                 leftvt == VT_I8 || leftvt == VT_UI8 ||
5416                 leftvt == VT_INT || leftvt == VT_UINT
5417                 ))
5418                 expected_error_num = DISP_E_TYPEMISMATCH;
5419             else
5420                 expected_error_num = DISP_E_BADVARTYPE;
5421
5422             V_VT(&left) = leftvt;
5423             V_VT(&right) = rightvt;
5424
5425             switch (leftvt) {
5426             case VT_BSTR:
5427                 V_BSTR(&left) = SysAllocString(sz_empty); break;
5428             case VT_DATE:
5429                 V_DATE(&left) = 0.0; break;
5430             case VT_DECIMAL:
5431                 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
5432             default:
5433                 V_I8(&left) = 0;
5434             }
5435
5436             switch (rightvt) {
5437             case VT_BSTR:
5438                 V_BSTR(&right) = SysAllocString(sz_empty); break;
5439             case VT_DATE:
5440                 V_DATE(&right) = 0.0; break;
5441             case VT_DECIMAL:
5442                 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
5443             default:
5444                 V_I8(&right) = 0;
5445             }
5446
5447             hres = VarCat(&left, &right, &result);
5448
5449             /* Determine the error code for the vt combination */
5450             ok(hres == expected_error_num,
5451                 "VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
5452                 leftvt, rightvt, expected_error_num, hres);
5453
5454             /* Check types are correct */
5455             ok(V_VT(&result) == resultvt,
5456                 "VarCat: %d, %d: expected vt %d, got vt %d\n",
5457                 leftvt, rightvt, resultvt, V_VT(&result));
5458
5459             VariantClear(&left);
5460             VariantClear(&right);
5461             VariantClear(&result);
5462         }
5463     }
5464
5465     /* Running single comparison tests to compare outputs */
5466
5467     /* Test concat strings */
5468     V_VT(&left) = VT_BSTR;
5469     V_VT(&right) = VT_BSTR;
5470     V_VT(&expected) = VT_BSTR;
5471     V_BSTR(&left) = SysAllocString(sz12);
5472     V_BSTR(&right) = SysAllocString(sz34);
5473     V_BSTR(&expected) = SysAllocString(sz1234);
5474     hres = VarCat(&left,&right,&result);
5475     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5476     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5477         "VarCat: VT_BSTR concat with VT_BSTR failed to return correct result\n");
5478
5479     VariantClear(&left);
5480     VariantClear(&right);
5481     VariantClear(&result);
5482
5483     /* Test if expression is VT_ERROR */
5484     V_VT(&left) = VT_ERROR;
5485     V_VT(&right) = VT_BSTR;
5486     V_BSTR(&right) = SysAllocString(sz1234);
5487     hres = VarCat(&left,&right,&result);
5488     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5489     ok(V_VT(&result) == VT_EMPTY,
5490         "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
5491
5492     VariantClear(&left);
5493     VariantClear(&right);
5494     VariantClear(&result);
5495
5496     V_VT(&left) = VT_BSTR;
5497     V_VT(&right) = VT_ERROR;
5498     V_BSTR(&left) = SysAllocString(sz1234);
5499     hres = VarCat(&left,&right,&result);
5500     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5501     ok(V_VT(&result) == VT_EMPTY,
5502         "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
5503
5504     VariantClear(&left);
5505     VariantClear(&right);
5506     VariantClear(&result);
5507     VariantClear(&expected);
5508
5509     /* Test combining boolean with number */
5510     V_VT(&left) = VT_INT;
5511     V_VT(&right) = VT_BOOL;
5512     V_VT(&expected) = VT_BSTR;
5513     V_INT(&left) = 12;
5514     V_BOOL(&right) = TRUE;
5515     V_BSTR(&expected) = SysAllocString(sz12_true);
5516     hres = VarCat(&left,&right,&result);
5517     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5518     hres = VarCmp(&result,&expected,lcid,0);
5519     ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5520         hres, variantstr(&result), variantstr(&expected));
5521
5522     VariantClear(&left);
5523     VariantClear(&right);
5524     VariantClear(&result);
5525     VariantClear(&expected);
5526
5527     V_VT(&left) = VT_INT;
5528     V_VT(&right) = VT_BOOL;
5529     V_VT(&expected) = VT_BSTR;
5530     V_INT(&left) = 12;
5531     V_BOOL(&right) = FALSE;
5532     V_BSTR(&expected) = SysAllocString(sz12_false);
5533     hres = VarCat(&left,&right,&result);
5534     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5535     hres = VarCmp(&result,&expected,lcid,0);
5536     ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5537         hres, variantstr(&result), variantstr(&expected));
5538
5539     VariantClear(&left);
5540     VariantClear(&right);
5541     VariantClear(&result);
5542     VariantClear(&expected);
5543
5544     /* Test when both expressions are numeric */
5545     V_VT(&left) = VT_INT;
5546     V_VT(&right) = VT_INT;
5547     V_VT(&expected) = VT_BSTR;
5548     V_INT(&left)  = 12;
5549     V_INT(&right) = 34;
5550     V_BSTR(&expected) = SysAllocString(sz1234);
5551     hres = VarCat(&left,&right,&result);
5552     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5553     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5554         "VarCat: NUMBER concat with NUMBER returned incorrect result\n");
5555
5556     VariantClear(&left);
5557     VariantClear(&right);
5558     VariantClear(&result);
5559
5560     /* Test if one expression is numeric and the other is a string */
5561     V_VT(&left) = VT_INT;
5562     V_VT(&right) = VT_BSTR;
5563     V_INT(&left) = 12;
5564     V_BSTR(&right) = SysAllocString(sz34);
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 VT_BSTR, incorrect result\n");
5569
5570     VariantClear(&left);
5571     VariantClear(&right);
5572     VariantClear(&result);
5573
5574     V_VT(&left) = VT_BSTR;
5575     V_VT(&right) = VT_INT;
5576     V_BSTR(&left) = SysAllocString(sz12);
5577     V_INT(&right) = 34;
5578     hres = VarCat(&left,&right,&result);
5579     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5580     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5581         "VarCat: VT_BSTR concat with NUMBER, incorrect result\n");
5582
5583     VariantClear(&left);
5584     VariantClear(&right);
5585     VariantClear(&result);
5586     VariantClear(&expected);
5587
5588     /* Test concat dates with strings */
5589     V_VT(&left) = VT_BSTR;
5590     V_VT(&right) = VT_DATE;
5591     V_VT(&expected) = VT_BSTR;
5592     V_VT(&expected_broken) = VT_BSTR;
5593     V_BSTR(&left) = SysAllocString(sz12);
5594     V_DATE(&right) = 29494.0;
5595     V_BSTR(&expected)= SysAllocString(sz12_date);
5596     V_BSTR(&expected_broken)= SysAllocString(sz12_date_broken);
5597     hres = VarCat(&left,&right,&result);
5598     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5599     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5600         broken(VarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5601         "VarCat: VT_BSTR concat with VT_DATE returned incorrect result\n");
5602
5603     VariantClear(&left);
5604     VariantClear(&right);
5605     VariantClear(&result);
5606     VariantClear(&expected);
5607     VariantClear(&expected_broken);
5608
5609     V_VT(&left) = VT_DATE;
5610     V_VT(&right) = VT_BSTR;
5611     V_VT(&expected) = VT_BSTR;
5612     V_VT(&expected_broken) = VT_BSTR;
5613     V_DATE(&left) = 29494.0;
5614     V_BSTR(&right) = SysAllocString(sz12);
5615     V_BSTR(&expected)= SysAllocString(date_sz12);
5616     V_BSTR(&expected_broken)= SysAllocString(date_sz12_broken);
5617     hres = VarCat(&left,&right,&result);
5618     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5619     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5620         broken(VarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5621         "VarCat: VT_DATE concat with VT_BSTR returned incorrect result\n");
5622
5623     VariantClear(&left);
5624     VariantClear(&right);
5625     VariantClear(&result);
5626     VariantClear(&expected);
5627     VariantClear(&expected_broken);
5628
5629     /* Test of both expressions are empty */
5630     V_VT(&left) = VT_BSTR;
5631     V_VT(&right) = VT_BSTR;
5632     V_VT(&expected) = VT_BSTR;
5633     V_BSTR(&left) = SysAllocString(sz_empty);
5634     V_BSTR(&right) = SysAllocString(sz_empty);
5635     V_BSTR(&expected)= SysAllocString(sz_empty);
5636     hres = VarCat(&left,&right,&result);
5637     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5638     ok(VarCmp(&result,&left,lcid,0) == VARCMP_EQ,
5639         "VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
5640
5641     /* Restore original date format settings */
5642     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
5643
5644     VariantClear(&left);
5645     VariantClear(&right);
5646     VariantClear(&result);
5647     VariantClear(&expected);
5648 }
5649
5650 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
5651
5652 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
5653         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5654         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5655         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5656         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5657
5658 #define VARANDCY(vt1,val1,val2,rvt,rval)                 \
5659         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5660         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5661         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5662         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5663
5664 /* Skip any type that is not defined or produces an error for every case */
5665 #define SKIPTESTAND(a)                                \
5666         if (a == VT_ERROR || a == VT_VARIANT ||       \
5667             a == VT_DISPATCH || a == VT_UNKNOWN ||    \
5668             a > VT_UINT || a == 15 /*not defined*/)   \
5669             continue
5670
5671 static void test_VarAnd(void)
5672 {
5673     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5674     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5675     VARIANT left, right, exp, result;
5676     BSTR false_str, true_str;
5677     VARTYPE i;
5678     HRESULT hres;
5679
5680     true_str = SysAllocString(szTrue);
5681     false_str = SysAllocString(szFalse);
5682
5683     CHECKPTR(VarAnd);
5684
5685     /* Test all possible flag/vt combinations & the resulting vt type */
5686     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5687     {
5688         VARTYPE leftvt, rightvt, resvt;
5689
5690         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5691         {
5692             SKIPTESTAND(leftvt);
5693
5694             /* Check if we need/have support for I8 and/or UI8 */
5695             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5696                 continue;
5697
5698             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5699             {
5700                 BOOL bFail = FALSE;
5701                 SKIPTESTAND(rightvt);
5702
5703                 /* Check if we need/have support for I8 and/or UI8 */
5704                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5705                     continue;
5706
5707                 memset(&left, 0, sizeof(left));
5708                 memset(&right, 0, sizeof(right));
5709                 V_VT(&left) = leftvt | ExtraFlags[i];
5710                 V_VT(&right) = rightvt | ExtraFlags[i];
5711                 V_VT(&result) = VT_EMPTY;
5712                 resvt = VT_EMPTY;
5713                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
5714                     V_BSTR(&left) = true_str;
5715                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
5716                     V_BSTR(&right) = true_str;
5717
5718                 /* Native VarAnd always returns an error when using extra
5719                  * flags or if the variant combination is I8 and INT.
5720                  */
5721                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5722                     (leftvt == VT_INT && rightvt == VT_I8) ||
5723                     ExtraFlags[i] != 0)
5724                     bFail = TRUE;
5725
5726                 /* Determine return type */
5727                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5728                     resvt = VT_I8;
5729                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5730                     leftvt == VT_UINT || rightvt == VT_UINT ||
5731                     leftvt == VT_INT || rightvt == VT_INT ||
5732                     leftvt == VT_UINT || rightvt == VT_UINT ||
5733                     leftvt == VT_R4 || rightvt == VT_R4 ||
5734                     leftvt == VT_R8 || rightvt == VT_R8 ||
5735                     leftvt == VT_CY || rightvt == VT_CY ||
5736                     leftvt == VT_DATE || rightvt == VT_DATE ||
5737                     leftvt == VT_I1 || rightvt == VT_I1 ||
5738                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5739                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5740                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5741                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5742                     resvt = VT_I4;
5743                 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
5744                     leftvt == VT_I2 || rightvt == VT_I2 ||
5745                     leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5746                     if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
5747                         (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5748                         (leftvt == VT_UI1 && rightvt == VT_UI1))
5749                         resvt = VT_UI1;
5750                     else
5751                         resvt = VT_I2;
5752                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5753                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
5754                     resvt = VT_BOOL;
5755                 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
5756                     leftvt == VT_BSTR || rightvt == VT_BSTR)
5757                     resvt = VT_NULL;
5758                 else
5759                     bFail = TRUE;
5760
5761                 hres = pVarAnd(&left, &right, &result);
5762
5763                 /* Check expected HRESULT and if result variant type is correct */
5764                 if (bFail)
5765                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
5766                         "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
5767                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
5768                         vtstr(V_VT(&result)), hres);
5769                 else
5770                     ok (hres == S_OK && resvt == V_VT(&result),
5771                         "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
5772                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
5773                         S_OK, vtstr(V_VT(&result)), hres);
5774             }
5775         }
5776     }
5777
5778     /*
5779      * Test returned values. Since we know the returned type is correct
5780      * and that we handle all combinations of invalid types, just check
5781      * that good type combinations produce the desired value.
5782      * FIXME: Test VT_DECIMAL
5783      */
5784     VARAND(EMPTY,0,EMPTY,0,I2,0);
5785     VARAND(EMPTY,1,EMPTY,0,I2,0);
5786     VARAND(EMPTY,1,EMPTY,1,I2,0);
5787     VARAND(EMPTY,0,NULL,0,I2,0);
5788     VARAND(EMPTY,1,NULL,0,I2,0);
5789     VARAND(EMPTY,1,NULL,1,I2,0);
5790     VARAND(EMPTY,0,I1,0,I4,0);
5791     VARAND(EMPTY,0,I1,1,I4,0);
5792     VARAND(EMPTY,1,I1,1,I4,0);
5793     VARAND(EMPTY,0,UI1,0,I2,0);
5794     VARAND(EMPTY,0,UI1,1,I2,0);
5795     VARAND(EMPTY,1,UI1,1,I2,0);
5796     VARAND(EMPTY,0,I2,0,I2,0);
5797     VARAND(EMPTY,0,I2,1,I2,0);
5798     VARAND(EMPTY,1,I2,1,I2,0);
5799     VARAND(EMPTY,0,UI2,0,I4,0);
5800     VARAND(EMPTY,0,UI2,1,I4,0);
5801     VARAND(EMPTY,1,UI2,1,I4,0);
5802     VARAND(EMPTY,0,I4,0,I4,0);
5803     VARAND(EMPTY,0,I4,1,I4,0);
5804     VARAND(EMPTY,1,I4,1,I4,0);
5805     VARAND(EMPTY,0,UI4,0,I4,0);
5806     VARAND(EMPTY,0,UI4,1,I4,0);
5807     VARAND(EMPTY,1,UI4,1,I4,0);
5808     if (HAVE_OLEAUT32_I8)
5809     {
5810         VARAND(EMPTY,0,I8,0,I8,0);
5811         VARAND(EMPTY,0,I8,1,I8,0);
5812         VARAND(EMPTY,1,I8,1,I8,0);
5813         VARAND(EMPTY,0,UI8,0,I4,0);
5814         VARAND(EMPTY,0,UI8,1,I4,0);
5815         VARAND(EMPTY,1,UI8,1,I4,0);
5816     }
5817     VARAND(EMPTY,0,INT,0,I4,0);
5818     VARAND(EMPTY,0,INT,1,I4,0);
5819     VARAND(EMPTY,1,INT,1,I4,0);
5820     VARAND(EMPTY,0,UINT,0,I4,0);
5821     VARAND(EMPTY,0,UINT,1,I4,0);
5822     VARAND(EMPTY,1,UINT,1,I4,0);
5823     VARAND(EMPTY,0,BOOL,0,I2,0);
5824     VARAND(EMPTY,0,BOOL,1,I2,0);
5825     VARAND(EMPTY,1,BOOL,1,I2,0);
5826     VARAND(EMPTY,0,R4,0,I4,0);
5827     VARAND(EMPTY,0,R4,1,I4,0);
5828     VARAND(EMPTY,1,R4,1,I4,0);
5829     VARAND(EMPTY,0,R8,0,I4,0);
5830     VARAND(EMPTY,0,R8,1,I4,0);
5831     VARAND(EMPTY,1,R8,1,I4,0);
5832     VARAND(EMPTY,0,BSTR,false_str,I2,0);
5833     VARAND(EMPTY,0,BSTR,true_str,I2,0);
5834     VARANDCY(EMPTY,0,10000,I4,0);
5835
5836     /* NULL OR 0 = NULL. NULL OR n = n */
5837     VARAND(NULL,0,NULL,0,NULL,0);
5838     VARAND(NULL,1,NULL,0,NULL,0);
5839     VARAND(NULL,0,I1,0,I4,0);
5840     VARAND(NULL,0,I1,1,NULL,0);
5841     VARAND(NULL,0,UI1,0,UI1,0);
5842     VARAND(NULL,0,UI1,1,NULL,0);
5843     VARAND(NULL,0,I2,0,I2,0);
5844     VARAND(NULL,0,I2,1,NULL,0);
5845     VARAND(NULL,0,UI2,0,I4,0);
5846     VARAND(NULL,0,UI2,1,NULL,0);
5847     VARAND(NULL,0,I4,0,I4,0);
5848     VARAND(NULL,0,I4,1,NULL,0);
5849     VARAND(NULL,0,UI4,0,I4,0);
5850     VARAND(NULL,0,UI4,1,NULL,0);
5851     if (HAVE_OLEAUT32_I8)
5852     {
5853         VARAND(NULL,0,I8,0,I8,0);
5854         VARAND(NULL,0,I8,1,NULL,0);
5855         VARAND(NULL,0,UI8,0,I4,0);
5856         VARAND(NULL,0,UI8,1,NULL,0);
5857     }
5858     VARAND(NULL,0,INT,0,I4,0);
5859     VARAND(NULL,0,INT,1,NULL,0);
5860     VARAND(NULL,0,UINT,0,I4,0);
5861     VARAND(NULL,0,UINT,1,NULL,0);
5862     VARAND(NULL,0,BOOL,0,BOOL,0);
5863     VARAND(NULL,0,BOOL,1,NULL,0);
5864     VARAND(NULL,0,R4,0,I4,0);
5865     VARAND(NULL,0,R4,1,NULL,0);
5866     VARAND(NULL,0,R8,0,I4,0);
5867     VARAND(NULL,0,R8,1,NULL,0);
5868     VARAND(NULL,0,BSTR,false_str,BOOL,0);
5869     VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
5870     VARANDCY(NULL,0,10000,NULL,0);
5871     VARANDCY(NULL,0,0,I4,0);
5872     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5873     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5874     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
5875     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5876
5877     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5878     VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5879     VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
5880     VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
5881     VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
5882     VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
5883     VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5884     VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5885     VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
5886     VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
5887     VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
5888     VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
5889     VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5890     VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5891     VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
5892     VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
5893     VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5894     VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
5895     VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5896     VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5897     VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
5898     VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
5899     VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5900     VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
5901     VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
5902     VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5903     VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
5904     VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5905     if (HAVE_OLEAUT32_I8)
5906     {
5907         VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5908         VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
5909         VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
5910         VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
5911         VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5912     }
5913     VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5914     VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
5915     VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
5916     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5917     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
5918     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5919     VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
5920     VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
5921     VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
5922     VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
5923     VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
5924     VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
5925     VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
5926     VARAND(I1,-1,I1,-1,I4,-1);
5927     VARAND(I1,-1,I1,0,I4,0);
5928     VARAND(I1,0,I1,0,I4,0);
5929     VARAND(I1,-1,UI1,255,I4,255);
5930     VARAND(I1,-1,UI1,0,I4,0);
5931     VARAND(I1,0,UI1,0,I4,0);
5932     VARAND(I1,-1,I2,-1,I4,-1);
5933     VARAND(I1,-1,I2,0,I4,0);
5934     VARAND(I1,0,I2,0,I4,0);
5935     VARAND(I1,-1,UI2,65535,I4,65535);
5936     VARAND(I1,-1,UI2,0,I4,0);
5937     VARAND(I1,0,UI2,0,I4,0);
5938     VARAND(I1,-1,I4,-1,I4,-1);
5939     VARAND(I1,-1,I4,0,I4,0);
5940     VARAND(I1,0,I4,0,I4,0);
5941     VARAND(I1,-1,UI4,0xffffffff,I4,-1);
5942     VARAND(I1,-1,UI4,0,I4,0);
5943     VARAND(I1,0,UI4,0,I4,0);
5944     VARAND(I1,-1,R4,-1,I4,-1);
5945     VARAND(I1,-1,R4,0,I4,0);
5946     VARAND(I1,0,R4,0,I4,0);
5947     VARAND(I1,-1,R8,-1,I4,-1);
5948     VARAND(I1,-1,R8,0,I4,0);
5949     VARAND(I1,0,R8,0,I4,0);
5950     VARAND(I1,-1,DATE,-1,I4,-1);
5951     VARAND(I1,-1,DATE,0,I4,0);
5952     VARAND(I1,0,DATE,0,I4,0);
5953     if (HAVE_OLEAUT32_I8)
5954     {
5955         VARAND(I1,-1,I8,-1,I8,-1);
5956         VARAND(I1,-1,I8,0,I8,0);
5957         VARAND(I1,0,I8,0,I8,0);
5958         VARAND(I1,-1,UI8,0,I4,0);
5959         VARAND(I1,0,UI8,0,I4,0);
5960     }
5961     VARAND(I1,-1,INT,-1,I4,-1);
5962     VARAND(I1,-1,INT,0,I4,0);
5963     VARAND(I1,0,INT,0,I4,0);
5964     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
5965     VARAND(I1,-1,UINT,0,I4,0);
5966     VARAND(I1,0,UINT,0,I4,0);
5967     VARAND(I1,0,BSTR,false_str,I4,0);
5968     VARAND(I1,-1,BSTR,false_str,I4,0);
5969     VARAND(I1,0,BSTR,true_str,I4,0);
5970     VARAND(I1,-1,BSTR,true_str,I4,-1);
5971     VARANDCY(I1,-1,10000,I4,1);
5972     VARANDCY(I1,-1,0,I4,0);
5973     VARANDCY(I1,0,0,I4,0);
5974
5975     VARAND(UI1,255,UI1,255,UI1,255);
5976     VARAND(UI1,255,UI1,0,UI1,0);
5977     VARAND(UI1,0,UI1,0,UI1,0);
5978     VARAND(UI1,255,I2,-1,I2,255);
5979     VARAND(UI1,255,I2,0,I2,0);
5980     VARAND(UI1,0,I2,0,I2,0);
5981     VARAND(UI1,255,UI2,65535,I4,255);
5982     VARAND(UI1,255,UI2,0,I4,0);
5983     VARAND(UI1,0,UI2,0,I4,0);
5984     VARAND(UI1,255,I4,-1,I4,255);
5985     VARAND(UI1,255,I4,0,I4,0);
5986     VARAND(UI1,0,I4,0,I4,0);
5987     VARAND(UI1,255,UI4,0xffffffff,I4,255);
5988     VARAND(UI1,255,UI4,0,I4,0);
5989     VARAND(UI1,0,UI4,0,I4,0);
5990     VARAND(UI1,255,R4,-1,I4,255);
5991     VARAND(UI1,255,R4,0,I4,0);
5992     VARAND(UI1,0,R4,0,I4,0);
5993     VARAND(UI1,255,R8,-1,I4,255);
5994     VARAND(UI1,255,R8,0,I4,0);
5995     VARAND(UI1,0,R8,0,I4,0);
5996     VARAND(UI1,255,DATE,-1,I4,255);
5997     VARAND(UI1,255,DATE,0,I4,0);
5998     VARAND(UI1,0,DATE,0,I4,0);
5999     if (HAVE_OLEAUT32_I8)
6000     {
6001         VARAND(UI1,255,I8,-1,I8,255);
6002         VARAND(UI1,255,I8,0,I8,0);
6003         VARAND(UI1,0,I8,0,I8,0);
6004         VARAND(UI1,255,UI8,0,I4,0);
6005         VARAND(UI1,0,UI8,0,I4,0);
6006     }
6007     VARAND(UI1,255,INT,-1,I4,255);
6008     VARAND(UI1,255,INT,0,I4,0);
6009     VARAND(UI1,0,INT,0,I4,0);
6010     VARAND(UI1,255,UINT,0xffffffff,I4,255);
6011     VARAND(UI1,255,UINT,0,I4,0);
6012     VARAND(UI1,0,UINT,0,I4,0);
6013     VARAND(UI1,0,BSTR,false_str,I2,0);
6014     VARAND(UI1,255,BSTR,false_str,I2,0);
6015     VARAND(UI1,0,BSTR,true_str,I2,0);
6016     VARAND(UI1,255,BSTR,true_str,I2,255);
6017     VARANDCY(UI1,255,10000,I4,1);
6018     VARANDCY(UI1,255,0,I4,0);
6019     VARANDCY(UI1,0,0,I4,0);
6020
6021     VARAND(I2,-1,I2,-1,I2,-1);
6022     VARAND(I2,-1,I2,0,I2,0);
6023     VARAND(I2,0,I2,0,I2,0);
6024     VARAND(I2,-1,UI2,65535,I4,65535);
6025     VARAND(I2,-1,UI2,0,I4,0);
6026     VARAND(I2,0,UI2,0,I4,0);
6027     VARAND(I2,-1,I4,-1,I4,-1);
6028     VARAND(I2,-1,I4,0,I4,0);
6029     VARAND(I2,0,I4,0,I4,0);
6030     VARAND(I2,-1,UI4,0xffffffff,I4,-1);
6031     VARAND(I2,-1,UI4,0,I4,0);
6032     VARAND(I2,0,UI4,0,I4,0);
6033     VARAND(I2,-1,R4,-1,I4,-1);
6034     VARAND(I2,-1,R4,0,I4,0);
6035     VARAND(I2,0,R4,0,I4,0);
6036     VARAND(I2,-1,R8,-1,I4,-1);
6037     VARAND(I2,-1,R8,0,I4,0);
6038     VARAND(I2,0,R8,0,I4,0);
6039     VARAND(I2,-1,DATE,-1,I4,-1);
6040     VARAND(I2,-1,DATE,0,I4,0);
6041     VARAND(I2,0,DATE,0,I4,0);
6042     if (HAVE_OLEAUT32_I8)
6043     {
6044         VARAND(I2,-1,I8,-1,I8,-1);
6045         VARAND(I2,-1,I8,0,I8,0);
6046         VARAND(I2,0,I8,0,I8,0);
6047         VARAND(I2,-1,UI8,0,I4,0);
6048         VARAND(I2,0,UI8,0,I4,0);
6049     }
6050     VARAND(I2,-1,INT,-1,I4,-1);
6051     VARAND(I2,-1,INT,0,I4,0);
6052     VARAND(I2,0,INT,0,I4,0);
6053     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
6054     VARAND(I2,-1,UINT,0,I4,0);
6055     VARAND(I2,0,UINT,0,I4,0);
6056     VARAND(I2,0,BSTR,false_str,I2,0);
6057     VARAND(I2,-1,BSTR,false_str,I2,0);
6058     VARAND(I2,0,BSTR,true_str,I2,0);
6059     VARAND(I2,-1,BSTR,true_str,I2,-1);
6060     VARANDCY(I2,-1,10000,I4,1);
6061     VARANDCY(I2,-1,0,I4,0);
6062     VARANDCY(I2,0,0,I4,0);
6063
6064     VARAND(UI2,65535,UI2,65535,I4,65535);
6065     VARAND(UI2,65535,UI2,0,I4,0);
6066     VARAND(UI2,0,UI2,0,I4,0);
6067     VARAND(UI2,65535,I4,-1,I4,65535);
6068     VARAND(UI2,65535,I4,0,I4,0);
6069     VARAND(UI2,0,I4,0,I4,0);
6070     VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
6071     VARAND(UI2,65535,UI4,0,I4,0);
6072     VARAND(UI2,0,UI4,0,I4,0);
6073     VARAND(UI2,65535,R4,-1,I4,65535);
6074     VARAND(UI2,65535,R4,0,I4,0);
6075     VARAND(UI2,0,R4,0,I4,0);
6076     VARAND(UI2,65535,R8,-1,I4,65535);
6077     VARAND(UI2,65535,R8,0,I4,0);
6078     VARAND(UI2,0,R8,0,I4,0);
6079     VARAND(UI2,65535,DATE,-1,I4,65535);
6080     VARAND(UI2,65535,DATE,0,I4,0);
6081     VARAND(UI2,0,DATE,0,I4,0);
6082     if (HAVE_OLEAUT32_I8)
6083     {
6084         VARAND(UI2,65535,I8,-1,I8,65535);
6085         VARAND(UI2,65535,I8,0,I8,0);
6086         VARAND(UI2,0,I8,0,I8,0);
6087         VARAND(UI2,65535,UI8,0,I4,0);
6088         VARAND(UI2,0,UI8,0,I4,0);
6089     }
6090     VARAND(UI2,65535,INT,-1,I4,65535);
6091     VARAND(UI2,65535,INT,0,I4,0);
6092     VARAND(UI2,0,INT,0,I4,0);
6093     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
6094     VARAND(UI2,65535,UINT,0,I4,0);
6095     VARAND(UI2,0,UINT,0,I4,0);
6096     VARAND(UI2,0,BSTR,false_str,I4,0);
6097     VARAND(UI2,65535,BSTR,false_str,I4,0);
6098     VARAND(UI2,0,BSTR,true_str,I4,0);
6099     VARAND(UI2,65535,BSTR,true_str,I4,65535);
6100     VARANDCY(UI2,65535,10000,I4,1);
6101     VARANDCY(UI2,65535,0,I4,0);
6102     VARANDCY(UI2,0,0,I4,0);
6103
6104     VARAND(I4,-1,I4,-1,I4,-1);
6105     VARAND(I4,-1,I4,0,I4,0);
6106     VARAND(I4,0,I4,0,I4,0);
6107     VARAND(I4,-1,UI4,0xffffffff,I4,-1);
6108     VARAND(I4,-1,UI4,0,I4,0);
6109     VARAND(I4,0,UI4,0,I4,0);
6110     VARAND(I4,-1,R4,-1,I4,-1);
6111     VARAND(I4,-1,R4,0,I4,0);
6112     VARAND(I4,0,R4,0,I4,0);
6113     VARAND(I4,-1,R8,-1,I4,-1);
6114     VARAND(I4,-1,R8,0,I4,0);
6115     VARAND(I4,0,R8,0,I4,0);
6116     VARAND(I4,-1,DATE,-1,I4,-1);
6117     VARAND(I4,-1,DATE,0,I4,0);
6118     VARAND(I4,0,DATE,0,I4,0);
6119     if (HAVE_OLEAUT32_I8)
6120     {
6121         VARAND(I4,-1,I8,-1,I8,-1);
6122         VARAND(I4,-1,I8,0,I8,0);
6123         VARAND(I4,0,I8,0,I8,0);
6124         VARAND(I4,-1,UI8,0,I4,0);
6125         VARAND(I4,0,UI8,0,I4,0);
6126     }
6127     VARAND(I4,-1,INT,-1,I4,-1);
6128     VARAND(I4,-1,INT,0,I4,0);
6129     VARAND(I4,0,INT,0,I4,0);
6130     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
6131     VARAND(I4,-1,UINT,0,I4,0);
6132     VARAND(I4,0,UINT,0,I4,0);
6133     VARAND(I4,0,BSTR,false_str,I4,0);
6134     VARAND(I4,-1,BSTR,false_str,I4,0);
6135     VARAND(I4,0,BSTR,true_str,I4,0);
6136     VARAND(I4,-1,BSTR,true_str,I4,-1);
6137     VARANDCY(I4,-1,10000,I4,1);
6138     VARANDCY(I4,-1,0,I4,0);
6139     VARANDCY(I4,0,0,I4,0);
6140
6141     VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
6142     VARAND(UI4,0xffffffff,UI4,0,I4,0);
6143     VARAND(UI4,0,UI4,0,I4,0);
6144     VARAND(UI4,0xffffffff,R4,-1,I4,-1);
6145     VARAND(UI4,0xffffffff,R4,0,I4,0);
6146     VARAND(UI4,0,R4,0,I4,0);
6147     VARAND(UI4,0xffffffff,R8,-1,I4,-1);
6148     VARAND(UI4,0xffffffff,R8,0,I4,0);
6149     VARAND(UI4,0,R8,0,I4,0);
6150     VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
6151     VARAND(UI4,0xffffffff,DATE,0,I4,0);
6152     VARAND(UI4,0,DATE,0,I4,0);
6153     if (HAVE_OLEAUT32_I8)
6154     {
6155         VARAND(UI4,0xffffffff,I8,0,I8,0);
6156         VARAND(UI4,0,I8,0,I8,0);
6157         VARAND(UI4,0xffffffff,UI8,0,I4,0);
6158         VARAND(UI4,0,UI8,0,I4,0);
6159     }
6160     VARAND(UI4,0xffffffff,INT,-1,I4,-1);
6161     VARAND(UI4,0xffffffff,INT,0,I4,0);
6162     VARAND(UI4,0,INT,0,I4,0);
6163     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
6164     VARAND(UI4,0xffffffff,UINT,0,I4,0);
6165     VARAND(UI4,0,UINT,0,I4,0);
6166     VARAND(UI4,0,BSTR,false_str,I4,0);
6167     VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
6168     VARAND(UI4,0,BSTR,true_str,I4,0);
6169     VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
6170     VARANDCY(UI4,0xffffffff,10000,I4,1);
6171     VARANDCY(UI4,0xffffffff,0,I4,0);
6172     VARANDCY(UI4,0,0,I4,0);
6173
6174     VARAND(R4,-1,R4,-1,I4,-1);
6175     VARAND(R4,-1,R4,0,I4,0);
6176     VARAND(R4,0,R4,0,I4,0);
6177     VARAND(R4,-1,R8,-1,I4,-1);
6178     VARAND(R4,-1,R8,0,I4,0);
6179     VARAND(R4,0,R8,0,I4,0);
6180     VARAND(R4,-1,DATE,-1,I4,-1);
6181     VARAND(R4,-1,DATE,0,I4,0);
6182     VARAND(R4,0,DATE,0,I4,0);
6183     if (HAVE_OLEAUT32_I8)
6184     {
6185         VARAND(R4,-1,I8,-1,I8,-1);
6186         VARAND(R4,-1,I8,0,I8,0);
6187         VARAND(R4,0,I8,0,I8,0);
6188         VARAND(R4,-1,UI8,0,I4,0);
6189         VARAND(R4,0,UI8,0,I4,0);
6190     }
6191     VARAND(R4,-1,INT,-1,I4,-1);
6192     VARAND(R4,-1,INT,0,I4,0);
6193     VARAND(R4,0,INT,0,I4,0);
6194     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
6195     VARAND(R4,-1,UINT,0,I4,0);
6196     VARAND(R4,0,UINT,0,I4,0);
6197     VARAND(R4,0,BSTR,false_str,I4,0);
6198     VARAND(R4,-1,BSTR,false_str,I4,0);
6199     VARAND(R4,0,BSTR,true_str,I4,0);
6200     VARAND(R4,-1,BSTR,true_str,I4,-1);
6201     VARANDCY(R4,-1,10000,I4,1);
6202     VARANDCY(R4,-1,0,I4,0);
6203     VARANDCY(R4,0,0,I4,0);
6204
6205     VARAND(R8,-1,R8,-1,I4,-1);
6206     VARAND(R8,-1,R8,0,I4,0);
6207     VARAND(R8,0,R8,0,I4,0);
6208     VARAND(R8,-1,DATE,-1,I4,-1);
6209     VARAND(R8,-1,DATE,0,I4,0);
6210     VARAND(R8,0,DATE,0,I4,0);
6211     if (HAVE_OLEAUT32_I8)
6212     {
6213         VARAND(R8,-1,I8,-1,I8,-1);
6214         VARAND(R8,-1,I8,0,I8,0);
6215         VARAND(R8,0,I8,0,I8,0);
6216         VARAND(R8,-1,UI8,0,I4,0);
6217         VARAND(R8,0,UI8,0,I4,0);
6218     }
6219     VARAND(R8,-1,INT,-1,I4,-1);
6220     VARAND(R8,-1,INT,0,I4,0);
6221     VARAND(R8,0,INT,0,I4,0);
6222     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
6223     VARAND(R8,-1,UINT,0,I4,0);
6224     VARAND(R8,0,UINT,0,I4,0);
6225     VARAND(R8,0,BSTR,false_str,I4,0);
6226     VARAND(R8,-1,BSTR,false_str,I4,0);
6227     VARAND(R8,0,BSTR,true_str,I4,0);
6228     VARAND(R8,-1,BSTR,true_str,I4,-1);
6229     VARANDCY(R8,-1,10000,I4,1);
6230     VARANDCY(R8,-1,0,I4,0);
6231     VARANDCY(R8,0,0,I4,0);
6232
6233     VARAND(DATE,-1,DATE,-1,I4,-1);
6234     VARAND(DATE,-1,DATE,0,I4,0);
6235     VARAND(DATE,0,DATE,0,I4,0);
6236     if (HAVE_OLEAUT32_I8)
6237     {
6238         VARAND(DATE,-1,I8,-1,I8,-1);
6239         VARAND(DATE,-1,I8,0,I8,0);
6240         VARAND(DATE,0,I8,0,I8,0);
6241         VARAND(DATE,-1,UI8,0,I4,0);
6242         VARAND(DATE,0,UI8,0,I4,0);
6243     }
6244     VARAND(DATE,-1,INT,-1,I4,-1);
6245     VARAND(DATE,-1,INT,0,I4,0);
6246     VARAND(DATE,0,INT,0,I4,0);
6247     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
6248     VARAND(DATE,-1,UINT,0,I4,0);
6249     VARAND(DATE,0,UINT,0,I4,0);
6250     VARAND(DATE,0,BSTR,false_str,I4,0);
6251     VARAND(DATE,-1,BSTR,false_str,I4,0);
6252     VARAND(DATE,0,BSTR,true_str,I4,0);
6253     VARAND(DATE,-1,BSTR,true_str,I4,-1);
6254     VARANDCY(DATE,-1,10000,I4,1);
6255     VARANDCY(DATE,-1,0,I4,0);
6256     VARANDCY(DATE,0,0,I4,0);
6257
6258     if (HAVE_OLEAUT32_I8)
6259     {
6260         VARAND(I8,-1,I8,-1,I8,-1);
6261         VARAND(I8,-1,I8,0,I8,0);
6262         VARAND(I8,0,I8,0,I8,0);
6263         VARAND(I8,-1,UI8,0,I8,0);
6264         VARAND(I8,0,UI8,0,I8,0);
6265         VARAND(I8,-1,UINT,0,I8,0);
6266         VARAND(I8,0,UINT,0,I8,0);
6267         VARAND(I8,0,BSTR,false_str,I8,0);
6268         VARAND(I8,-1,BSTR,false_str,I8,0);
6269         VARAND(I8,0,BSTR,true_str,I8,0);
6270         VARAND(I8,-1,BSTR,true_str,I8,-1);
6271         VARANDCY(I8,-1,10000,I8,1);
6272         VARANDCY(I8,-1,0,I8,0);
6273         VARANDCY(I8,0,0,I8,0);
6274
6275         VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
6276         VARAND(UI8,0xffff,UI8,0,I4,0);
6277         VARAND(UI8,0,UI8,0,I4,0);
6278         VARAND(UI8,0xffff,INT,-1,I4,65535);
6279         VARAND(UI8,0xffff,INT,0,I4,0);
6280         VARAND(UI8,0,INT,0,I4,0);
6281         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
6282         VARAND(UI8,0xffff,UINT,0,I4,0);
6283         VARAND(UI8,0,UINT,0,I4,0);
6284         VARAND(UI8,0,BSTR,false_str,I4,0);
6285         VARAND(UI8,0xffff,BSTR,false_str,I4,0);
6286         VARAND(UI8,0,BSTR,true_str,I4,0);
6287         VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
6288         VARANDCY(UI8,0xffff,10000,I4,1);
6289         VARANDCY(UI8,0xffff,0,I4,0);
6290         VARANDCY(UI8,0,0,I4,0);
6291     }
6292
6293     VARAND(INT,-1,INT,-1,I4,-1);
6294     VARAND(INT,-1,INT,0,I4,0);
6295     VARAND(INT,0,INT,0,I4,0);
6296     VARAND(INT,-1,UINT,0xffff,I4,65535);
6297     VARAND(INT,-1,UINT,0,I4,0);
6298     VARAND(INT,0,UINT,0,I4,0);
6299     VARAND(INT,0,BSTR,false_str,I4,0);
6300     VARAND(INT,-1,BSTR,false_str,I4,0);
6301     VARAND(INT,0,BSTR,true_str,I4,0);
6302     VARAND(INT,-1,BSTR,true_str,I4,-1);
6303     VARANDCY(INT,-1,10000,I4,1);
6304     VARANDCY(INT,-1,0,I4,0);
6305     VARANDCY(INT,0,0,I4,0);
6306
6307     VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
6308     VARAND(UINT,0xffff,UINT,0,I4,0);
6309     VARAND(UINT,0,UINT,0,I4,0);
6310     VARAND(UINT,0,BSTR,false_str,I4,0);
6311     VARAND(UINT,0xffff,BSTR, false_str,I4,0);
6312     VARAND(UINT,0,BSTR,true_str,I4,0);
6313     VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
6314     VARANDCY(UINT,0xffff,10000,I4,1);
6315     VARANDCY(UINT,0xffff,0,I4,0);
6316     VARANDCY(UINT,0,0,I4,0);
6317
6318     VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
6319     VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
6320     VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
6321     VARANDCY(BSTR,true_str,10000,I4,1);
6322     VARANDCY(BSTR,false_str,10000,I4,0);
6323
6324     SysFreeString(true_str);
6325     SysFreeString(false_str);
6326 }
6327
6328 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
6329
6330 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
6331 {
6332     HRESULT hres;
6333
6334     hres = pVarCmp(left,right,lcid,flags);
6335     ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
6336                        variantstr(left), variantstr(right), result, hres );
6337 }
6338 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
6339                         HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
6340 {
6341     test_cmp( line, lcid, 0, left, right, res1 );
6342     V_VT(left) |= VT_RESERVED;
6343     test_cmp( line, lcid, 0, left, right, res2 );
6344     V_VT(left) &= ~VT_RESERVED;
6345     V_VT(right) |= VT_RESERVED;
6346     test_cmp( line, lcid, 0, left, right, res3 );
6347     V_VT(left) |= VT_RESERVED;
6348     test_cmp( line, lcid, 0, left, right, res4 );
6349     ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
6350 }
6351
6352 /* ERROR from wingdi.h is interfering here */
6353 #undef ERROR
6354 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
6355         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
6356         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
6357         test_cmp( __LINE__, lcid, flags, &left, &right, result )
6358 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
6359         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
6360         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
6361         test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
6362 #define VARCMP(vt1,val1,vt2,val2,result) \
6363         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
6364 /* The above macros do not work for VT_NULL as NULL gets expanded first */
6365 #define V_NULL_  V_NULL
6366 #define VT_NULL_ VT_NULL
6367
6368 static void test_VarCmp(void)
6369 {
6370     VARIANT left, right;
6371     VARTYPE i;
6372     LCID lcid;
6373     HRESULT hres;
6374     DECIMAL dec;
6375     static const WCHAR szhuh[] = {'h','u','h','?','\0'};
6376     static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
6377     static const WCHAR szempty[] = {'\0'};
6378     static const WCHAR sz0[] = {'0','\0'};
6379     static const WCHAR sz1[] = {'1','\0'};
6380     static const WCHAR sz7[] = {'7','\0'};
6381     static const WCHAR sz42[] = {'4','2','\0'};
6382     static const WCHAR sz1neg[] = {'-','1','\0'};
6383     static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
6384     static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
6385     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
6386     BSTR bstr2cents, bstr1few;
6387
6388     CHECKPTR(VarCmp);
6389
6390     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
6391     bstrempty = SysAllocString(szempty);
6392     bstrhuh = SysAllocString(szhuh);
6393     bstr2cents = SysAllocString(sz2cents);
6394     bstr0 = SysAllocString(sz0);
6395     bstr1 = SysAllocString(sz1);
6396     bstr7 = SysAllocString(sz7);
6397     bstr42 = SysAllocString(sz42);
6398     bstr1neg = SysAllocString(sz1neg);
6399     bstr666neg = SysAllocString(sz666neg);
6400     bstr1few = SysAllocString(sz1few);
6401
6402     /* Test all possible flag/vt combinations & the resulting vt type */
6403     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6404     {
6405         VARTYPE leftvt, rightvt;
6406
6407         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6408         {
6409
6410             SKIPTESTS(leftvt);
6411
6412             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6413             {
6414                 BOOL bFail = FALSE;
6415                 HRESULT expect = VARCMP_EQ;
6416
6417                 SKIPTESTS(rightvt);
6418
6419                 memset(&left, 0, sizeof(left));
6420                 memset(&right, 0, sizeof(right));
6421                 V_VT(&left) = leftvt | ExtraFlags[i];
6422                 if (leftvt == VT_BSTR) {
6423                     V_BSTR(&left) = bstr1neg;
6424                     if (ExtraFlags[i] & VT_RESERVED)
6425                         expect = VARCMP_LT;
6426                     else
6427                         expect = VARCMP_GT;
6428                 }
6429                 V_VT(&right) = rightvt | ExtraFlags[i];
6430                 if (rightvt == VT_BSTR) {
6431                     V_BSTR(&right) = bstr1neg;
6432                     if (ExtraFlags[i] & VT_RESERVED)
6433                         expect = VARCMP_GT;
6434                     else
6435                         expect = VARCMP_LT;
6436                 }
6437
6438                 /* Don't ask me why but native VarCmp cannot handle:
6439                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
6440                    VT_INT is only supported as left variant. Go figure.
6441                    Tested with DCOM98, Win2k, WinXP */
6442                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6443                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
6444                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
6445                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6446                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6447                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6448                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6449                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
6450                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6451                     leftvt == VT_I1 || rightvt == VT_I1 ||
6452                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6453                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6454                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6455                     rightvt == VT_INT ||
6456                     leftvt == VT_UINT || rightvt == VT_UINT) {
6457                     bFail = TRUE;
6458                 }
6459
6460                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
6461                     !(ExtraFlags[i] & ~VT_RESERVED)) {
6462                     expect = VARCMP_EQ;
6463                     bFail = FALSE;
6464                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
6465                     expect = VARCMP_NULL;
6466                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
6467                     expect = VARCMP_EQ;
6468                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
6469                     expect = VARCMP_GT;
6470                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
6471                     expect = VARCMP_LT;
6472
6473                 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
6474                 if (bFail) {
6475                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6476                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%X\n",
6477                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
6478                 } else {
6479                     ok(hres == expect,
6480                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%X, got 0x%X\n",
6481                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
6482                        hres);
6483                 }
6484             }
6485         }
6486     }
6487
6488     /* VARCMP{,EX} run each 4 tests with a permutation of all possible
6489        input variants with (1) and without (0) VT_RESERVED set. The order
6490        of the permutations is (0,0); (1,0); (0,1); (1,1) */
6491     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
6492     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
6493     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
6494     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
6495     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
6496     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
6497     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
6498     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
6499     VARCMP(I4,1,UI1,1,VARCMP_EQ);
6500     VARCMP(I2,2,I2,2,VARCMP_EQ);
6501     VARCMP(I2,1,I2,2,VARCMP_LT);
6502     VARCMP(I2,2,I2,1,VARCMP_GT);
6503     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
6504     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
6505
6506     /* BSTR handling, especially in conjunction with VT_RESERVED */
6507     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
6508     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
6509     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
6510     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
6511     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
6512     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
6513     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
6514     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
6515     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
6516     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
6517     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
6518     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
6519     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
6520     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
6521     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6522     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6523     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6524     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6525     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6526     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
6527     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6528     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6529     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
6530     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
6531     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6532     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
6533     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6534     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6535     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6536     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6537     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
6538     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6539     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
6540     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6541     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
6542     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6543     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6544     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6545     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6546     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6547     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6548     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6549     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6550     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6551     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6552     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6553     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6554     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6555     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6556     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6557     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6558     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6559     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
6560     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
6561     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
6562
6563     /* DECIMAL handling */
6564     setdec(&dec,0,0,0,0);
6565     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6566     setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
6567     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
6568     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
6569     setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
6570     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
6571     setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001);    /* 1+1e-20 */
6572     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
6573
6574     /* Show that DATE is handled just as a R8 */
6575     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
6576     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
6577     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
6578     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
6579     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
6580     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
6581     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
6582     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
6583     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
6584
6585     /* R4 precision handling */
6586     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
6587     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
6588     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
6589     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
6590     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
6591     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
6592     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
6593     setdec(&dec,8,0,0,0x5F5E101);         /* 1+1e-8 */
6594     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
6595
6596     SysFreeString(bstrhuh);
6597     SysFreeString(bstrempty);
6598     SysFreeString(bstr0);
6599     SysFreeString(bstr1);
6600     SysFreeString(bstr7);
6601     SysFreeString(bstr42);
6602     SysFreeString(bstr1neg);
6603     SysFreeString(bstr666neg);
6604     SysFreeString(bstr2cents);
6605     SysFreeString(bstr1few);
6606 }
6607
6608 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
6609
6610 #define VARPOW(vt1,val1,vt2,val2,rvt,rval)               \
6611         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6612         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6613         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6614         test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
6615
6616 /* Skip any type that is not defined or produces an error for every case */
6617 #define SKIPTESTPOW(a)                            \
6618     if (a == VT_ERROR || a == VT_VARIANT ||       \
6619         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
6620         a == VT_RECORD || a > VT_UINT ||          \
6621         a == 15 /*not defined*/)                  \
6622         continue
6623
6624 static void test_VarPow(void)
6625 {
6626     static const WCHAR str2[] = { '2','\0' };
6627     static const WCHAR str3[] = { '3','\0' };
6628     VARIANT left, right, exp, result, cy, dec;
6629     BSTR num2_str, num3_str;
6630     VARTYPE i;
6631     HRESULT hres;
6632
6633     CHECKPTR(VarPow);
6634
6635     num2_str = SysAllocString(str2);
6636     num3_str = SysAllocString(str3);
6637
6638     /* Test all possible flag/vt combinations & the resulting vt type */
6639     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6640     {
6641         VARTYPE leftvt, rightvt, resvt;
6642
6643         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6644         {
6645             SKIPTESTPOW(leftvt);
6646
6647             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6648             {
6649                 BOOL bFail = FALSE;
6650                 SKIPTESTPOW(rightvt);
6651
6652                 /* Native crashes with VT_BYREF */
6653                 if (ExtraFlags[i] == VT_BYREF)
6654                     continue;
6655
6656                 memset(&left, 0, sizeof(left));
6657                 memset(&right, 0, sizeof(right));
6658                 V_VT(&left) = leftvt | ExtraFlags[i];
6659                 V_VT(&right) = rightvt | ExtraFlags[i];
6660                 V_VT(&result) = VT_EMPTY;
6661                 resvt = VT_EMPTY;
6662
6663                 if (leftvt == VT_BSTR)
6664                     V_BSTR(&left) = num2_str;
6665                 if (rightvt == VT_BSTR)
6666                     V_BSTR(&right) = num2_str;
6667
6668                 /* Native VarPow always returns an error when using extra flags */
6669                 if (ExtraFlags[i] != 0)
6670                     bFail = TRUE;
6671
6672                 /* Determine return type */
6673                 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
6674                          ((leftvt != VT_I8 && leftvt != VT_UI8 &&
6675                            rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
6676                     resvt = VT_NULL;
6677                 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
6678                     leftvt == VT_I4 || leftvt == VT_R4 ||
6679                     leftvt == VT_R8 || leftvt == VT_CY ||
6680                     leftvt == VT_DATE || leftvt == VT_BSTR ||
6681                     leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
6682                     (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
6683                     (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
6684                     leftvt == VT_INT || leftvt == VT_UINT) &&
6685                     (rightvt == VT_EMPTY || rightvt == VT_I2 ||
6686                     rightvt == VT_I4 || rightvt == VT_R4 ||
6687                     rightvt == VT_R8 || rightvt == VT_CY ||
6688                     rightvt == VT_DATE || rightvt == VT_BSTR ||
6689                     rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
6690                     (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
6691                     (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
6692                     rightvt == VT_INT || rightvt == VT_UINT))
6693                     resvt = VT_R8;
6694                 else
6695                     bFail = TRUE;
6696
6697                 hres = pVarPow(&left, &right, &result);
6698
6699                 /* Check expected HRESULT and if result variant type is correct */
6700                 if (bFail)
6701                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6702                         "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
6703                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
6704                         vtstr(V_VT(&result)), hres);
6705                 else
6706                     ok (hres == S_OK && resvt == V_VT(&result),
6707                         "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
6708                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
6709                         S_OK, vtstr(V_VT(&result)), hres);
6710             }
6711         }
6712     }
6713
6714     /* Check return values for valid variant type combinations */
6715     VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
6716     VARPOW(EMPTY,0,NULL,0,NULL,0);
6717     VARPOW(EMPTY,0,I2,3,R8,0.0);
6718     VARPOW(EMPTY,0,I4,3,R8,0.0);
6719     VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
6720     VARPOW(EMPTY,0,R8,3.0,R8,0.0);
6721     VARPOW(EMPTY,0,DATE,3,R8,0.0);
6722     VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
6723     VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
6724     VARPOW(EMPTY,0,I1,3,R8,0.0);
6725     VARPOW(EMPTY,0,UI1,3,R8,0.0);
6726     VARPOW(EMPTY,0,UI2,3,R8,0.0);
6727     VARPOW(EMPTY,0,UI4,3,R8,0.0);
6728     if (HAVE_OLEAUT32_I8)
6729     {
6730         VARPOW(EMPTY,0,I8,3,R8,0.0);
6731         VARPOW(EMPTY,0,UI8,3,R8,0.0);
6732     }
6733     VARPOW(EMPTY,0,INT,3,R8,0.0);
6734     VARPOW(EMPTY,0,UINT,3,R8,0.0);
6735     VARPOW(NULL,0,EMPTY,0,NULL,0);
6736     VARPOW(NULL,0,NULL,0,NULL,0);
6737     VARPOW(NULL,0,I2,3,NULL,0);
6738     VARPOW(NULL,0,I4,3,NULL,0);
6739     VARPOW(NULL,0,R4,3.0f,NULL,0);
6740     VARPOW(NULL,0,R8,3.0,NULL,0);
6741     VARPOW(NULL,0,DATE,3,NULL,0);
6742     VARPOW(NULL,0,BSTR,num3_str,NULL,0);
6743     VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
6744     VARPOW(NULL,0,I1,3,NULL,0);
6745     VARPOW(NULL,0,UI1,3,NULL,0);
6746     VARPOW(NULL,0,UI2,3,NULL,0);
6747     VARPOW(NULL,0,UI4,3,NULL,0);
6748     if (HAVE_OLEAUT32_I8)
6749     {
6750         VARPOW(NULL,0,I8,3,NULL,0);
6751         VARPOW(NULL,0,UI8,3,NULL,0);
6752     }
6753     VARPOW(NULL,0,INT,3,NULL,0);
6754     VARPOW(NULL,0,UINT,3,NULL,0);
6755     VARPOW(I2,2,EMPTY,0,R8,1.0);
6756     VARPOW(I2,2,NULL,0,NULL,0);
6757     VARPOW(I2,2,I2,3,R8,8.0);
6758     VARPOW(I2,2,I4,3,R8,8.0);
6759     VARPOW(I2,2,R4,3.0f,R8,8.0);
6760     VARPOW(I2,2,R8,3.0,R8,8.0);
6761     VARPOW(I2,2,DATE,3,R8,8.0);
6762     VARPOW(I2,2,BSTR,num3_str,R8,8.0);
6763     VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
6764     VARPOW(I2,2,I1,3,R8,8.0);
6765     VARPOW(I2,2,UI1,3,R8,8.0);
6766     VARPOW(I2,2,UI2,3,R8,8.0);
6767     VARPOW(I2,2,UI4,3,R8,8.0);
6768     if (HAVE_OLEAUT32_I8)
6769     {
6770         VARPOW(I2,2,I8,3,R8,8.0);
6771         VARPOW(I2,2,UI8,3,R8,8.0);
6772     }
6773     VARPOW(I2,2,INT,3,R8,8.0);
6774     VARPOW(I2,2,UINT,3,R8,8.0);
6775     VARPOW(I4,2,EMPTY,0,R8,1.0);
6776     VARPOW(I4,2,NULL,0,NULL,0);
6777     VARPOW(I4,2,I2,3,R8,8.0);
6778     VARPOW(I4,2,I4,3,R8,8.0);
6779     VARPOW(I4,2,R4,3.0f,R8,8.0);
6780     VARPOW(I4,2,R8,3.0,R8,8.0);
6781     VARPOW(I4,2,DATE,3,R8,8.0);
6782     VARPOW(I4,2,BSTR,num3_str,R8,8.0);
6783     VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
6784     VARPOW(I4,2,I1,3,R8,8.0);
6785     VARPOW(I4,2,UI1,3,R8,8.0);
6786     VARPOW(I4,2,UI2,3,R8,8.0);
6787     VARPOW(I4,2,UI4,3,R8,8.0);
6788     if (HAVE_OLEAUT32_I8)
6789     {
6790         VARPOW(I4,2,I8,3,R8,8.0);
6791         VARPOW(I4,2,UI8,3,R8,8.0);
6792     }
6793     VARPOW(I4,2,INT,3,R8,8.0);
6794     VARPOW(I4,2,UINT,3,R8,8.0);
6795     VARPOW(R4,2,EMPTY,0,R8,1.0);
6796     VARPOW(R4,2,NULL,0,NULL,0);
6797     VARPOW(R4,2,I2,3,R8,8.0);
6798     VARPOW(R4,2,I4,3,R8,8.0);
6799     VARPOW(R4,2,R4,3.0f,R8,8.0);
6800     VARPOW(R4,2,R8,3.0,R8,8.0);
6801     VARPOW(R4,2,DATE,3,R8,8.0);
6802     VARPOW(R4,2,BSTR,num3_str,R8,8.0);
6803     VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
6804     VARPOW(R4,2,I1,3,R8,8.0);
6805     VARPOW(R4,2,UI1,3,R8,8.0);
6806     VARPOW(R4,2,UI2,3,R8,8.0);
6807     VARPOW(R4,2,UI4,3,R8,8.0);
6808     if (HAVE_OLEAUT32_I8)
6809     {
6810         VARPOW(R4,2,I8,3,R8,8.0);
6811         VARPOW(R4,2,UI8,3,R8,8.0);
6812     }
6813     VARPOW(R4,2,INT,3,R8,8.0);
6814     VARPOW(R4,2,UINT,3,R8,8.0);
6815     VARPOW(R8,2,EMPTY,0,R8,1.0);
6816     VARPOW(R8,2,NULL,0,NULL,0);
6817     VARPOW(R8,2,I2,3,R8,8.0);
6818     VARPOW(R8,2,I4,3,R8,8.0);
6819     VARPOW(R8,2,R4,3.0f,R8,8.0);
6820     VARPOW(R8,2,R8,3.0,R8,8.0);
6821     VARPOW(R8,2,DATE,3,R8,8.0);
6822     VARPOW(R8,2,BSTR,num3_str,R8,8.0);
6823     VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
6824     VARPOW(R8,2,I1,3,R8,8.0);
6825     VARPOW(R8,2,UI1,3,R8,8.0);
6826     VARPOW(R8,2,UI2,3,R8,8.0);
6827     VARPOW(R8,2,UI4,3,R8,8.0);
6828     if (HAVE_OLEAUT32_I8)
6829     {
6830         VARPOW(R8,2,I8,3,R8,8.0);
6831         VARPOW(R8,2,UI8,3,R8,8.0);
6832     }
6833     VARPOW(R8,2,INT,3,R8,8.0);
6834     VARPOW(R8,2,UINT,3,R8,8.0);
6835     VARPOW(DATE,2,EMPTY,0,R8,1.0);
6836     VARPOW(DATE,2,NULL,0,NULL,0);
6837     VARPOW(DATE,2,I2,3,R8,8.0);
6838     VARPOW(DATE,2,I4,3,R8,8.0);
6839     VARPOW(DATE,2,R4,3.0f,R8,8.0);
6840     VARPOW(DATE,2,R8,3.0,R8,8.0);
6841     VARPOW(DATE,2,DATE,3,R8,8.0);
6842     VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
6843     VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
6844     VARPOW(DATE,2,I1,3,R8,8.0);
6845     VARPOW(DATE,2,UI1,3,R8,8.0);
6846     VARPOW(DATE,2,UI2,3,R8,8.0);
6847     VARPOW(DATE,2,UI4,3,R8,8.0);
6848     if (HAVE_OLEAUT32_I8)
6849     {
6850         VARPOW(DATE,2,I8,3,R8,8.0);
6851         VARPOW(DATE,2,UI8,3,R8,8.0);
6852     }
6853     VARPOW(DATE,2,INT,3,R8,8.0);
6854     VARPOW(DATE,2,UINT,3,R8,8.0);
6855     VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
6856     VARPOW(BSTR,num2_str,NULL,0,NULL,0);
6857     VARPOW(BSTR,num2_str,I2,3,R8,8.0);
6858     VARPOW(BSTR,num2_str,I4,3,R8,8.0);
6859     VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
6860     VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
6861     VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
6862     VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
6863     VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
6864     VARPOW(BSTR,num2_str,I1,3,R8,8.0);
6865     VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
6866     VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
6867     VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
6868     if (HAVE_OLEAUT32_I8)
6869     {
6870         VARPOW(BSTR,num2_str,I8,3,R8,8.0);
6871         VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
6872     }
6873     VARPOW(BSTR,num2_str,INT,3,R8,8.0);
6874     VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
6875     VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
6876     VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
6877     VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
6878     VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
6879     VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
6880     VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
6881     VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
6882     VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
6883     VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
6884     VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
6885     VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
6886     VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
6887     VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
6888     if (HAVE_OLEAUT32_I8)
6889     {
6890         VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
6891         VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
6892     }
6893     VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
6894     VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
6895     VARPOW(I1,2,EMPTY,0,R8,1.0);
6896     VARPOW(I1,2,NULL,0,NULL,0);
6897     VARPOW(I1,2,I2,3,R8,8.0);
6898     VARPOW(I1,2,I4,3,R8,8.0);
6899     VARPOW(I1,2,R4,3.0f,R8,8.0);
6900     VARPOW(I1,2,R8,3.0,R8,8.0);
6901     VARPOW(I1,2,DATE,3,R8,8.0);
6902     VARPOW(I1,2,BSTR,num3_str,R8,8.0);
6903     VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
6904     VARPOW(I1,2,I1,3,R8,8.0);
6905     VARPOW(I1,2,UI1,3,R8,8.0);
6906     VARPOW(I1,2,UI2,3,R8,8.0);
6907     VARPOW(I1,2,UI4,3,R8,8.0);
6908     if (HAVE_OLEAUT32_I8)
6909     {
6910         VARPOW(I1,2,I8,3,R8,8.0);
6911         VARPOW(I1,2,UI8,3,R8,8.0);
6912     }
6913     VARPOW(I1,2,INT,3,R8,8.0);
6914     VARPOW(I1,2,UINT,3,R8,8.0);
6915     VARPOW(UI1,2,EMPTY,0,R8,1.0);
6916     VARPOW(UI1,2,NULL,0,NULL,0);
6917     VARPOW(UI1,2,I2,3,R8,8.0);
6918     VARPOW(UI1,2,I4,3,R8,8.0);
6919     VARPOW(UI1,2,R4,3.0f,R8,8.0);
6920     VARPOW(UI1,2,R8,3.0,R8,8.0);
6921     VARPOW(UI1,2,DATE,3,R8,8.0);
6922     VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
6923     VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
6924     VARPOW(UI1,2,I1,3,R8,8.0);
6925     VARPOW(UI1,2,UI1,3,R8,8.0);
6926     VARPOW(UI1,2,UI2,3,R8,8.0);
6927     VARPOW(UI1,2,UI4,3,R8,8.0);
6928     if (HAVE_OLEAUT32_I8)
6929     {
6930         VARPOW(UI1,2,I8,3,R8,8.0);
6931         VARPOW(UI1,2,UI8,3,R8,8.0);
6932     }
6933     VARPOW(UI1,2,INT,3,R8,8.0);
6934     VARPOW(UI1,2,UINT,3,R8,8.0);
6935     VARPOW(UI2,2,EMPTY,0,R8,1.0);
6936     VARPOW(UI2,2,NULL,0,NULL,0);
6937     VARPOW(UI2,2,I2,3,R8,8.0);
6938     VARPOW(UI2,2,I4,3,R8,8.0);
6939     VARPOW(UI2,2,R4,3.0f,R8,8.0);
6940     VARPOW(UI2,2,R8,3.0,R8,8.0);
6941     VARPOW(UI2,2,DATE,3,R8,8.0);
6942     VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
6943     VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
6944     VARPOW(UI2,2,I1,3,R8,8.0);
6945     VARPOW(UI2,2,UI1,3,R8,8.0);
6946     VARPOW(UI2,2,UI2,3,R8,8.0);
6947     VARPOW(UI2,2,UI4,3,R8,8.0);
6948     if (HAVE_OLEAUT32_I8)
6949     {
6950         VARPOW(UI2,2,I8,3,R8,8.0);
6951         VARPOW(UI2,2,UI8,3,R8,8.0);
6952     }
6953     VARPOW(UI2,2,INT,3,R8,8.0);
6954     VARPOW(UI2,2,UINT,3,R8,8.0);
6955     VARPOW(UI4,2,EMPTY,0,R8,1.0);
6956     VARPOW(UI4,2,NULL,0,NULL,0);
6957     VARPOW(UI4,2,I2,3,R8,8.0);
6958     VARPOW(UI4,2,I4,3,R8,8.0);
6959     VARPOW(UI4,2,R4,3.0f,R8,8.0);
6960     VARPOW(UI4,2,R8,3.0,R8,8.0);
6961     VARPOW(UI4,2,DATE,3,R8,8.0);
6962     VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
6963     VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
6964     VARPOW(UI4,2,I1,3,R8,8.0);
6965     VARPOW(UI4,2,UI1,3,R8,8.0);
6966     VARPOW(UI4,2,UI2,3,R8,8.0);
6967     VARPOW(UI4,2,UI4,3,R8,8.0);
6968     if (HAVE_OLEAUT32_I8)
6969     {
6970         VARPOW(UI4,2,I8,3,R8,8.0);
6971         VARPOW(UI4,2,UI8,3,R8,8.0);
6972     }
6973     VARPOW(UI4,2,INT,3,R8,8.0);
6974     VARPOW(UI4,2,UINT,3,R8,8.0);
6975     if (HAVE_OLEAUT32_I8)
6976     {
6977         VARPOW(I8,2,EMPTY,0,R8,1.0);
6978         VARPOW(I8,2,NULL,0,NULL,0);
6979         VARPOW(I8,2,I2,3,R8,8.0);
6980         VARPOW(I8,2,I4,3,R8,8.0);
6981         VARPOW(I8,2,R4,3.0f,R8,8.0);
6982         VARPOW(I8,2,R8,3.0,R8,8.0);
6983         VARPOW(I8,2,DATE,3,R8,8.0);
6984         VARPOW(I8,2,BSTR,num3_str,R8,8.0);
6985         VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
6986         VARPOW(I8,2,I1,3,R8,8.0);
6987         VARPOW(I8,2,UI1,3,R8,8.0);
6988         VARPOW(I8,2,UI2,3,R8,8.0);
6989         VARPOW(I8,2,UI4,3,R8,8.0);
6990         VARPOW(I8,2,I8,3,R8,8.0);
6991         VARPOW(I8,2,UI8,3,R8,8.0);
6992         VARPOW(I8,2,INT,3,R8,8.0);
6993         VARPOW(I8,2,UINT,3,R8,8.0);
6994         VARPOW(UI8,2,EMPTY,0,R8,1.0);
6995         VARPOW(UI8,2,NULL,0,NULL,0);
6996         VARPOW(UI8,2,I2,3,R8,8.0);
6997         VARPOW(UI8,2,I4,3,R8,8.0);
6998         VARPOW(UI8,2,R4,3.0f,R8,8.0);
6999         VARPOW(UI8,2,R8,3.0,R8,8.0);
7000         VARPOW(UI8,2,DATE,3,R8,8.0);
7001         VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
7002         VARPOW(UI8,2,I1,3,R8,8.0);
7003         VARPOW(UI8,2,UI1,3,R8,8.0);
7004         VARPOW(UI8,2,UI2,3,R8,8.0);
7005         VARPOW(UI8,2,UI4,3,R8,8.0);
7006         VARPOW(UI8,2,I8,3,R8,8.0);
7007         VARPOW(UI8,2,UI8,3,R8,8.0);
7008         VARPOW(UI8,2,INT,3,R8,8.0);
7009         VARPOW(UI8,2,UINT,3,R8,8.0);
7010     }
7011     VARPOW(INT,2,EMPTY,0,R8,1.0);
7012     VARPOW(INT,2,NULL,0,NULL,0);
7013     VARPOW(INT,2,I2,3,R8,8.0);
7014     VARPOW(INT,2,I4,3,R8,8.0);
7015     VARPOW(INT,2,R4,3.0f,R8,8.0);
7016     VARPOW(INT,2,R8,3.0,R8,8.0);
7017     VARPOW(INT,2,DATE,3,R8,8.0);
7018     VARPOW(INT,2,BSTR,num3_str,R8,8.0);
7019     VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
7020     VARPOW(INT,2,I1,3,R8,8.0);
7021     VARPOW(INT,2,UI1,3,R8,8.0);
7022     VARPOW(INT,2,UI2,3,R8,8.0);
7023     VARPOW(INT,2,UI4,3,R8,8.0);
7024     if (HAVE_OLEAUT32_I8)
7025     {
7026         VARPOW(INT,2,I8,3,R8,8.0);
7027         VARPOW(INT,2,UI8,3,R8,8.0);
7028     }
7029     VARPOW(INT,2,INT,3,R8,8.0);
7030     VARPOW(INT,2,UINT,3,R8,8.0);
7031     VARPOW(UINT,2,EMPTY,0,R8,1.0);
7032     VARPOW(UINT,2,NULL,0,NULL,0);
7033     VARPOW(UINT,2,I2,3,R8,8.0);
7034     VARPOW(UINT,2,I4,3,R8,8.0);
7035     VARPOW(UINT,2,R4,3.0f,R8,8.0);
7036     VARPOW(UINT,2,R8,3.0,R8,8.0);
7037     VARPOW(UINT,2,DATE,3,R8,8.0);
7038     VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
7039     VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
7040     VARPOW(UINT,2,I1,3,R8,8.0);
7041     VARPOW(UINT,2,UI1,3,R8,8.0);
7042     VARPOW(UINT,2,UI2,3,R8,8.0);
7043     VARPOW(UINT,2,UI4,3,R8,8.0);
7044     if (HAVE_OLEAUT32_I8)
7045     {
7046         VARPOW(UINT,2,I8,3,R8,8.0);
7047         VARPOW(UINT,2,UI8,3,R8,8.0);
7048     }
7049     VARPOW(UINT,2,INT,3,R8,8.0);
7050     VARPOW(UINT,2,UINT,3,R8,8.0);
7051
7052     /* Manually test some VT_CY, VT_DECIMAL variants */
7053     V_VT(&cy) = VT_CY;
7054     hres = VarCyFromI4(2, &V_CY(&cy));
7055     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7056     V_VT(&dec) = VT_DECIMAL;
7057     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7058     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7059     memset(&left, 0, sizeof(left));
7060     memset(&right, 0, sizeof(right));
7061     V_VT(&left) = VT_I4;
7062     V_I4(&left) = 100;
7063     V_VT(&right) = VT_I8;
7064     V_UI1(&right) = 2;
7065
7066     hres = pVarPow(&cy, &cy, &result);
7067     ok(hres == S_OK && V_VT(&result) == VT_R8,
7068         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7069         S_OK, hres, vtstr(V_VT(&result)));
7070     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7071         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7072
7073     hres = pVarPow(&cy, &right, &result);
7074     if (hres == S_OK)
7075     {
7076         ok(hres == S_OK && V_VT(&result) == VT_R8,
7077            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7078            S_OK, hres, vtstr(V_VT(&result)));
7079         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7080            "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7081     }
7082     else
7083     {
7084         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7085            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7086            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7087     }
7088
7089     hres = pVarPow(&left, &cy, &result);
7090     ok(hres == S_OK && V_VT(&result) == VT_R8,
7091         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7092         S_OK, hres, vtstr(V_VT(&result)));
7093     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
7094         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
7095
7096     hres = pVarPow(&left, &dec, &result);
7097     ok(hres == S_OK && V_VT(&result) == VT_R8,
7098         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7099         S_OK, hres, vtstr(V_VT(&result)));
7100     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
7101         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
7102
7103     hres = pVarPow(&dec, &dec, &result);
7104     ok(hres == S_OK && V_VT(&result) == VT_R8,
7105         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7106         S_OK, hres, vtstr(V_VT(&result)));
7107     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7108         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7109
7110     hres = pVarPow(&dec, &right, &result);
7111     if (hres == S_OK)
7112     {
7113         ok(hres == S_OK && V_VT(&result) == VT_R8,
7114            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7115            S_OK, hres, vtstr(V_VT(&result)));
7116         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7117            "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7118     }
7119     else
7120     {
7121         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7122            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7123            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7124     }
7125
7126     SysFreeString(num2_str);
7127     SysFreeString(num3_str);
7128 }
7129
7130 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7131
7132 #define VARDIV(vt1,val1,vt2,val2,rvt,rval)               \
7133         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7134         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7135         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7136         test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
7137
7138 /* Skip any type that is not defined or produces an error for every case */
7139 #define SKIPTESTDIV(a)                            \
7140     if (a == VT_ERROR || a == VT_VARIANT ||       \
7141         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7142         a == VT_RECORD || a > VT_UINT ||          \
7143         a == VT_I1 || a == VT_UI8 ||              \
7144         a == VT_INT || a == VT_UINT ||            \
7145         a == VT_UI2 || a == VT_UI4 ||             \
7146         a == 15 /*not defined*/)                  \
7147         continue
7148
7149 static void test_VarDiv(void)
7150 {
7151     static const WCHAR str1[] = { '1','\0' };
7152     static const WCHAR str2[] = { '2','\0' };
7153     VARIANT left, right, exp, result, cy, dec;
7154     BSTR num1_str, num2_str;
7155     VARTYPE i;
7156     HRESULT hres;
7157     double r;
7158
7159     num1_str = SysAllocString(str1);
7160     num2_str = SysAllocString(str2);
7161
7162     CHECKPTR(VarDiv);
7163
7164     /* Test all possible flag/vt combinations & the resulting vt type */
7165     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7166     {
7167         VARTYPE leftvt, rightvt, resvt;
7168
7169         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7170         {
7171             SKIPTESTDIV(leftvt);
7172
7173             /* Check if we need/have support for I8 */
7174             if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
7175                 continue;
7176
7177             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7178             {
7179                 BOOL bFail = FALSE;
7180                 SKIPTESTDIV(rightvt);
7181
7182                 /* Check if we need/have support for I8 */
7183                 if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
7184                     continue;
7185
7186                 /* Native crashes with VT_BYREF */
7187                 if (ExtraFlags[i] == VT_BYREF)
7188                     continue;
7189
7190                 memset(&left, 0, sizeof(left));
7191                 memset(&right, 0, sizeof(right));
7192                 V_VT(&left) = leftvt | ExtraFlags[i];
7193                 V_VT(&right) = rightvt | ExtraFlags[i];
7194                 V_VT(&result) = VT_EMPTY;
7195                 resvt = VT_EMPTY;
7196
7197                 if (leftvt == VT_BSTR)
7198                     V_BSTR(&left) = num2_str;
7199                 else if (leftvt == VT_DECIMAL)
7200                 {
7201                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7202                     V_VT(&left) = leftvt | ExtraFlags[i];
7203                 }
7204
7205                 /* Division by 0 is undefined */
7206                 switch(rightvt)
7207                 {
7208                 case VT_BSTR:
7209                     V_BSTR(&right) = num2_str;
7210                     break;
7211                 case VT_DECIMAL:
7212                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7213                     V_VT(&right) = rightvt | ExtraFlags[i];
7214                     break;
7215                 case VT_BOOL:
7216                     V_BOOL(&right) = VARIANT_TRUE;
7217                     break;
7218                 case VT_I2: V_I2(&right) = 2; break;
7219                 case VT_I4: V_I4(&right) = 2; break;
7220                 case VT_R4: V_R4(&right) = 2.0f; break;
7221                 case VT_R8: V_R8(&right) = 2.0; break;
7222                 case VT_CY: V_CY(&right).int64 = 2; break;
7223                 case VT_DATE: V_DATE(&right) = 2; break;
7224                 case VT_UI1: V_UI1(&right) = 2; break;
7225                 case VT_I8: V_I8(&right) = 2; break;
7226                 default: break;
7227                 }
7228
7229                 /* Determine return type */
7230                 if (!(rightvt == VT_EMPTY))
7231                 {
7232                     if (leftvt == VT_NULL || rightvt == VT_NULL)
7233                         resvt = VT_NULL;
7234                     else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
7235                         resvt = VT_DECIMAL;
7236                     else if (leftvt == VT_I8 || rightvt == VT_I8 ||
7237                         leftvt == VT_CY || rightvt == VT_CY ||
7238                         leftvt == VT_DATE || rightvt == VT_DATE ||
7239                         leftvt == VT_I4 || rightvt == VT_I4 ||
7240                         leftvt == VT_BSTR || rightvt == VT_BSTR ||
7241                         leftvt == VT_I2 || rightvt == VT_I2 ||
7242                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
7243                         leftvt == VT_R8 || rightvt == VT_R8 ||
7244                         leftvt == VT_UI1 || rightvt == VT_UI1)
7245                     {
7246                         if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
7247                             (leftvt == VT_R4 && rightvt == VT_UI1))
7248                             resvt = VT_R4;
7249                         else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
7250                             rightvt == VT_I2)) || (rightvt == VT_R4 &&
7251                             (leftvt == VT_BOOL || leftvt == VT_I2)))
7252                             resvt = VT_R4;
7253                         else
7254                             resvt = VT_R8;
7255                     }
7256                     else if (leftvt == VT_R4 || rightvt == VT_R4)
7257                         resvt = VT_R4;
7258                 }
7259                 else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
7260                     resvt = VT_NULL;
7261                 else
7262                     bFail = TRUE;
7263
7264                 /* Native VarDiv always returns an error when using extra flags */
7265                 if (ExtraFlags[i] != 0)
7266                     bFail = TRUE;
7267
7268                 hres = pVarDiv(&left, &right, &result);
7269
7270                 /* Check expected HRESULT and if result variant type is correct */
7271                 if (bFail)
7272                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7273                         hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
7274                         "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7275                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7276                         vtstr(V_VT(&result)), hres);
7277                 else
7278                     ok (hres == S_OK && resvt == V_VT(&result),
7279                         "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7280                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7281                         S_OK, vtstr(V_VT(&result)), hres);
7282             }
7283         }
7284     }
7285
7286     /* Test return values for all the good cases */
7287     VARDIV(EMPTY,0,NULL,0,NULL,0);
7288     VARDIV(EMPTY,0,I2,2,R8,0.0);
7289     VARDIV(EMPTY,0,I4,2,R8,0.0);
7290     VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
7291     VARDIV(EMPTY,0,R8,2.0,R8,0.0);
7292     VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
7293     VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
7294     VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
7295     VARDIV(EMPTY,0,UI1,2,R8,0.0);
7296     if (HAVE_OLEAUT32_I8)
7297     {
7298         VARDIV(EMPTY,0,I8,2,R8,0.0);
7299     }
7300     VARDIV(NULL,0,EMPTY,0,NULL,0);
7301     VARDIV(NULL,0,NULL,0,NULL,0);
7302     VARDIV(NULL,0,I2,2,NULL,0);
7303     VARDIV(NULL,0,I4,2,NULL,0);
7304     VARDIV(NULL,0,R4,2.0f,NULL,0);
7305     VARDIV(NULL,0,R8,2.0,NULL,0);
7306     VARDIV(NULL,0,DATE,2,NULL,0);
7307     VARDIV(NULL,0,BSTR,num2_str,NULL,0);
7308     VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7309     VARDIV(NULL,0,UI1,2,NULL,0);
7310     if (HAVE_OLEAUT32_I8)
7311     {
7312         VARDIV(NULL,0,I8,2,NULL,0);
7313     }
7314     VARDIV(I2,2,NULL,0,NULL,0);
7315     VARDIV(I2,1,I2,2,R8,0.5);
7316     VARDIV(I2,1,I4,2,R8,0.5);
7317     VARDIV(I2,1,R4,2,R4,0.5f);
7318     VARDIV(I2,1,R8,2.0,R8,0.5);
7319     VARDIV(I2,1,DATE,2,R8,0.5);
7320     VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
7321     VARDIV(I2,1,UI1,2,R8,0.5);
7322     if (HAVE_OLEAUT32_I8)
7323     {
7324         VARDIV(I2,1,I8,2,R8,0.5);
7325     }
7326     VARDIV(I4,1,NULL,0,NULL,0);
7327     VARDIV(I4,1,I2,2,R8,0.5);
7328     VARDIV(I4,1,I4,2,R8,0.5);
7329     VARDIV(I4,1,R4,2.0f,R8,0.5);
7330     VARDIV(I4,1,R8,2.0,R8,0.5);
7331     VARDIV(I4,1,DATE,2,R8,0.5);
7332     VARDIV(I4,1,BSTR,num2_str,R8,0.5);
7333     VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
7334     VARDIV(I4,1,UI1,2,R8,0.5);
7335     if (HAVE_OLEAUT32_I8)
7336     {
7337         VARDIV(I4,1,I8,2,R8,0.5);
7338     }
7339     VARDIV(R4,1.0f,NULL,0,NULL,0);
7340     VARDIV(R4,1.0f,I2,2,R4,0.5f);
7341     VARDIV(R4,1.0f,I4,2,R8,0.5);
7342     VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
7343     VARDIV(R4,1.0f,R8,2.0,R8,0.5);
7344     VARDIV(R4,1.0f,DATE,2,R8,0.5);
7345     VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
7346     VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
7347     VARDIV(R4,1.0f,UI1,2,R4,0.5f);
7348     if (HAVE_OLEAUT32_I8)
7349     {
7350         VARDIV(R4,1.0f,I8,2,R8,0.5);
7351     }
7352     VARDIV(R8,1.0,NULL,0,NULL,0);
7353     VARDIV(R8,1.0,I2,2,R8,0.5);
7354     VARDIV(R8,1.0,I4,2,R8,0.5);
7355     VARDIV(R8,1.0,R4,2.0f,R8,0.5);
7356     VARDIV(R8,1.0,R8,2.0,R8,0.5);
7357     VARDIV(R8,1.0,DATE,2,R8,0.5);
7358     VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
7359     VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
7360     VARDIV(R8,1.0,UI1,2,R8,0.5);
7361     if (HAVE_OLEAUT32_I8)
7362     {
7363         VARDIV(R8,1.0,I8,2,R8,0.5);
7364     }
7365     VARDIV(DATE,1,NULL,0,NULL,0);
7366     VARDIV(DATE,1,I2,2,R8,0.5);
7367     VARDIV(DATE,1,I4,2,R8,0.5);
7368     VARDIV(DATE,1,R4,2.0f,R8,0.5);
7369     VARDIV(DATE,1,R8,2.0,R8,0.5);
7370     VARDIV(DATE,1,DATE,2,R8,0.5);
7371     VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
7372     VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
7373     VARDIV(DATE,1,UI1,2,R8,0.5);
7374     if (HAVE_OLEAUT32_I8)
7375     {
7376         VARDIV(DATE,1,I8,2,R8,0.5);
7377     }
7378     VARDIV(BSTR,num1_str,NULL,0,NULL,0);
7379     VARDIV(BSTR,num1_str,I2,2,R8,0.5);
7380     VARDIV(BSTR,num1_str,I4,2,R8,0.5);
7381     VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
7382     VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
7383     VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
7384     VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
7385     VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
7386     VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
7387     if (HAVE_OLEAUT32_I8)
7388     {
7389         VARDIV(BSTR,num1_str,I8,2,R8,0.5);
7390     }
7391     VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7392     VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
7393     VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
7394     VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
7395     VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
7396     VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
7397     VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
7398     VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
7399     VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
7400     VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
7401     VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
7402     VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
7403     VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
7404     VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
7405     if (HAVE_OLEAUT32_I8)
7406     {
7407         VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
7408     }
7409     VARDIV(UI1,1,NULL,0,NULL,0);
7410     VARDIV(UI1,1,I2,2,R8,0.5);
7411     VARDIV(UI1,1,I4,2,R8,0.5);
7412     VARDIV(UI1,1,R4,2.0f,R4,0.5f);
7413     VARDIV(UI1,1,R8,2.0,R8,0.5);
7414     VARDIV(UI1,1,DATE,2,R8,0.5);
7415     VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
7416     VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
7417     VARDIV(UI1,1,UI1,2,R8,0.5);
7418     if (HAVE_OLEAUT32_I8)
7419     {
7420         VARDIV(UI1,1,I8,2,R8,0.5);
7421         VARDIV(I8,1,NULL,0,NULL,0);
7422         VARDIV(I8,1,I2,2,R8,0.5);
7423         VARDIV(I8,1,I4,2,R8,0.5);
7424         VARDIV(I8,1,R4,2.0f,R8,0.5);
7425         VARDIV(I8,1,R8,2.0,R8,0.5);
7426         VARDIV(I8,1,DATE,2,R8,0.5);
7427         VARDIV(I8,1,BSTR,num2_str,R8,0.5);
7428         VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
7429         VARDIV(I8,1,UI1,2,R8,0.5);
7430         VARDIV(I8,1,I8,2,R8,0.5);
7431     }
7432
7433     /* Manually test some VT_CY, VT_DECIMAL variants */
7434     V_VT(&cy) = VT_CY;
7435     hres = VarCyFromI4(10000, &V_CY(&cy));
7436     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7437     V_VT(&dec) = VT_DECIMAL;
7438     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7439     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7440     memset(&left, 0, sizeof(left));
7441     memset(&right, 0, sizeof(right));
7442     V_VT(&left) = VT_I4;
7443     V_I4(&left) = 100;
7444     V_VT(&right) = VT_UI1;
7445     V_UI1(&right) = 2;
7446
7447     hres = pVarDiv(&cy, &cy, &result);
7448     ok(hres == S_OK && V_VT(&result) == VT_R8,
7449         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7450     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
7451         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
7452
7453     hres = pVarDiv(&cy, &right, &result);
7454     ok(hres == S_OK && V_VT(&result) == VT_R8,
7455         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7456     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
7457         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
7458
7459     hres = pVarDiv(&left, &cy, &result);
7460     ok(hres == S_OK && V_VT(&result) == VT_R8,
7461         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7462     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
7463         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
7464
7465     hres = pVarDiv(&left, &dec, &result);
7466     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7467         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7468     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7469     ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
7470         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
7471
7472     hres = pVarDiv(&dec, &dec, &result);
7473     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7474         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7475     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7476     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7477         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7478
7479     hres = pVarDiv(&dec, &right, &result);
7480     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7481         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7482     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7483     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7484         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7485
7486     /* Check for division by zero and overflow */
7487     V_VT(&left) = VT_R8;
7488     V_I4(&left) = 1;
7489     V_VT(&right) = VT_R8;
7490     V_I4(&right) = 0;
7491     hres = pVarDiv(&left, &right, &result);
7492     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7493         "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7494
7495     V_VT(&left) = VT_R8;
7496     V_I4(&left) = 0;
7497     V_VT(&right) = VT_R8;
7498     V_I4(&right) = 0;
7499     hres = pVarDiv(&left, &right, &result);
7500     ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
7501         "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%X\n", hres);
7502
7503     SysFreeString(num1_str);
7504     SysFreeString(num2_str);
7505 }
7506
7507 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7508
7509 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval)              \
7510         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7511         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7512         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7513         test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
7514
7515 /* Skip any type that is not defined or produces an error for every case */
7516 #define SKIPTESTIDIV(a)                           \
7517     if (a == VT_ERROR || a == VT_VARIANT ||       \
7518         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7519         a == VT_RECORD || a > VT_UINT ||          \
7520         a == 15 /*not defined*/)                  \
7521         continue
7522
7523 static void test_VarIdiv(void)
7524 {
7525     static const WCHAR str1[] = { '1','\0' };
7526     static const WCHAR str2[] = { '2','\0' };
7527     VARIANT left, right, exp, result, cy, dec;
7528     BSTR num1_str, num2_str;
7529     VARTYPE i;
7530     HRESULT hres;
7531
7532     CHECKPTR(VarIdiv);
7533
7534     num1_str = SysAllocString(str1);
7535     num2_str = SysAllocString(str2);
7536
7537     /* Test all possible flag/vt combinations & the resulting vt type */
7538     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7539     {
7540         VARTYPE leftvt, rightvt, resvt;
7541
7542         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7543         {
7544             SKIPTESTIDIV(leftvt);
7545
7546             /* Check if we need/have support for I8 and/or UI8 */
7547             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7548                 continue;
7549
7550             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7551             {
7552                 BOOL bFail = FALSE;
7553                 SKIPTESTIDIV(rightvt);
7554
7555                 /* Native crashes with extra flag VT_BYREF */
7556                 if (ExtraFlags[i] == VT_BYREF)
7557                     continue;
7558
7559                 /* Check if we need/have support for I8 and/or UI8 */
7560                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7561                     continue;
7562
7563                 memset(&left, 0, sizeof(left));
7564                 memset(&right, 0, sizeof(right));
7565                 V_VT(&left) = leftvt | ExtraFlags[i];
7566                 V_VT(&right) = rightvt | ExtraFlags[i];
7567                 V_VT(&result) = VT_EMPTY;
7568                 resvt = VT_EMPTY;
7569
7570                 if (leftvt == VT_BSTR)
7571                     V_BSTR(&left) = num2_str;
7572                 else if (leftvt == VT_DECIMAL)
7573                 {
7574                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7575                     V_VT(&left) = leftvt | ExtraFlags[i];
7576                 }
7577
7578                 /* Division by 0 is undefined */
7579                 switch(rightvt)
7580                 {
7581                 case VT_BSTR:
7582                     V_BSTR(&right) = num2_str;
7583                     break;
7584                 case VT_DECIMAL:
7585                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7586                     V_VT(&right) = rightvt | ExtraFlags[i];
7587                     break;
7588                 case VT_BOOL:
7589                     V_BOOL(&right) = VARIANT_TRUE;
7590                     break;
7591                 case VT_CY:
7592                     VarCyFromI4(10000, &V_CY(&right));
7593                     V_VT(&right) = rightvt | ExtraFlags[i];
7594                     break;
7595                 case VT_I2: V_I2(&right) = 2; break;
7596                 case VT_I4: V_I4(&right) = 2; break;
7597                 case VT_R4: V_R4(&right) = 2.0f; break;
7598                 case VT_R8: V_R8(&right) = 2.0; break;
7599                 case VT_DATE: V_DATE(&right) = 2; break;
7600                 case VT_I1: V_I1(&right) = 2; break;
7601                 case VT_UI1: V_UI1(&right) = 2; break;
7602                 case VT_UI2: V_UI2(&right) = 2; break;
7603                 case VT_UI4: V_UI4(&right) = 2; break;
7604                 case VT_I8: V_I8(&right) = 2; break;
7605                 case VT_UI8: V_UI8(&right) = 2; break;
7606                 case VT_INT: V_INT(&right) = 2; break;
7607                 case VT_UINT: V_UINT(&right) = 2; break;
7608                 default: break;
7609                 }
7610
7611                 /* Native VarIdiv always returns an error when using extra
7612                  * flags or if the variant combination is I8 and INT.
7613                  */
7614                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
7615                     (leftvt == VT_INT && rightvt == VT_I8) ||
7616                     (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
7617                     ExtraFlags[i] != 0)
7618                     bFail = TRUE;
7619
7620                 /* Determine variant type */
7621                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
7622                     resvt = VT_NULL;
7623                 else if (leftvt == VT_I8 || rightvt == VT_I8)
7624                     resvt = VT_I8;
7625                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
7626                     leftvt == VT_INT || rightvt == VT_INT ||
7627                     leftvt == VT_UINT || rightvt == VT_UINT ||
7628                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
7629                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
7630                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
7631                     leftvt == VT_I1 || rightvt == VT_I1 ||
7632                     leftvt == VT_BSTR || rightvt == VT_BSTR ||
7633                     leftvt == VT_DATE || rightvt == VT_DATE ||
7634                     leftvt == VT_CY || rightvt == VT_CY ||
7635                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
7636                     leftvt == VT_R8 || rightvt == VT_R8 ||
7637                     leftvt == VT_R4 || rightvt == VT_R4)
7638                     resvt = VT_I4;
7639                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
7640                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
7641                     leftvt == VT_EMPTY)
7642                     resvt = VT_I2;
7643                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
7644                     resvt = VT_UI1;
7645                 else
7646                     bFail = TRUE;
7647
7648                 hres = pVarIdiv(&left, &right, &result);
7649
7650                 /* Check expected HRESULT and if result variant type is correct */
7651                 if (bFail)
7652                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7653                         hres == DISP_E_DIVBYZERO,
7654                         "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7655                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7656                         vtstr(V_VT(&result)), hres);
7657                 else
7658                     ok (hres == S_OK && resvt == V_VT(&result),
7659                         "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7660                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7661                         S_OK, vtstr(V_VT(&result)), hres);
7662             }
7663         }
7664     }
7665
7666     /* Test return values for all the good cases */
7667     VARIDIV(EMPTY,0,NULL,0,NULL,0);
7668     VARIDIV(EMPTY,0,I2,1,I2,0);
7669     VARIDIV(EMPTY,0,I4,1,I4,0);
7670     VARIDIV(EMPTY,0,R4,1.0f,I4,0);
7671     VARIDIV(EMPTY,0,R8,1.0,I4,0);
7672     VARIDIV(EMPTY,0,DATE,1.0,I4,0);
7673     VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
7674     VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
7675     VARIDIV(EMPTY,0,I1,1,I4,0);
7676     VARIDIV(EMPTY,0,UI1,1,I2,0);
7677     VARIDIV(EMPTY,0,UI2,1,I4,0);
7678     VARIDIV(EMPTY,0,UI4,1,I4,0);
7679     if (HAVE_OLEAUT32_I8)
7680     {
7681         VARIDIV(EMPTY,0,I8,1,I8,0);
7682         VARIDIV(EMPTY,0,UI8,1,I4,0);
7683     }
7684     VARIDIV(EMPTY,0,INT,1,I4,0);
7685     VARIDIV(EMPTY,0,UINT,1,I4,0);
7686     VARIDIV(NULL,0,EMPTY,0,NULL,0);
7687     VARIDIV(NULL,0,NULL,0,NULL,0);
7688     VARIDIV(NULL,0,I2,1,NULL,0);
7689     VARIDIV(NULL,0,I4,1,NULL,0);
7690     VARIDIV(NULL,0,R4,1,NULL,0);
7691     VARIDIV(NULL,0,R8,1,NULL,0);
7692     VARIDIV(NULL,0,DATE,1,NULL,0);
7693     VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
7694     VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7695     VARIDIV(NULL,0,I1,1,NULL,0);
7696     VARIDIV(NULL,0,UI1,1,NULL,0);
7697     VARIDIV(NULL,0,UI2,1,NULL,0);
7698     VARIDIV(NULL,0,UI4,1,NULL,0);
7699     if (HAVE_OLEAUT32_I8)
7700     {
7701         VARIDIV(NULL,0,I8,1,NULL,0);
7702         VARIDIV(NULL,0,UI8,1,NULL,0);
7703     }
7704     VARIDIV(NULL,0,INT,1,NULL,0);
7705     VARIDIV(NULL,0,UINT,1,NULL,0);
7706     VARIDIV(I2,2,NULL,0,NULL,0);
7707     VARIDIV(I2,2,I2,1,I2,2);
7708     VARIDIV(I2,2,I4,1,I4,2);
7709     VARIDIV(I2,2,R4,1,I4,2);
7710     VARIDIV(I2,2,R8,1,I4,2);
7711     VARIDIV(I2,2,DATE,1,I4,2);
7712     VARIDIV(I2,2,BSTR,num1_str,I4,2);
7713     VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
7714     VARIDIV(I2,2,I1,1,I4,2);
7715     VARIDIV(I2,2,UI1,1,I2,2);
7716     VARIDIV(I2,2,UI2,1,I4,2);
7717     VARIDIV(I2,2,UI4,1,I4,2);
7718     if (HAVE_OLEAUT32_I8)
7719     {
7720         VARIDIV(I2,2,I8,1,I8,2);
7721         VARIDIV(I2,2,UI8,1,I4,2);
7722     }
7723     VARIDIV(I2,2,INT,1,I4,2);
7724     VARIDIV(I2,2,UINT,1,I4,2);
7725     VARIDIV(I4,2,NULL,0,NULL,0);
7726     VARIDIV(I4,2,I2,1,I4,2);
7727     VARIDIV(I4,2,I4,1,I4,2);
7728     VARIDIV(I4,2,R4,1,I4,2);
7729     VARIDIV(I4,2,R8,1,I4,2);
7730     VARIDIV(I4,2,DATE,1,I4,2);
7731     VARIDIV(I4,2,BSTR,num1_str,I4,2);
7732     VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
7733     VARIDIV(I4,2,I1,1,I4,2);
7734     VARIDIV(I4,2,UI1,1,I4,2);
7735     VARIDIV(I4,2,UI2,1,I4,2);
7736     VARIDIV(I4,2,UI4,1,I4,2);
7737     if (HAVE_OLEAUT32_I8)
7738     {
7739         VARIDIV(I4,2,I8,1,I8,2);
7740         VARIDIV(I4,2,UI8,1,I4,2);
7741     }
7742     VARIDIV(I4,2,INT,1,I4,2);
7743     VARIDIV(I4,2,UINT,1,I4,2);
7744     VARIDIV(R4,2.0f,NULL,0,NULL,0);
7745     VARIDIV(R4,2.0f,I2,1,I4,2);
7746     VARIDIV(R4,2.0f,I4,1,I4,2);
7747     VARIDIV(R4,2.0f,R4,1.0f,I4,2);
7748     VARIDIV(R4,2.0f,R8,1.0,I4,2);
7749     VARIDIV(R4,2.0f,DATE,1,I4,2);
7750     VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
7751     VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
7752     VARIDIV(R4,2.0f,I1,1,I4,2);
7753     VARIDIV(R4,2.0f,UI1,1,I4,2);
7754     VARIDIV(R4,2.0f,UI2,1,I4,2);
7755     VARIDIV(R4,2.0f,UI4,1,I4,2);
7756     if (HAVE_OLEAUT32_I8)
7757     {
7758         VARIDIV(R4,2.0f,I8,1,I8,2);
7759         VARIDIV(R4,2.0f,UI8,1,I4,2);
7760     }
7761     VARIDIV(R4,2.0f,INT,1,I4,2);
7762     VARIDIV(R4,2.0f,UINT,1,I4,2);
7763     VARIDIV(R8,2.0,NULL,0,NULL,0);
7764     VARIDIV(R8,2.0,I2,1,I4,2);
7765     VARIDIV(R8,2.0,I4,1,I4,2);
7766     VARIDIV(R8,2.0,R4,1,I4,2);
7767     VARIDIV(R8,2.0,R8,1,I4,2);
7768     VARIDIV(R8,2.0,DATE,1,I4,2);
7769     VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
7770     VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
7771     VARIDIV(R8,2.0,I1,1,I4,2);
7772     VARIDIV(R8,2.0,UI1,1,I4,2);
7773     VARIDIV(R8,2.0,UI2,1,I4,2);
7774     VARIDIV(R8,2.0,UI4,1,I4,2);
7775     if (HAVE_OLEAUT32_I8)
7776     {
7777         VARIDIV(R8,2.0,I8,1,I8,2);
7778         VARIDIV(R8,2.0,UI8,1,I4,2);
7779     }
7780     VARIDIV(R8,2.0,INT,1,I4,2);
7781     VARIDIV(R8,2.0,UINT,1,I4,2);
7782     VARIDIV(DATE,2,NULL,0,NULL,0);
7783     VARIDIV(DATE,2,I2,1,I4,2);
7784     VARIDIV(DATE,2,I4,1,I4,2);
7785     VARIDIV(DATE,2,R4,1,I4,2);
7786     VARIDIV(DATE,2,R8,1,I4,2);
7787     VARIDIV(DATE,2,DATE,1,I4,2);
7788     VARIDIV(DATE,2,BSTR,num1_str,I4,2);
7789     VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
7790     VARIDIV(DATE,2,I1,1,I4,2);
7791     VARIDIV(DATE,2,UI1,1,I4,2);
7792     VARIDIV(DATE,2,UI2,1,I4,2);
7793     VARIDIV(DATE,2,UI4,1,I4,2);
7794     if (HAVE_OLEAUT32_I8)
7795     {
7796         VARIDIV(DATE,2,I8,1,I8,2);
7797         VARIDIV(DATE,2,UI8,1,I4,2);
7798     }
7799     VARIDIV(DATE,2,INT,1,I4,2);
7800     VARIDIV(DATE,2,UINT,1,I4,2);
7801     VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
7802     VARIDIV(BSTR,num2_str,I2,1,I4,2);
7803     VARIDIV(BSTR,num2_str,I4,1,I4,2);
7804     VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
7805     VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
7806     VARIDIV(BSTR,num2_str,DATE,1,I4,2);
7807     VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
7808     VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
7809     VARIDIV(BSTR,num2_str,I1,1,I4,2);
7810     VARIDIV(BSTR,num2_str,UI1,1,I4,2);
7811     VARIDIV(BSTR,num2_str,UI2,1,I4,2);
7812     VARIDIV(BSTR,num2_str,UI4,1,I4,2);
7813     if (HAVE_OLEAUT32_I8)
7814     {
7815         VARIDIV(BSTR,num2_str,I8,1,I8,2);
7816         VARIDIV(BSTR,num2_str,UI8,1,I4,2);
7817     }
7818     VARIDIV(BSTR,num2_str,INT,1,I4,2);
7819     VARIDIV(BSTR,num2_str,UINT,1,I4,2);
7820     VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7821     VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
7822     VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
7823     VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
7824     VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
7825     VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
7826     VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
7827     VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
7828     VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
7829     VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
7830     VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
7831     VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
7832     if (HAVE_OLEAUT32_I8)
7833     {
7834         VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
7835         VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
7836     }
7837     VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
7838     VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
7839     VARIDIV(I1,2,NULL,0,NULL,0);
7840     VARIDIV(I1,2,I2,1,I4,2);
7841     VARIDIV(I1,2,I4,1,I4,2);
7842     VARIDIV(I1,2,R4,1.0f,I4,2);
7843     VARIDIV(I1,2,R8,1.0,I4,2);
7844     VARIDIV(I1,2,DATE,1,I4,2);
7845     VARIDIV(I1,2,BSTR,num1_str,I4,2);
7846     VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
7847     VARIDIV(I1,2,I1,1,I4,2);
7848     VARIDIV(I1,2,UI1,1,I4,2);
7849     VARIDIV(I1,2,UI2,1,I4,2);
7850     VARIDIV(I1,2,UI4,1,I4,2);
7851     if (HAVE_OLEAUT32_I8)
7852     {
7853         VARIDIV(I1,2,I8,1,I8,2);
7854         VARIDIV(I1,2,UI8,1,I4,2);
7855     }
7856     VARIDIV(I1,2,INT,1,I4,2);
7857     VARIDIV(I1,2,UINT,1,I4,2);
7858     VARIDIV(UI1,2,NULL,0,NULL,0);
7859     VARIDIV(UI1,2,I2,1,I2,2);
7860     VARIDIV(UI1,2,I4,1,I4,2);
7861     VARIDIV(UI1,2,R4,1.0f,I4,2);
7862     VARIDIV(UI1,2,R8,1.0,I4,2);
7863     VARIDIV(UI1,2,DATE,1,I4,2);
7864     VARIDIV(UI1,2,BSTR,num1_str,I4,2);
7865     VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
7866     VARIDIV(UI1,2,I1,1,I4,2);
7867     VARIDIV(UI1,2,UI1,1,UI1,2);
7868     VARIDIV(UI1,2,UI2,1,I4,2);
7869     VARIDIV(UI1,2,UI4,1,I4,2);
7870     if (HAVE_OLEAUT32_I8)
7871     {
7872         VARIDIV(UI1,2,I8,1,I8,2);
7873         VARIDIV(UI1,2,UI8,1,I4,2);
7874     }
7875     VARIDIV(UI1,2,INT,1,I4,2);
7876     VARIDIV(UI1,2,UINT,1,I4,2);
7877     VARIDIV(UI2,2,NULL,0,NULL,0);
7878     VARIDIV(UI2,2,I2,1,I4,2);
7879     VARIDIV(UI2,2,I4,1,I4,2);
7880     VARIDIV(UI2,2,R4,1.0f,I4,2);
7881     VARIDIV(UI2,2,R8,1.0,I4,2);
7882     VARIDIV(UI2,2,DATE,1,I4,2);
7883     VARIDIV(UI2,2,BSTR,num1_str,I4,2);
7884     VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
7885     VARIDIV(UI2,2,I1,1,I4,2);
7886     VARIDIV(UI2,2,UI1,1,I4,2);
7887     VARIDIV(UI2,2,UI2,1,I4,2);
7888     VARIDIV(UI2,2,UI4,1,I4,2);
7889     if (HAVE_OLEAUT32_I8)
7890     {
7891         VARIDIV(UI2,2,I8,1,I8,2);
7892         VARIDIV(UI2,2,UI8,1,I4,2);
7893     }
7894     VARIDIV(UI2,2,INT,1,I4,2);
7895     VARIDIV(UI2,2,UINT,1,I4,2);
7896     VARIDIV(UI4,2,NULL,0,NULL,0);
7897     VARIDIV(UI4,2,I2,1,I4,2);
7898     VARIDIV(UI4,2,I4,1,I4,2);
7899     VARIDIV(UI4,2,R4,1.0f,I4,2);
7900     VARIDIV(UI4,2,R8,1.0,I4,2);
7901     VARIDIV(UI4,2,DATE,1,I4,2);
7902     VARIDIV(UI4,2,BSTR,num1_str,I4,2);
7903     VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
7904     VARIDIV(UI4,2,I1,1,I4,2);
7905     VARIDIV(UI4,2,UI1,1,I4,2);
7906     VARIDIV(UI4,2,UI2,1,I4,2);
7907     VARIDIV(UI4,2,UI4,1,I4,2);
7908     if (HAVE_OLEAUT32_I8)
7909     {
7910         VARIDIV(UI4,2,I8,1,I8,2);
7911         VARIDIV(UI4,2,UI8,1,I4,2);
7912     }
7913     VARIDIV(UI4,2,INT,1,I4,2);
7914     VARIDIV(UI4,2,UINT,1,I4,2);
7915     if (HAVE_OLEAUT32_I8)
7916     {
7917         VARIDIV(I8,2,NULL,0,NULL,0);
7918         VARIDIV(I8,2,I2,1,I8,2);
7919         VARIDIV(I8,2,I4,1,I8,2);
7920         VARIDIV(I8,2,R4,1.0f,I8,2);
7921         VARIDIV(I8,2,R8,1.0,I8,2);
7922         VARIDIV(I8,2,DATE,1,I8,2);
7923         VARIDIV(I8,2,BSTR,num1_str,I8,2);
7924         VARIDIV(I8,2,BOOL,1,I8,2);
7925         VARIDIV(I8,2,I1,1,I8,2);
7926         VARIDIV(I8,2,UI1,1,I8,2);
7927         VARIDIV(I8,2,UI2,1,I8,2);
7928         VARIDIV(I8,2,UI4,1,I8,2);
7929         VARIDIV(I8,2,I8,1,I8,2);
7930         VARIDIV(I8,2,UI8,1,I8,2);
7931         VARIDIV(I8,2,UINT,1,I8,2);
7932         VARIDIV(UI8,2,NULL,0,NULL,0);
7933         VARIDIV(UI8,2,I2,1,I4,2);
7934         VARIDIV(UI8,2,I4,1,I4,2);
7935         VARIDIV(UI8,2,R4,1.0f,I4,2);
7936         VARIDIV(UI8,2,R8,1.0,I4,2);
7937         VARIDIV(UI8,2,DATE,1,I4,2);
7938         VARIDIV(UI8,2,BSTR,num1_str,I4,2);
7939         VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
7940         VARIDIV(UI8,2,I1,1,I4,2);
7941         VARIDIV(UI8,2,UI1,1,I4,2);
7942         VARIDIV(UI8,2,UI2,1,I4,2);
7943         VARIDIV(UI8,2,UI4,1,I4,2);
7944         VARIDIV(UI8,2,I8,1,I8,2);
7945         VARIDIV(UI8,2,UI8,1,I4,2);
7946         VARIDIV(UI8,2,INT,1,I4,2);
7947         VARIDIV(UI8,2,UINT,1,I4,2);
7948     }
7949     VARIDIV(INT,2,NULL,0,NULL,0);
7950     VARIDIV(INT,2,I2,1,I4,2);
7951     VARIDIV(INT,2,I4,1,I4,2);
7952     VARIDIV(INT,2,R4,1.0f,I4,2);
7953     VARIDIV(INT,2,R8,1.0,I4,2);
7954     VARIDIV(INT,2,DATE,1,I4,2);
7955     VARIDIV(INT,2,BSTR,num1_str,I4,2);
7956     VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
7957     VARIDIV(INT,2,I1,1,I4,2);
7958     VARIDIV(INT,2,UI1,1,I4,2);
7959     VARIDIV(INT,2,UI2,1,I4,2);
7960     VARIDIV(INT,2,UI4,1,I4,2);
7961     if (HAVE_OLEAUT32_I8)
7962     {
7963         VARIDIV(INT,2,UI8,1,I4,2);
7964     }
7965     VARIDIV(INT,2,INT,1,I4,2);
7966     VARIDIV(INT,2,UINT,1,I4,2);
7967     VARIDIV(UINT,2,NULL,0,NULL,0);
7968     VARIDIV(UINT,2,I2,1,I4,2);
7969     VARIDIV(UINT,2,I4,1,I4,2);
7970     VARIDIV(UINT,2,R4,1.0f,I4,2);
7971     VARIDIV(UINT,2,R8,1.0,I4,2);
7972     VARIDIV(UINT,2,DATE,1,I4,2);
7973     VARIDIV(UINT,2,BSTR,num1_str,I4,2);
7974     VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
7975     VARIDIV(UINT,2,I1,1,I4,2);
7976     VARIDIV(UINT,2,UI1,1,I4,2);
7977     VARIDIV(UINT,2,UI2,1,I4,2);
7978     VARIDIV(UINT,2,UI4,1,I4,2);
7979     if (HAVE_OLEAUT32_I8)
7980     {
7981         VARIDIV(UINT,2,I8,1,I8,2);
7982         VARIDIV(UINT,2,UI8,1,I4,2);
7983     }
7984     VARIDIV(UINT,2,INT,1,I4,2);
7985     VARIDIV(UINT,2,UINT,1,I4,2);
7986
7987     /* Manually test some VT_CY, VT_DECIMAL variants */
7988     V_VT(&cy) = VT_CY;
7989     hres = VarCyFromI4(10000, &V_CY(&cy));
7990     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7991     V_VT(&dec) = VT_DECIMAL;
7992     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7993     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7994     memset(&left, 0, sizeof(left));
7995     memset(&right, 0, sizeof(right));
7996     V_VT(&left) = VT_I4;
7997     V_I4(&left) = 100;
7998     V_VT(&right) = VT_I8;
7999     V_UI1(&right) = 2;
8000
8001     hres = VarIdiv(&cy, &cy, &result);
8002     ok(hres == S_OK && V_VT(&result) == VT_I4,
8003         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8004         S_OK, hres, vtstr(V_VT(&result)));
8005     ok(hres == S_OK && V_I4(&result) == 1,
8006         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
8007
8008     if (HAVE_OLEAUT32_I8)
8009     {
8010         hres = VarIdiv(&cy, &right, &result);
8011         ok(hres == S_OK && V_VT(&result) == VT_I8,
8012             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8013             S_OK, hres, vtstr(V_VT(&result)));
8014         ok(hres == S_OK && V_I8(&result) == 5000,
8015             "VARIDIV: CY value 0x%x%08x, expected 0x%x\n",
8016             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), 5000);
8017     }
8018
8019     hres = VarIdiv(&left, &cy, &result);
8020     ok(hres == S_OK && V_VT(&result) == VT_I4,
8021         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8022         S_OK, hres, vtstr(V_VT(&result)));
8023     ok(hres == S_OK && V_I4(&result) == 0,
8024         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 0);
8025
8026     hres = VarIdiv(&left, &dec, &result);
8027     ok(hres == S_OK && V_VT(&result) == VT_I4,
8028         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8029         S_OK, hres, vtstr(V_VT(&result)));
8030     ok(hres == S_OK && V_I4(&result) == 50,
8031         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 50);
8032
8033     hres = VarIdiv(&dec, &dec, &result);
8034     ok(hres == S_OK && V_VT(&result) == VT_I4,
8035         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8036         S_OK, hres, vtstr(V_VT(&result)));
8037     ok(hres == S_OK && V_I4(&result) == 1,
8038         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
8039
8040     if (HAVE_OLEAUT32_I8)
8041     {
8042         hres = VarIdiv(&dec, &right, &result);
8043         ok(hres == S_OK && V_VT(&result) == VT_I8,
8044             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8045             S_OK, hres, vtstr(V_VT(&result)));
8046         ok(hres == S_OK && V_I8(&result) == 1,
8047             "VARIDIV: DECIMAL value 0x%x%08x, expected %d\n",
8048             (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result), 1);
8049     }
8050
8051     /* Check for division by zero */
8052     V_VT(&left) = VT_INT;
8053     V_I4(&left) = 1;
8054     V_VT(&right) = VT_INT;
8055     V_I4(&right) = 0;
8056     hres = pVarIdiv(&left, &right, &result);
8057     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8058         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8059
8060     V_VT(&left) = VT_INT;
8061     V_I4(&left) = 0;
8062     V_VT(&right) = VT_INT;
8063     V_I4(&right) = 0;
8064     hres = pVarIdiv(&left, &right, &result);
8065     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8066         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8067
8068     SysFreeString(num1_str);
8069     SysFreeString(num2_str);
8070 }
8071
8072
8073 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
8074
8075 #define VARIMP(vt1,val1,vt2,val2,rvt,rval)              \
8076         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
8077         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8078         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
8079         test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
8080
8081 /* Skip any type that is not defined or produces an error for every case */
8082 #define SKIPTESTIMP(a)                            \
8083     if (a == VT_ERROR || a == VT_VARIANT ||       \
8084         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
8085         a == VT_RECORD || a > VT_UINT ||          \
8086         a == 15 /*not defined*/)                  \
8087         continue
8088
8089 static void test_VarImp(void)
8090 {
8091     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
8092     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
8093     VARIANT left, right, exp, result, cy, dec;
8094     BSTR true_str, false_str;
8095     VARTYPE i;
8096     HRESULT hres;
8097
8098     CHECKPTR(VarImp);
8099
8100     true_str = SysAllocString(szTrue);
8101     false_str = SysAllocString(szFalse);
8102
8103     /* Test all possible flag/vt combinations & the resulting vt type */
8104     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
8105     {
8106         VARTYPE leftvt, rightvt, resvt;
8107
8108         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8109         {
8110             SKIPTESTIMP(leftvt);
8111
8112             /* Check if we need/have support for I8 and/or UI8 */
8113             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8114                 continue;
8115
8116             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8117             {
8118                 BOOL bFail = FALSE;
8119                 SKIPTESTIMP(rightvt);
8120
8121                 /* Native crashes when using the extra flag VT_BYREF
8122                  * or with the following VT combinations
8123                  */
8124                 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
8125                     (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
8126                     ExtraFlags[i] == VT_BYREF)
8127                     continue;
8128
8129                 /* Check if we need/have support for I8 and/or UI8 */
8130                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8131                     continue;
8132
8133                 memset(&left, 0, sizeof(left));
8134                 memset(&right, 0, sizeof(right));
8135                 V_VT(&left) = leftvt | ExtraFlags[i];
8136                 V_VT(&right) = rightvt | ExtraFlags[i];
8137                 V_VT(&result) = VT_EMPTY;
8138                 resvt = VT_EMPTY;
8139
8140                 if (leftvt == VT_BSTR)
8141                     V_BSTR(&left) = true_str;
8142
8143                 /* This allows us to test return types that are not NULL
8144                  * (NULL Imp value = n, NULL Imp 0 = NULL)
8145                  */
8146                 switch(rightvt)
8147                 {
8148                 case VT_BSTR:
8149                     V_BSTR(&right) = true_str;
8150                     break;
8151                 case VT_DECIMAL:
8152                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8153                     V_VT(&right) = rightvt | ExtraFlags[i];
8154                     break;
8155                 case VT_BOOL:
8156                     V_BOOL(&right) = VARIANT_TRUE;
8157                     break;
8158                 case VT_I1: V_I1(&right) = 2; break;
8159                 case VT_I2: V_I2(&right) = 2; break;
8160                 case VT_I4: V_I4(&right) = 2; break;
8161                 case VT_R4: V_R4(&right) = 2.0f; break;
8162                 case VT_R8: V_R8(&right) = 2.0; break;
8163                 case VT_CY: V_CY(&right).int64 = 10000; break;
8164                 case VT_DATE: V_DATE(&right) = 2; break;
8165                 case VT_I8: V_I8(&right) = 2; break;
8166                 case VT_INT: V_INT(&right) = 2; break;
8167                 case VT_UINT: V_UINT(&right) = 2; break;
8168                 case VT_UI1: V_UI1(&right) = 2; break;
8169                 case VT_UI2: V_UI2(&right) = 2; break;
8170                 case VT_UI4: V_UI4(&right) = 2; break;
8171                 case VT_UI8: V_UI8(&right) = 2; break;
8172                 default: break;
8173                 }
8174
8175                 /* Native VarImp always returns an error when using extra
8176                  * flags or if the variants are I8 and INT.
8177                  */
8178                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8179                     ExtraFlags[i] != 0)
8180                     bFail = TRUE;
8181
8182                 /* Determine result type */
8183                 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
8184                     (leftvt == VT_NULL && rightvt == VT_NULL) ||
8185                     (leftvt == VT_NULL && rightvt == VT_EMPTY))
8186                     resvt = VT_NULL;
8187                 else if (leftvt == VT_I8 || rightvt == VT_I8)
8188                     resvt = VT_I8;
8189                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8190                     leftvt == VT_INT || rightvt == VT_INT ||
8191                     leftvt == VT_UINT || rightvt == VT_UINT ||
8192                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
8193                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
8194                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
8195                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8196                     leftvt == VT_DATE || rightvt == VT_DATE ||
8197                     leftvt == VT_CY || rightvt == VT_CY ||
8198                     leftvt == VT_R8 || rightvt == VT_R8 ||
8199                     leftvt == VT_R4 || rightvt == VT_R4 ||
8200                     leftvt == VT_I1 || rightvt == VT_I1)
8201                     resvt = VT_I4;
8202                 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
8203                     (leftvt == VT_UI1 && rightvt == VT_NULL) ||
8204                     (leftvt == VT_NULL && rightvt == VT_UI1))
8205                     resvt = VT_UI1;
8206                 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
8207                     leftvt == VT_I2 || rightvt == VT_I2 ||
8208                     leftvt == VT_UI1 || rightvt == VT_UI1)
8209                     resvt = VT_I2;
8210                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
8211                     leftvt == VT_BSTR || rightvt == VT_BSTR)
8212                     resvt = VT_BOOL;
8213
8214                 hres = pVarImp(&left, &right, &result);
8215
8216                 /* Check expected HRESULT and if result variant type is correct */
8217                 if (bFail)
8218                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
8219                         "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
8220                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
8221                         vtstr(V_VT(&result)), hres);
8222                 else
8223                     ok (hres == S_OK && resvt == V_VT(&result),
8224                         "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
8225                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
8226                         S_OK, vtstr(V_VT(&result)), hres);
8227             }
8228         }
8229     }
8230
8231     VARIMP(EMPTY,0,EMPTY,0,I2,-1);
8232     VARIMP(EMPTY,0,NULL,0,I2,-1);
8233     VARIMP(EMPTY,0,I2,-1,I2,-1);
8234     VARIMP(EMPTY,0,I4,-1,I4,-1);
8235     VARIMP(EMPTY,0,R4,0.0f,I4,-1);
8236     VARIMP(EMPTY,0,R8,-1.0,I4,-1);
8237     VARIMP(EMPTY,0,DATE,0,I4,-1);
8238     VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
8239     VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
8240     VARIMP(EMPTY,0,I1,0,I4,-1);
8241     VARIMP(EMPTY,0,UI1,1,I2,-1);
8242     VARIMP(EMPTY,0,UI2,1,I4,-1);
8243     VARIMP(EMPTY,0,UI4,1,I4,-1);
8244     if (HAVE_OLEAUT32_I8)
8245     {
8246         VARIMP(EMPTY,0,I8,1,I8,-1);
8247         VARIMP(EMPTY,0,UI8,1,I4,-1);
8248     }
8249     VARIMP(EMPTY,0,INT,-1,I4,-1);
8250     VARIMP(EMPTY,0,UINT,1,I4,-1);
8251     VARIMP(NULL,0,EMPTY,0,NULL,0);
8252     VARIMP(NULL,0,NULL,0,NULL,0);
8253     VARIMP(NULL,0,I2,-1,I2,-1);
8254     VARIMP(NULL,0,I4,-1,I4,-1);
8255     VARIMP(NULL,0,R4,0.0f,NULL,0);
8256     VARIMP(NULL,0,R8,-1.0,I4,-1);
8257     VARIMP(NULL,0,DATE,0,NULL,0);
8258     VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
8259     VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
8260     VARIMP(NULL,0,I1,0,NULL,0);
8261     VARIMP(NULL,0,UI1,1,UI1,1);
8262     VARIMP(NULL,0,UI2,1,I4,1);
8263     VARIMP(NULL,0,UI4,1,I4,1);
8264     if (HAVE_OLEAUT32_I8)
8265     {
8266         VARIMP(NULL,0,I8,1,I8,1);
8267         VARIMP(NULL,0,UI8,1,I4,1);
8268     }
8269     VARIMP(NULL,0,INT,-1,I4,-1);
8270     VARIMP(NULL,0,UINT,1,I4,1);
8271     VARIMP(I2,-1,EMPTY,0,I2,0);
8272     VARIMP(I2,-1,I2,-1,I2,-1);
8273     VARIMP(I2,-1,I4,-1,I4,-1);
8274     VARIMP(I2,-1,R4,0.0f,I4,0);
8275     VARIMP(I2,-1,R8,-1.0,I4,-1);
8276     VARIMP(I2,-1,DATE,0,I4,0);
8277     VARIMP(I2,-1,BSTR,true_str,I2,-1);
8278     VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
8279     VARIMP(I2,-1,I1,0,I4,0);
8280     VARIMP(I2,-1,UI1,1,I2,1);
8281     VARIMP(I2,-1,UI2,1,I4,1);
8282     VARIMP(I2,-1,UI4,1,I4,1);
8283     if (HAVE_OLEAUT32_I8)
8284     {
8285         VARIMP(I2,-1,I8,1,I8,1);
8286         VARIMP(I2,-1,UI8,1,I4,1);
8287     }
8288     VARIMP(I2,-1,INT,-1,I4,-1);
8289     VARIMP(I2,-1,UINT,1,I4,1);
8290     VARIMP(I4,2,EMPTY,0,I4,-3);
8291     VARIMP(I4,2,NULL,0,I4,-3);
8292     VARIMP(I4,2,I2,-1,I4,-1);
8293     VARIMP(I4,2,I4,-1,I4,-1);
8294     VARIMP(I4,2,R4,0.0f,I4,-3);
8295     VARIMP(I4,2,R8,-1.0,I4,-1);
8296     VARIMP(I4,2,DATE,0,I4,-3);
8297     VARIMP(I4,2,BSTR,true_str,I4,-1);
8298     VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
8299     VARIMP(I4,2,I1,0,I4,-3);
8300     VARIMP(I4,2,UI1,1,I4,-3);
8301     VARIMP(I4,2,UI2,1,I4,-3);
8302     VARIMP(I4,2,UI4,1,I4,-3);
8303     if (HAVE_OLEAUT32_I8)
8304     {
8305         VARIMP(I4,2,I8,1,I8,-3);
8306         VARIMP(I4,2,UI8,1,I4,-3);
8307     }
8308     VARIMP(I4,2,INT,-1,I4,-1);
8309     VARIMP(I4,2,UINT,1,I4,-3);
8310     VARIMP(R4,-1.0f,EMPTY,0,I4,0);
8311     VARIMP(R4,-1.0f,NULL,0,NULL,0);
8312     VARIMP(R4,-1.0f,I2,-1,I4,-1);
8313     VARIMP(R4,-1.0f,I4,-1,I4,-1);
8314     VARIMP(R4,-1.0f,R4,0.0f,I4,0);
8315     VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
8316     VARIMP(R4,-1.0f,DATE,1,I4,1);
8317     VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
8318     VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
8319     VARIMP(R4,-1.0f,I1,0,I4,0);
8320     VARIMP(R4,-1.0f,UI1,1,I4,1);
8321     VARIMP(R4,-1.0f,UI2,1,I4,1);
8322     VARIMP(R4,-1.0f,UI4,1,I4,1);
8323     if (HAVE_OLEAUT32_I8)
8324     {
8325         VARIMP(R4,-1.0f,I8,1,I8,1);
8326         VARIMP(R4,-1.0f,UI8,1,I4,1);
8327     }
8328     VARIMP(R4,-1.0f,INT,-1,I4,-1);
8329     VARIMP(R4,-1.0f,UINT,1,I4,1);
8330     VARIMP(R8,1.0,EMPTY,0,I4,-2);
8331     VARIMP(R8,1.0,NULL,0,I4,-2);
8332     VARIMP(R8,1.0,I2,-1,I4,-1);
8333     VARIMP(R8,1.0,I4,-1,I4,-1);
8334     VARIMP(R8,1.0,R4,0.0f,I4,-2);
8335     VARIMP(R8,1.0,R8,-1.0,I4,-1);
8336     VARIMP(R8,1.0,DATE,0,I4,-2);
8337     VARIMP(R8,1.0,BSTR,true_str,I4,-1);
8338     VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
8339     VARIMP(R8,1.0,I1,0,I4,-2);
8340     VARIMP(R8,1.0,UI1,1,I4,-1);
8341     VARIMP(R8,1.0,UI2,1,I4,-1);
8342     VARIMP(R8,1.0,UI4,1,I4,-1);
8343     if (HAVE_OLEAUT32_I8)
8344     {
8345         VARIMP(R8,1.0,I8,1,I8,-1);
8346         VARIMP(R8,1.0,UI8,1,I4,-1);
8347     }
8348     VARIMP(R8,1.0,INT,-1,I4,-1);
8349     VARIMP(R8,1.0,UINT,1,I4,-1);
8350     VARIMP(DATE,0,EMPTY,0,I4,-1);
8351     VARIMP(DATE,0,NULL,0,I4,-1);
8352     VARIMP(DATE,0,I2,-1,I4,-1);
8353     VARIMP(DATE,0,I4,-1,I4,-1);
8354     VARIMP(DATE,0,R4,0.0f,I4,-1);
8355     VARIMP(DATE,0,R8,-1.0,I4,-1);
8356     VARIMP(DATE,0,DATE,0,I4,-1);
8357     VARIMP(DATE,0,BSTR,true_str,I4,-1);
8358     VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
8359     VARIMP(DATE,0,I1,0,I4,-1);
8360     VARIMP(DATE,0,UI1,1,I4,-1);
8361     VARIMP(DATE,0,UI2,1,I4,-1);
8362     VARIMP(DATE,0,UI4,1,I4,-1);
8363     if (HAVE_OLEAUT32_I8)
8364     {
8365         VARIMP(DATE,0,I8,1,I8,-1);
8366         VARIMP(DATE,0,UI8,1,I4,-1);
8367     }
8368     VARIMP(DATE,0,INT,-1,I4,-1);
8369     VARIMP(DATE,0,UINT,1,I4,-1);
8370     VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
8371     VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
8372     VARIMP(BSTR,false_str,I2,-1,I2,-1);
8373     VARIMP(BSTR,false_str,I4,-1,I4,-1);
8374     VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
8375     VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
8376     VARIMP(BSTR,false_str,DATE,0,I4,-1);
8377     VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
8378     VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
8379     VARIMP(BSTR,false_str,I1,0,I4,-1);
8380     VARIMP(BSTR,false_str,UI1,1,I2,-1);
8381     VARIMP(BSTR,false_str,UI2,1,I4,-1);
8382     VARIMP(BSTR,false_str,UI4,1,I4,-1);
8383     if (HAVE_OLEAUT32_I8)
8384     {
8385         VARIMP(BSTR,false_str,I8,1,I8,-1);
8386         VARIMP(BSTR,false_str,UI8,1,I4,-1);
8387     }
8388     VARIMP(BSTR,false_str,INT,-1,I4,-1);
8389     VARIMP(BSTR,false_str,UINT,1,I4,-1);
8390     VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
8391     VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8392     VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
8393     VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
8394     VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
8395     VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
8396     VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
8397     VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
8398     VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
8399     VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
8400     VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
8401     VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
8402     VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
8403     if (HAVE_OLEAUT32_I8)
8404     {
8405         VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
8406         VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
8407     }
8408     VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
8409     VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
8410     VARIMP(I1,-1,EMPTY,0,I4,0);
8411     VARIMP(I1,-1,NULL,0,NULL,0);
8412     VARIMP(I1,-1,I2,-1,I4,-1);
8413     VARIMP(I1,-1,I4,-1,I4,-1);
8414     VARIMP(I1,-1,R4,0.0f,I4,0);
8415     VARIMP(I1,-1,R8,-1.0,I4,-1);
8416     VARIMP(I1,-1,DATE,0,I4,0);
8417     VARIMP(I1,-1,BSTR,true_str,I4,-1);
8418     VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
8419     VARIMP(I1,-1,I1,0,I4,0);
8420     VARIMP(I1,-1,UI1,1,I4,1);
8421     VARIMP(I1,-1,UI2,1,I4,1);
8422     VARIMP(I1,-1,UI4,1,I4,1);
8423     if (HAVE_OLEAUT32_I8)
8424     {
8425         VARIMP(I1,-1,I8,1,I8,1);
8426         VARIMP(I1,-1,UI8,1,I4,1);
8427     }
8428     VARIMP(I1,-1,INT,-1,I4,-1);
8429     VARIMP(I1,-1,UINT,1,I4,1);
8430     VARIMP(UI1,0,EMPTY,0,I2,-1);
8431     VARIMP(UI1,0,NULL,0,UI1,255);
8432     VARIMP(UI1,0,I2,-1,I2,-1);
8433     VARIMP(UI1,0,I4,-1,I4,-1);
8434     VARIMP(UI1,0,R4,0.0f,I4,-1);
8435     VARIMP(UI1,0,R8,-1.0,I4,-1);
8436     VARIMP(UI1,0,DATE,0,I4,-1);
8437     VARIMP(UI1,0,BSTR,true_str,I2,-1);
8438     VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
8439     VARIMP(UI1,0,I1,0,I4,-1);
8440     VARIMP(UI1,0,UI1,1,UI1,255);
8441     VARIMP(UI1,0,UI2,1,I4,-1);
8442     VARIMP(UI1,0,UI4,1,I4,-1);
8443     if (HAVE_OLEAUT32_I8)
8444     {
8445         VARIMP(UI1,0,I8,1,I8,-1);
8446         VARIMP(UI1,0,UI8,1,I4,-1);
8447     }
8448     VARIMP(UI1,0,INT,-1,I4,-1);
8449     VARIMP(UI1,0,UINT,1,I4,-1);
8450     VARIMP(UI2,0,EMPTY,0,I4,-1);
8451     VARIMP(UI2,0,NULL,0,I4,-1);
8452     VARIMP(UI2,0,I2,-1,I4,-1);
8453     VARIMP(UI2,0,I4,-1,I4,-1);
8454     VARIMP(UI2,0,R4,0.0f,I4,-1);
8455     VARIMP(UI2,0,R8,-1.0,I4,-1);
8456     VARIMP(UI2,0,DATE,0,I4,-1);
8457     VARIMP(UI2,0,BSTR,true_str,I4,-1);
8458     VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
8459     VARIMP(UI2,0,I1,0,I4,-1);
8460     VARIMP(UI2,0,UI1,1,I4,-1);
8461     VARIMP(UI2,0,UI2,1,I4,-1);
8462     VARIMP(UI2,0,UI4,1,I4,-1);
8463     if (HAVE_OLEAUT32_I8)
8464     {
8465         VARIMP(UI2,0,I8,1,I8,-1);
8466         VARIMP(UI2,0,UI8,1,I4,-1);
8467     }
8468     VARIMP(UI2,0,INT,-1,I4,-1);
8469     VARIMP(UI2,0,UINT,1,I4,-1);
8470     VARIMP(UI4,0,EMPTY,0,I4,-1);
8471     VARIMP(UI4,0,NULL,0,I4,-1);
8472     VARIMP(UI4,0,I2,-1,I4,-1);
8473     VARIMP(UI4,0,I4,-1,I4,-1);
8474     VARIMP(UI4,0,R4,0.0f,I4,-1);
8475     VARIMP(UI4,0,R8,-1.0,I4,-1);
8476     VARIMP(UI4,0,DATE,0,I4,-1);
8477     VARIMP(UI4,0,BSTR,true_str,I4,-1);
8478     VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
8479     VARIMP(UI4,0,I1,0,I4,-1);
8480     VARIMP(UI4,0,UI1,1,I4,-1);
8481     VARIMP(UI4,0,UI2,1,I4,-1);
8482     VARIMP(UI4,0,UI4,1,I4,-1);
8483     if (HAVE_OLEAUT32_I8)
8484     {
8485         VARIMP(UI4,0,I8,1,I8,-1);
8486         VARIMP(UI4,0,UI8,1,I4,-1);
8487     }
8488     VARIMP(UI4,0,INT,-1,I4,-1);
8489     VARIMP(UI4,0,UINT,1,I4,-1);
8490     if (HAVE_OLEAUT32_I8)
8491     {
8492         VARIMP(I8,-1,EMPTY,0,I8,0);
8493         VARIMP(I8,-1,NULL,0,NULL,0);
8494         VARIMP(I8,-1,I2,-1,I8,-1);
8495         VARIMP(I8,-1,I4,-1,I8,-1);
8496         VARIMP(I8,-1,R4,0.0f,I8,0);
8497         VARIMP(I8,-1,R8,-1.0,I8,-1);
8498         VARIMP(I8,-1,DATE,0,I8,0);
8499         VARIMP(I8,-1,BSTR,true_str,I8,-1);
8500         VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
8501         VARIMP(I8,-1,I1,0,I8,0);
8502         VARIMP(I8,-1,UI1,1,I8,1);
8503         VARIMP(I8,-1,UI2,1,I8,1);
8504         VARIMP(I8,-1,UI4,1,I8,1);
8505         VARIMP(I8,-1,I8,1,I8,1);
8506         VARIMP(I8,-1,UI8,1,I8,1);
8507         VARIMP(I8,-1,UINT,1,I8,1);
8508         VARIMP(UI8,0,EMPTY,0,I4,-1);
8509         VARIMP(UI8,0,NULL,0,I4,-1);
8510         VARIMP(UI8,0,I2,-1,I4,-1);
8511         VARIMP(UI8,0,I4,-1,I4,-1);
8512         VARIMP(UI8,0,R4,0.0f,I4,-1);
8513         VARIMP(UI8,0,R8,-1.0,I4,-1);
8514         VARIMP(UI8,0,DATE,0,I4,-1);
8515         VARIMP(UI8,0,BSTR,true_str,I4,-1);
8516         VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
8517         VARIMP(UI8,0,I1,0,I4,-1);
8518         VARIMP(UI8,0,UI1,1,I4,-1);
8519         VARIMP(UI8,0,UI2,1,I4,-1);
8520         VARIMP(UI8,0,UI4,1,I4,-1);
8521         VARIMP(UI8,0,I8,1,I8,-1);
8522         VARIMP(UI8,0,UI8,1,I4,-1);
8523         VARIMP(UI8,0,INT,-1,I4,-1);
8524         VARIMP(UI8,0,UINT,1,I4,-1);
8525     }
8526     VARIMP(INT,-1,EMPTY,0,I4,0);
8527     VARIMP(INT,-1,NULL,0,NULL,0);
8528     VARIMP(INT,-1,I2,-1,I4,-1);
8529     VARIMP(INT,-1,I4,-1,I4,-1);
8530     VARIMP(INT,-1,R4,0.0f,I4,0);
8531     VARIMP(INT,-1,R8,-1.0,I4,-1);
8532     VARIMP(INT,-1,DATE,0,I4,0);
8533     VARIMP(INT,-1,BSTR,true_str,I4,-1);
8534     VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
8535     VARIMP(INT,-1,I1,0,I4,0);
8536     VARIMP(INT,-1,UI1,1,I4,1);
8537     VARIMP(INT,-1,UI2,1,I4,1);
8538     VARIMP(INT,-1,UI4,1,I4,1);
8539     if (HAVE_OLEAUT32_I8)
8540     {
8541         VARIMP(INT,-1,I8,1,I8,1);
8542         VARIMP(INT,-1,UI8,1,I4,1);
8543     }
8544     VARIMP(INT,-1,INT,-1,I4,-1);
8545     VARIMP(INT,-1,UINT,1,I4,1);
8546     VARIMP(UINT,1,EMPTY,0,I4,-2);
8547     VARIMP(UINT,1,NULL,0,I4,-2);
8548     VARIMP(UINT,1,I2,-1,I4,-1);
8549     VARIMP(UINT,1,I4,-1,I4,-1);
8550     VARIMP(UINT,1,R4,0.0f,I4,-2);
8551     VARIMP(UINT,1,R8,-1.0,I4,-1);
8552     VARIMP(UINT,1,DATE,0,I4,-2);
8553     VARIMP(UINT,1,BSTR,true_str,I4,-1);
8554     VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
8555     VARIMP(UINT,1,I1,0,I4,-2);
8556     VARIMP(UINT,1,UI1,1,I4,-1);
8557     VARIMP(UINT,1,UI2,1,I4,-1);
8558     VARIMP(UINT,1,UI4,1,I4,-1);
8559     if (HAVE_OLEAUT32_I8)
8560     {
8561         VARIMP(UINT,1,I8,1,I8,-1);
8562         VARIMP(UINT,1,UI8,1,I4,-1);
8563     }
8564     VARIMP(UINT,1,INT,-1,I4,-1);
8565     VARIMP(UINT,1,UINT,1,I4,-1);
8566
8567     /* Manually test some VT_CY, VT_DECIMAL variants */
8568     V_VT(&cy) = VT_CY;
8569     hres = VarCyFromI4(1, &V_CY(&cy));
8570     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8571     V_VT(&dec) = VT_DECIMAL;
8572     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8573     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8574     memset(&left, 0, sizeof(left));
8575     memset(&right, 0, sizeof(right));
8576     V_VT(&left) = VT_I4;
8577     V_I4(&left) = 0;
8578     V_VT(&right) = VT_I8;
8579     V_UI1(&right) = 0;
8580
8581     hres = pVarImp(&cy, &cy, &result);
8582     ok(hres == S_OK && V_VT(&result) == VT_I4,
8583         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8584         S_OK, hres, vtstr(V_VT(&result)));
8585     ok(hres == S_OK && V_I4(&result) == -1,
8586         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8587
8588     if (HAVE_OLEAUT32_I8)
8589     {
8590         hres = pVarImp(&cy, &right, &result);
8591         ok(hres == S_OK && V_VT(&result) == VT_I8,
8592             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8593             S_OK, hres, vtstr(V_VT(&result)));
8594         ok(hres == S_OK && V_I8(&result) == -2,
8595             "VARIMP: CY value %x%08x, expected %d\n",
8596             (DWORD)((V_I8(&result)) >> 32), (DWORD)(V_I8(&result)), -2);
8597     }
8598
8599     hres = pVarImp(&left, &cy, &result);
8600     ok(hres == S_OK && V_VT(&result) == VT_I4,
8601         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8602         S_OK, hres, vtstr(V_VT(&result)));
8603     ok(hres == S_OK && V_I4(&result) == -1,
8604         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8605
8606     hres = pVarImp(&left, &dec, &result);
8607     ok(hres == S_OK && V_VT(&result) == VT_I4,
8608         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8609         S_OK, hres, vtstr(V_VT(&result)));
8610     ok(hres == S_OK && V_I4(&result) == -1,
8611         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8612
8613     hres = pVarImp(&dec, &dec, &result);
8614     ok(hres == S_OK && V_VT(&result) == VT_I4,
8615         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8616         S_OK, hres, vtstr(V_VT(&result)));
8617     ok(hres == S_OK && V_I4(&result) == -1,
8618         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8619
8620     if (HAVE_OLEAUT32_I8)
8621     {
8622         hres = pVarImp(&dec, &right, &result);
8623         ok(hres == S_OK && V_VT(&result) == VT_I8,
8624             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8625             S_OK, hres, vtstr(V_VT(&result)));
8626         ok(hres == S_OK && V_I8(&result) == -3,
8627             "VARIMP: DECIMAL value 0x%x%08x, expected %d\n",
8628             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), -3);
8629     }
8630
8631     SysFreeString(false_str);
8632     SysFreeString(true_str);
8633 }
8634
8635 START_TEST(vartest)
8636 {
8637   init();
8638
8639   test_VariantInit();
8640   test_VariantClear();
8641   test_VariantCopy();
8642   test_VariantCopyInd();
8643   test_VarParseNumFromStr();
8644   test_VarNumFromParseNum();
8645   test_VarUdateFromDate();
8646   test_VarDateFromUdate();
8647   test_SystemTimeToVariantTime();
8648   test_VariantTimeToSystemTime();
8649   test_DosDateTimeToVariantTime();
8650   test_VariantTimeToDosDateTime();
8651   test_VarAbs();
8652   test_VarNot();
8653   test_VarSub();
8654   test_VarMod();
8655   test_VarFix();
8656   test_VarInt();
8657   test_VarNeg();
8658   test_VarRound();
8659   test_VarXor();
8660   test_VarOr();
8661   test_VarPow();
8662   test_VarEqv();
8663   test_VarMul();
8664   test_VarAdd();
8665   test_VarCat();
8666   test_VarCmp();
8667   test_VarAnd();
8668   test_VarDiv();
8669   test_VarIdiv();
8670   test_VarImp();
8671 }