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

   1 /*
   2  * VARIANT test program
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  * Copyright 2006 Google (Benjamin Arai)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #define CONST_VTABLE
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winsock.h"
  32 #include "wine/test.h"
  33 #include "winuser.h"
  34 #include "wingdi.h"
  35 #include "winnls.h"
  36 #include "winerror.h"
  37 #include "winnt.h"
  38
  39 #include "wtypes.h"
  40 #include "oleauto.h"
  41
  42 static HMODULE hOleaut32;
  43
  44 static HRESULT (WINAPI *pVarUdateFromDate)(DATE,ULONG,UDATE*);
  45 static HRESULT (WINAPI *pVarDateFromUdate)(UDATE*,ULONG,DATE*);
  46 static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
  47 static INT (WINAPI *pVariantTimeToSystemTime)(double,LPSYSTEMTIME);
  48 static INT (WINAPI *pDosDateTimeToVariantTime)(USHORT,USHORT,double*);
  49 static INT (WINAPI *pVariantTimeToDosDateTime)(double,USHORT*,USHORT *);
  50
  51 static const WCHAR sz12[] = {'1','2','\0'};
  52 /* the strings are localized */
  53 static WCHAR sz12_false[32];
  54 static WCHAR sz12_true[32];
  55
  56 /* Get a conversion function ptr, return if function not available */
  57 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
  58   if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }
  59
  60 /* Have IRecordInfo data type? */
  61 static int HAVE_OLEAUT32_RECORD = 0;
  62 /* Have I8/UI8 data type? */
  63 static int HAVE_OLEAUT32_I8 = 0;
  64 /* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
  65 static int IS_ANCIENT = 0;
  66
  67 /* When comparing floating point values we cannot expect an exact match
  68  * because the rounding errors depend on the exact algorithm.
  69  */
  70 #define EQ_DOUBLE(a,b)     (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)
  71 #define EQ_FLOAT(a,b)      (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)
  72
  73 #define SKIPTESTS(a)  if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue
  74
  75 /* Allow our test macros to work for VT_NULL and VT_EMPTY too */
  76 #define V_EMPTY(v) V_I4(v)
  77 #define V_NULL(v) V_I4(v)
  78
  79 /* Size constraints for overflow tests */
  80 #define I1_MAX   0x7f
  81 #define I1_MIN   ((-I1_MAX)-1)
  82 #define UI1_MAX  0xff
  83 #define UI1_MIN  0
  84 #define I2_MAX   0x7fff
  85 #define I2_MIN   ((-I2_MAX)-1)
  86 #define UI2_MAX  0xffff
  87 #define UI2_MIN  0
  88 #define I4_MAX   0x7fffffff
  89 #define I4_MIN   ((-I4_MAX)-1)
  90 #define UI4_MAX  0xffffffff
  91 #define UI4_MIN  0
  92 #define I8_MAX   (((LONGLONG)I4_MAX << 32) | UI4_MAX)
  93 #define I8_MIN   ((-I8_MAX)-1)
  94 #define UI8_MAX  (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
  95 #define UI8_MIN  0
  96 #define DATE_MAX 2958465
  97 #define DATE_MIN -657434
  98 #define R4_MAX FLT_MAX
  99 #define R4_MIN FLT_MIN
 100 #define R8_MAX DBL_MAX
 101 #define R8_MIN DBL_MIN
 102
 103 static void init(void)
 104 {
 105     BSTR bstr;
 106     HRESULT res;
 107
 108     res = VarBstrFromBool(VARIANT_TRUE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
 109     ok(res == S_OK && (lstrlenW(bstr) > 0),
 110         "Expected localized string for 'True'\n");
 111     /* lstrcpyW / lstrcatW do not work on win95 */
 112     memcpy(sz12_true, sz12, sizeof(sz12));
 113     if (bstr) memcpy(&sz12_true[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
 114     SysFreeString(bstr);
 115
 116     res = VarBstrFromBool(VARIANT_FALSE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
 117     ok(res == S_OK && (lstrlenW(bstr) > 0),
 118         "Expected localized string for 'False'\n");
 119     memcpy(sz12_false, sz12, sizeof(sz12));
 120     if (bstr) memcpy(&sz12_false[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
 121     SysFreeString(bstr);
 122
 123     hOleaut32 = GetModuleHandle("oleaut32.dll");
 124
 125   /* Is a given function exported from oleaut32? */
 126 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
 127
 128   HAVE_OLEAUT32_I8 = HAVE_FUNC(VarI8FromI1);
 129   if (!HAVE_OLEAUT32_I8)
 130       skip("No support for I8 and UI8 data types\n");
 131
 132   HAVE_OLEAUT32_RECORD = HAVE_FUNC(SafeArraySetRecordInfo);
 133   IS_ANCIENT = (!HAVE_FUNC(VarI1FromI2));
 134
 135 #undef HAVE_FUNC
 136 }
 137
 138 /* Functions to set a DECIMAL */
 139 static void setdec(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG64 lo64)
 140 {
 141     S(U(*dec)).scale = scl;
 142     S(U(*dec)).sign = sgn;
 143     dec->Hi32 = hi32;
 144     U1(*dec).Lo64 = lo64;
 145 }
 146
 147 static void setdec64(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG mid32, ULONG lo32)
 148 {
 149     S(U(*dec)).scale = scl;
 150     S(U(*dec)).sign = sgn;
 151     dec->Hi32 = hi32;
 152     S1(U1(*dec)).Mid32 = mid32;
 153     S1(U1(*dec)).Lo32 = lo32;
 154 }
 155
 156 static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
 157 {
 158     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 159     return *str1 - *str2;
 160 }
 161
 162 /* return the string text of a given variant type */
 163 static char vtstr_buffer[16][256];
 164 static int vtstr_current=0;
 165 static const char *vtstr(int x)
 166 {
 167     switch(x) {
 168 #define CASE(vt) case VT_##vt: return #vt
 169     CASE(EMPTY);
 170     CASE(NULL);
 171     CASE(I2);
 172     CASE(I4);
 173     CASE(R4);
 174     CASE(R8);
 175     CASE(CY);
 176     CASE(DATE);
 177     CASE(BSTR);
 178     CASE(DISPATCH);
 179     CASE(ERROR);
 180     CASE(BOOL);
 181     CASE(VARIANT);
 182     CASE(UNKNOWN);
 183     CASE(DECIMAL);
 184     CASE(I1);
 185     CASE(UI1);
 186     CASE(UI2);
 187     CASE(UI4);
 188     CASE(I8);
 189     CASE(UI8);
 190     CASE(INT);
 191     CASE(UINT);
 192     CASE(VOID);
 193     CASE(HRESULT);
 194     CASE(PTR);
 195     CASE(SAFEARRAY);
 196     CASE(CARRAY);
 197     CASE(USERDEFINED);
 198     CASE(LPSTR);
 199     CASE(LPWSTR);
 200     CASE(RECORD);
 201     CASE(INT_PTR);
 202     CASE(UINT_PTR);
 203     CASE(FILETIME);
 204     CASE(BLOB);
 205     CASE(STREAM);
 206     CASE(STORAGE);
 207     CASE(STREAMED_OBJECT);
 208     CASE(STORED_OBJECT);
 209     CASE(BLOB_OBJECT);
 210     CASE(CF);
 211     CASE(CLSID);
 212     CASE(VERSIONED_STREAM);
 213     CASE(VECTOR);
 214     CASE(ARRAY);
 215     CASE(BYREF);
 216     CASE(RESERVED);
 217     CASE(ILLEGAL);
 218 #undef CASE
 219
 220     case 0xfff:
 221         return "VT_BSTR_BLOB/VT_ILLEGALMASKED/VT_TYPEMASK";
 222
 223     default:
 224         vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
 225         sprintf(vtstr_buffer[vtstr_current], "unknown variant type %d", x);
 226         return vtstr_buffer[vtstr_current++];
 227     }
 228 }
 229
 230 static const char *variantstr( const VARIANT *var )
 231 {
 232     vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
 233     switch(V_VT(var))
 234     {
 235     case VT_I1:
 236         sprintf( vtstr_buffer[vtstr_current], "VT_I1(%d)", V_I1(var) ); break;
 237     case VT_I2:
 238         sprintf( vtstr_buffer[vtstr_current], "VT_I2(%d)", V_I2(var) ); break;
 239     case VT_I4:
 240         sprintf( vtstr_buffer[vtstr_current], "VT_I4(%d)", V_I4(var) ); break;
 241     case VT_INT:
 242         sprintf( vtstr_buffer[vtstr_current], "VT_INT(%d)", V_INT(var) ); break;
 243     case VT_I8:
 244         sprintf( vtstr_buffer[vtstr_current], "VT_I8(%x%08x)", (UINT)(V_I8(var) >> 32), (UINT)V_I8(var) ); break;
 245     case VT_UI8:
 246         sprintf( vtstr_buffer[vtstr_current], "VT_UI8(%x%08x)", (UINT)(V_UI8(var) >> 32), (UINT)V_UI8(var) ); break;
 247     case VT_R4:
 248         sprintf( vtstr_buffer[vtstr_current], "VT_R4(%g)", V_R4(var) ); break;
 249     case VT_R8:
 250         sprintf( vtstr_buffer[vtstr_current], "VT_R8(%g)", V_R8(var) ); break;
 251     case VT_UI1:
 252         sprintf( vtstr_buffer[vtstr_current], "VT_UI1(%u)", V_UI1(var) ); break;
 253     case VT_UI2:
 254         sprintf( vtstr_buffer[vtstr_current], "VT_UI2(%u)", V_UI2(var) ); break;
 255     case VT_UI4:
 256         sprintf( vtstr_buffer[vtstr_current], "VT_UI4(%u)", V_UI4(var) ); break;
 257     case VT_UINT:
 258         sprintf( vtstr_buffer[vtstr_current], "VT_UINT(%d)", V_UINT(var) ); break;
 259     case VT_CY:
 260         sprintf( vtstr_buffer[vtstr_current], "VT_CY(%x%08x)", S(V_CY(var)).Hi, S(V_CY(var)).Lo ); break;
 261     case VT_DATE:
 262         sprintf( vtstr_buffer[vtstr_current], "VT_DATE(%g)", V_DATE(var) ); break;
 263     default:
 264         return vtstr(V_VT(var));
 265     }
 266     return vtstr_buffer[vtstr_current++];
 267 }
 268
 269 static BOOL is_expected_variant( const VARIANT *result, const VARIANT *expected )
 270 {
 271     if (V_VT(result) != V_VT(expected)) return FALSE;
 272     switch(V_VT(expected))
 273     {
 274     case VT_EMPTY:
 275     case VT_NULL:
 276         return TRUE;
 277
 278 #define CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))
 279     CASE(BOOL);
 280     CASE(I1);
 281     CASE(UI1);
 282     CASE(I2);
 283     CASE(UI2);
 284     CASE(I4);
 285     CASE(UI4);
 286     CASE(I8);
 287     CASE(UI8);
 288     CASE(INT);
 289     CASE(UINT);
 290 #undef CASE
 291
 292     case VT_DATE:
 293         return EQ_FLOAT(V_DATE(result), V_DATE(expected));
 294     case VT_R4:
 295         return EQ_FLOAT(V_R4(result), V_R4(expected));
 296     case VT_R8:
 297         return EQ_FLOAT(V_R8(result), V_R8(expected));
 298     case VT_CY:
 299         return (V_CY(result).int64 == V_CY(expected).int64);
 300     case VT_BSTR:
 301         return !lstrcmpW( V_BSTR(result), V_BSTR(expected) );
 302     case VT_DECIMAL:
 303         return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
 304     default:
 305         ok(0, "unhandled variant type %s\n",vtstr(V_VT(expected)));
 306         return 0;
 307     }
 308 }
 309
 310 static void test_var_call1( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT),
 311                            VARIANT *arg, VARIANT *expected )
 312 {
 313     VARIANT old_arg = *arg;
 314     VARIANT result;
 315     HRESULT hres;
 316
 317     memset( &result, 0, sizeof(result) );
 318     hres = func( arg, &result );
 319     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
 320     if (hres == S_OK)
 321         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 322                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
 323     ok_(__FILE__,line)( is_expected_variant( arg, &old_arg ), "Modified argument %s / %s\n",
 324                         variantstr(&old_arg), variantstr(arg));
 325     VariantClear( &result );
 326 }
 327
 328 static void test_var_call2( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT,LPVARIANT),
 329                             VARIANT *left, VARIANT *right, VARIANT *expected )
 330 {
 331     VARIANT old_left = *left, old_right = *right;
 332     VARIANT result;
 333     HRESULT hres;
 334
 335     memset( &result, 0, sizeof(result) );
 336     hres = func( left, right, &result );
 337     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
 338     if (hres == S_OK)
 339         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 340                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
 341     ok_(__FILE__,line)( is_expected_variant( left, &old_left ), "Modified left argument %s / %s\n",
 342                         variantstr(&old_left), variantstr(left));
 343     ok_(__FILE__,line)( is_expected_variant( right, &old_right ), "Modified right argument %s / %s\n",
 344                         variantstr(&old_right), variantstr(right));
 345     VariantClear( &result );
 346 }
 347
 348 static int strcmp_wa(const WCHAR *strw, const char *stra)
 349 {
 350     WCHAR buf[512];
 351     MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(buf[0]));
 352     return lstrcmpW(strw, buf);
 353 }
 354
 355 #define test_bstr_var(a,b) _test_bstr_var(__LINE__,a,b)
 356 static void _test_bstr_var(unsigned line, const VARIANT *v, const char *str)
 357 {
 358     ok_(__FILE__,line)(V_VT(v) == VT_BSTR, "unexpected vt=%d\n", V_VT(v));
 359     if(V_VT(v) == VT_BSTR)
 360         ok(!strcmp_wa(V_BSTR(v), str), "v=%s, expected %s\n", wine_dbgstr_w(V_BSTR(v)), str);
 361 }
 362
 363 static void test_VariantInit(void)
 364 {
 365   VARIANTARG v1, v2;
 366
 367   /* Test that VariantInit() only sets the type */
 368   memset(&v1, -1, sizeof(v1));
 369   v2 = v1;
 370   V_VT(&v2) = VT_EMPTY;
 371   VariantInit(&v1);
 372   ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
 373 }
 374
 375 /* All possible combinations of extra V_VT() flags */
 376 static const VARTYPE ExtraFlags[16] =
 377 {
 378   0,
 379   VT_VECTOR,
 380   VT_ARRAY,
 381   VT_BYREF,
 382   VT_RESERVED,
 383   VT_VECTOR|VT_ARRAY,
 384   VT_VECTOR|VT_BYREF,
 385   VT_VECTOR|VT_RESERVED,
 386   VT_VECTOR|VT_ARRAY|VT_BYREF,
 387   VT_VECTOR|VT_ARRAY|VT_RESERVED,
 388   VT_VECTOR|VT_BYREF|VT_RESERVED,
 389   VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
 390   VT_ARRAY|VT_BYREF,
 391   VT_ARRAY|VT_RESERVED,
 392   VT_ARRAY|VT_BYREF|VT_RESERVED,
 393   VT_BYREF|VT_RESERVED,
 394 };
 395
 396 /* Determine if a vt is valid for VariantClear() */
 397 static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
 398 {
 399   int ret = 0;
 400
 401   /* Only the following flags/types are valid */
 402   if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
 403       vt != (VARTYPE)15 &&
 404       (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
 405       (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
 406       (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
 407        extraFlags == (VT_ARRAY|VT_BYREF)))
 408     ret = 1; /* ok */
 409
 410   if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
 411       ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
 412     ret = 0; /* Old versions of oleaut32 */
 413   return ret;
 414 }
 415
 416 typedef struct
 417 {
 418     IUnknown IUnknown_iface;
 419     LONG     ref;
 420     LONG     events;
 421 } test_VariantClearImpl;
 422
 423 static inline test_VariantClearImpl *impl_from_IUnknown(IUnknown *iface)
 424 {
 425     return CONTAINING_RECORD(iface, test_VariantClearImpl, IUnknown_iface);
 426 }
 427
 428 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
 429 {
 430     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 431     This->events |= 0x1;
 432     return E_NOINTERFACE;
 433 }
 434
 435 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
 436     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 437     This->events |= 0x2;
 438     return InterlockedIncrement(&This->ref);
 439 }
 440
 441 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
 442     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 443     /* static class, won't be  freed */
 444     This->events |= 0x4;
 445     return InterlockedDecrement(&This->ref);
 446 }
 447
 448 static const IUnknownVtbl test_VariantClear_vtbl = {
 449     VC_QueryInterface,
 450     VC_AddRef,
 451     VC_Release,
 452 };
 453
 454 static test_VariantClearImpl test_myVariantClearImpl = {{&test_VariantClear_vtbl}, 1, 0};
 455
 456 static void test_VariantClear(void)
 457 {
 458   HRESULT hres;
 459   VARIANTARG v;
 460   VARIANT v2;
 461   size_t i;
 462   LONG i4;
 463   IUnknown *punk;
 464
 465   /* Crashes: Native does not test input for NULL, so neither does Wine */
 466   if (0)
 467       VariantClear(NULL);
 468
 469   /* Only the type field is set, to VT_EMPTY */
 470   V_VT(&v) = VT_UI4;
 471   V_UI4(&v) = ~0u;
 472   hres = VariantClear(&v);
 473   ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
 474      (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
 475      "VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
 476   ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
 477
 478   /* Test all possible V_VT values.
 479    * Also demonstrates that null pointers in 'v' are not dereferenced.
 480    * Individual variant tests should test VariantClear() with non-NULL values.
 481    */
 482   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 483   {
 484     VARTYPE vt;
 485
 486     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 487     {
 488       HRESULT hExpected = DISP_E_BADVARTYPE;
 489
 490       SKIPTESTS(vt);
 491
 492       memset(&v, 0, sizeof(v));
 493       V_VT(&v) = vt | ExtraFlags[i];
 494
 495       hres = VariantClear(&v);
 496
 497       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 498         hExpected = S_OK;
 499
 500       ok(hres == hExpected, "VariantClear: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
 501          hExpected, hres, vt, ExtraFlags[i]);
 502     }
 503   }
 504
 505   /* Some BYREF tests with non-NULL ptrs */
 506
 507   /* VARIANT BYREF */
 508   V_VT(&v2) = VT_I4;
 509   V_I4(&v2) = 0x1234;
 510   V_VT(&v) = VT_VARIANT | VT_BYREF;
 511   V_VARIANTREF(&v) = &v2;
 512
 513   hres = VariantClear(&v);
 514   ok(hres == S_OK, "ret %08x\n", hres);
 515   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 516   ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
 517   ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
 518   ok(V_I4(&v2) == 0x1234, "i4 %04x\n", V_I4(&v2));
 519
 520   /* I4 BYREF */
 521   i4 = 0x4321;
 522   V_VT(&v) = VT_I4 | VT_BYREF;
 523   V_I4REF(&v) = &i4;
 524
 525   hres = VariantClear(&v);
 526   ok(hres == S_OK, "ret %08x\n", hres);
 527   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 528   ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
 529   ok(i4 == 0x4321, "i4 changed %08x\n", i4);
 530
 531
 532   /* UNKNOWN */
 533   V_VT(&v) = VT_UNKNOWN;
 534   V_UNKNOWN(&v) = &test_myVariantClearImpl.IUnknown_iface;
 535   test_myVariantClearImpl.events = 0;
 536   hres = VariantClear(&v);
 537   ok(hres == S_OK, "ret %08x\n", hres);
 538   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 539   ok(V_UNKNOWN(&v) == &test_myVariantClearImpl.IUnknown_iface, "unknown %p\n", V_UNKNOWN(&v));
 540   /* Check that Release got called, but nothing else */
 541   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 542
 543   /* UNKNOWN BYREF */
 544   punk = &test_myVariantClearImpl.IUnknown_iface;
 545   V_VT(&v) = VT_UNKNOWN | VT_BYREF;
 546   V_UNKNOWNREF(&v) = &punk;
 547   test_myVariantClearImpl.events = 0;
 548   hres = VariantClear(&v);
 549   ok(hres == S_OK, "ret %08x\n", hres);
 550   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 551   ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
 552   /* Check that nothing got called */
 553   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 554
 555   /* DISPATCH */
 556   V_VT(&v) = VT_DISPATCH;
 557   V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
 558   test_myVariantClearImpl.events = 0;
 559   hres = VariantClear(&v);
 560   ok(hres == S_OK, "ret %08x\n", hres);
 561   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 562   ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
 563   /* Check that Release got called, but nothing else */
 564   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 565
 566   /* DISPATCH BYREF */
 567   punk = &test_myVariantClearImpl.IUnknown_iface;
 568   V_VT(&v) = VT_DISPATCH | VT_BYREF;
 569   V_DISPATCHREF(&v) = (IDispatch**)&punk;
 570   test_myVariantClearImpl.events = 0;
 571   hres = VariantClear(&v);
 572   ok(hres == S_OK, "ret %08x\n", hres);
 573   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 574   ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
 575   /* Check that nothing got called */
 576   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 577 }
 578
 579 static void test_VariantCopy(void)
 580 {
 581   VARIANTARG vSrc, vDst;
 582   VARTYPE vt;
 583   size_t i;
 584   HRESULT hres, hExpected;
 585
 586   /* Establish that the failure/other cases are dealt with. Individual tests
 587    * for each type should verify that data is copied correctly, references
 588    * are updated, etc.
 589    */
 590
 591   /* vSrc == vDst */
 592   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 593   {
 594     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 595     {
 596       SKIPTESTS(vt);
 597
 598       memset(&vSrc, 0, sizeof(vSrc));
 599       V_VT(&vSrc) = vt | ExtraFlags[i];
 600
 601       hExpected = DISP_E_BADVARTYPE;
 602       /* src is allowed to be a VT_CLSID */
 603       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 604         hExpected = S_OK;
 605
 606       hres = VariantCopy(&vSrc, &vSrc);
 607
 608       ok(hres == hExpected,
 609          "Copy(src==dst): expected 0x%X, got 0x%X for src==dest vt %d|0x%X\n",
 610          hExpected, hres, vt, ExtraFlags[i]);
 611     }
 612   }
 613
 614   /* Test that if VariantClear() fails on dest, the function fails. This also
 615    * shows that dest is in fact cleared and not just overwritten
 616    */
 617   memset(&vSrc, 0, sizeof(vSrc));
 618   V_VT(&vSrc) = VT_UI1;
 619
 620   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 621   {
 622     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 623     {
 624       SKIPTESTS(vt);
 625
 626       hExpected = DISP_E_BADVARTYPE;
 627
 628       memset(&vDst, 0, sizeof(vDst));
 629       V_VT(&vDst) = vt | ExtraFlags[i];
 630
 631       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 632         hExpected = S_OK;
 633
 634       hres = VariantCopy(&vDst, &vSrc);
 635
 636       ok(hres == hExpected,
 637          "Copy(bad dst): expected 0x%X, got 0x%X for dest vt %d|0x%X\n",
 638          hExpected, hres, vt, ExtraFlags[i]);
 639       if (hres == S_OK)
 640         ok(V_VT(&vDst) == VT_UI1,
 641            "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 642     }
 643   }
 644
 645   /* Test that VariantClear() checks vSrc for validity before copying */
 646   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 647   {
 648     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 649     {
 650       SKIPTESTS(vt);
 651
 652       hExpected = DISP_E_BADVARTYPE;
 653
 654       memset(&vDst, 0, sizeof(vDst));
 655       V_VT(&vDst) = VT_EMPTY;
 656
 657       memset(&vSrc, 0, sizeof(vSrc));
 658       V_VT(&vSrc) = vt | ExtraFlags[i];
 659
 660       /* src is allowed to be a VT_CLSID */
 661       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 662         hExpected = S_OK;
 663
 664       hres = VariantCopy(&vDst, &vSrc);
 665
 666       ok(hres == hExpected,
 667          "Copy(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 668          hExpected, hres, vt, ExtraFlags[i]);
 669       if (hres == S_OK)
 670       {
 671         ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
 672            "Copy(bad src): expected vt = %d, got %d\n",
 673            vt | ExtraFlags[i], V_VT(&vDst));
 674         VariantClear(&vDst);
 675       }
 676     }
 677   }
 678
 679   /* Test that copying a NULL BSTR results in an empty BSTR */
 680   memset(&vDst, 0, sizeof(vDst));
 681   V_VT(&vDst) = VT_EMPTY;
 682   memset(&vSrc, 0, sizeof(vSrc));
 683   V_VT(&vSrc) = VT_BSTR;
 684   hres = VariantCopy(&vDst, &vSrc);
 685   ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
 686   if (hres == S_OK)
 687   {
 688     ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
 689        "Copy(NULL BSTR): should have non-NULL result\n");
 690     if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
 691     {
 692       ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
 693     }
 694     VariantClear(&vDst);
 695   }
 696 }
 697
 698 /* Determine if a vt is valid for VariantCopyInd() */
 699 static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
 700 {
 701   int ret = 0;
 702
 703   if ((extraFlags & VT_ARRAY) ||
 704      (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
 705      !(extraFlags & (VT_VECTOR|VT_RESERVED))))
 706   {
 707     ret = 1; /* ok */
 708   }
 709   return ret;
 710 }
 711
 712 static void test_VariantCopyInd(void)
 713 {
 714   VARIANTARG vSrc, vDst, vRef, vRef2;
 715   VARTYPE vt;
 716   size_t i;
 717   BYTE buffer[64];
 718   HRESULT hres, hExpected;
 719
 720   memset(buffer, 0, sizeof(buffer));
 721
 722   /* vSrc == vDst */
 723   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 724   {
 725     if (ExtraFlags[i] & VT_ARRAY)
 726       continue; /* Native crashes on NULL safearray */
 727
 728     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 729     {
 730       SKIPTESTS(vt);
 731
 732       memset(&vSrc, 0, sizeof(vSrc));
 733       V_VT(&vSrc) = vt | ExtraFlags[i];
 734
 735       hExpected = DISP_E_BADVARTYPE;
 736       if (!(ExtraFlags[i] & VT_BYREF))
 737       {
 738         /* if src is not by-reference, acts as VariantCopy() */
 739         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 740           hExpected = S_OK;
 741       }
 742       else
 743       {
 744         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 745             vt == VT_DISPATCH || vt == VT_RECORD)
 746           continue; /* Need valid ptrs for deep copies */
 747
 748         V_BYREF(&vSrc) = &buffer;
 749         hExpected = E_INVALIDARG;
 750
 751         if ((vt == VT_I8 || vt == VT_UI8) &&
 752             ExtraFlags[i] == VT_BYREF)
 753         {
 754           if (HAVE_OLEAUT32_I8)
 755             hExpected = S_OK; /* Only valid if I8 is a known type */
 756         }
 757         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 758           hExpected = S_OK;
 759       }
 760
 761       hres = VariantCopyInd(&vSrc, &vSrc);
 762
 763       ok(hres == hExpected,
 764          "CopyInd(src==dst): expected 0x%X, got 0x%X for src==dst vt %d|0x%X\n",
 765          hExpected, hres, vt, ExtraFlags[i]);
 766     }
 767   }
 768
 769   /* Bad dest */
 770   memset(&vSrc, 0, sizeof(vSrc));
 771   V_VT(&vSrc) = VT_UI1|VT_BYREF;
 772   V_BYREF(&vSrc) = &buffer;
 773
 774   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 775   {
 776     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 777     {
 778       SKIPTESTS(vt);
 779
 780       memset(&vDst, 0, sizeof(vDst));
 781       V_VT(&vDst) = vt | ExtraFlags[i];
 782
 783       hExpected = DISP_E_BADVARTYPE;
 784
 785       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 786         hExpected = S_OK;
 787
 788       hres = VariantCopyInd(&vDst, &vSrc);
 789
 790       ok(hres == hExpected,
 791          "CopyInd(bad dst): expected 0x%X, got 0x%X for dst vt %d|0x%X\n",
 792          hExpected, hres, vt, ExtraFlags[i]);
 793       if (hres == S_OK)
 794         ok(V_VT(&vDst) == VT_UI1,
 795            "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 796     }
 797   }
 798
 799   /* bad src */
 800   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 801   {
 802     if (ExtraFlags[i] & VT_ARRAY)
 803       continue; /* Native crashes on NULL safearray */
 804
 805     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 806     {
 807       SKIPTESTS(vt);
 808
 809       memset(&vDst, 0, sizeof(vDst));
 810       V_VT(&vDst) = VT_EMPTY;
 811
 812       memset(&vSrc, 0, sizeof(vSrc));
 813       V_VT(&vSrc) = vt | ExtraFlags[i];
 814
 815       hExpected = DISP_E_BADVARTYPE;
 816       if (!(ExtraFlags[i] & VT_BYREF))
 817       {
 818         /* if src is not by-reference, acts as VariantCopy() */
 819         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 820           hExpected = S_OK;
 821       }
 822       else
 823       {
 824         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 825             vt == VT_DISPATCH || vt == VT_RECORD)
 826           continue; /* Need valid ptrs for deep copies, see vartype.c */
 827
 828         V_BYREF(&vSrc) = &buffer;
 829
 830         hExpected = E_INVALIDARG;
 831
 832         if ((vt == VT_I8 || vt == VT_UI8) &&
 833             ExtraFlags[i] == VT_BYREF)
 834         {
 835           if (HAVE_OLEAUT32_I8)
 836             hExpected = S_OK; /* Only valid if I8 is a known type */
 837         }
 838         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 839           hExpected = S_OK;
 840       }
 841
 842       hres = VariantCopyInd(&vDst, &vSrc);
 843
 844       ok(hres == hExpected,
 845          "CopyInd(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 846          hExpected, hres, vt, ExtraFlags[i]);
 847       if (hres == S_OK)
 848       {
 849         if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
 850         {
 851           /* Type of vDst should be the type of the referenced variant.
 852            * Since we set the buffer to all zeros, its type should be
 853            * VT_EMPTY.
 854            */
 855           ok(V_VT(&vDst) == VT_EMPTY,
 856              "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
 857              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 858         }
 859         else
 860         {
 861           ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
 862              "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
 863              vt, ExtraFlags[i] & ~VT_BYREF,
 864              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 865         }
 866         VariantClear(&vDst);
 867       }
 868     }
 869   }
 870
 871   /* By-reference variants are dereferenced */
 872   V_VT(&vRef) = VT_UI1;
 873   V_UI1(&vRef) = 0x77;
 874   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 875   V_VARIANTREF(&vSrc) = &vRef;
 876   VariantInit(&vDst);
 877
 878   hres = VariantCopyInd(&vDst, &vSrc);
 879   ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
 880   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
 881      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 882       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 883
 884   /* By-reference variant to a by-reference type succeeds */
 885   V_VT(&vRef) = VT_UI1|VT_BYREF;
 886   V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
 887   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 888   V_VARIANTREF(&vSrc) = &vRef;
 889   VariantInit(&vDst);
 890
 891   hres = VariantCopyInd(&vDst, &vSrc);
 892   ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
 893   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
 894      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 895       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 896
 897   /* But a by-reference variant to a by-reference variant fails */
 898   V_VT(&vRef2) = VT_UI1;
 899   V_UI1(&vRef2) = 0x77;
 900   V_VT(&vRef) = VT_VARIANT|VT_BYREF;
 901   V_VARIANTREF(&vRef) = &vRef2;
 902   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 903   V_VARIANTREF(&vSrc) = &vRef;
 904   VariantInit(&vDst);
 905
 906   hres = VariantCopyInd(&vDst, &vSrc);
 907   ok(hres == E_INVALIDARG,
 908      "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08x\n", hres);
 909 }
 910
 911 static HRESULT (WINAPI *pVarParseNumFromStr)(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
 912
 913 /* Macros for converting and testing the result of VarParseNumFromStr */
 914 #define FAILDIG 255
 915
 916 static HRESULT convert_str( const char *str, INT dig, ULONG flags,
 917                             NUMPARSE *np, BYTE rgb[128], LCID lcid )
 918 {
 919     OLECHAR buff[128];
 920     MultiByteToWideChar( CP_ACP,0, str, -1, buff, sizeof(buff)/sizeof(WCHAR) );
 921     memset( rgb, FAILDIG, 128 );
 922     memset( np, 255, sizeof(*np) );
 923     np->cDig = dig;
 924     np->dwInFlags = flags;
 925     return pVarParseNumFromStr( buff, lcid, LOCALE_NOUSEROVERRIDE, np, rgb);
 926 }
 927
 928 static void expect_NumFromStr( int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c,
 929                                INT d, INT e, INT f )
 930 {
 931     if (hres == (HRESULT)S_OK)
 932     {
 933         ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
 934         ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%x, got 0x%x\n", b, np->dwInFlags);
 935         ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%x, got 0x%x\n", c, np->dwOutFlags);
 936         ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
 937         ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
 938         ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
 939     }
 940 }
 941
 942 #define CONVERTN(str,dig,flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )
 943 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
 944 #define EXPECT(a,b,c,d,e,f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )
 945 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
 946 #define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)
 947 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
 948
 949 static void test_VarParseNumFromStr(void)
 950 {
 951   HRESULT hres;
 952   /* Ensure all tests are using the same locale characters for '$', ',' etc */
 953   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 954   NUMPARSE np;
 955   BYTE rgb[128];
 956
 957   /** No flags **/
 958
 959   CHECKPTR(VarParseNumFromStr);
 960
 961   /* Consume a single digit */
 962   CONVERT("7", 0);
 963   EXPECT(1,0,0,1,0,0);
 964   EXPECT2(7,FAILDIG);
 965
 966   /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
 967   CONVERT("10", 0);
 968   EXPECT(1,0,0,2,0,1);
 969   /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
 970    * but then excludes them from the returned cDig count.
 971    * In our implementation we don't bother writing them at all.
 972    */
 973   EXPECTRGB(0, 1);
 974
 975   /* if cDig is too small and numbers follow, sets INEXACT */
 976   CONVERTN("11",1, 0);
 977   EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
 978   EXPECT2(1,FAILDIG);
 979
 980   /* Strips leading zeros */
 981   CONVERT("01", 0);
 982   EXPECT(1,0,0,2,0,0);
 983   EXPECT2(1,FAILDIG);
 984
 985   /* Strips leading zeros */
 986   CONVERTN("01",1, 0);
 987   EXPECT(1,0,0,2,0,0);
 988   EXPECT2(1,FAILDIG);
 989
 990
 991   /* Fails on non digits */
 992   CONVERT("a", 0);
 993   EXPECTFAIL;
 994   EXPECTRGB(0,FAILDIG);
 995
 996   /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
 997
 998   /* Without flag, fails on whitespace */
 999   CONVERT(" 0", 0);
1000   EXPECTFAIL;
1001   EXPECTRGB(0,FAILDIG);
1002
1003
1004   /* With flag, consumes whitespace */
1005   CONVERT(" 0", NUMPRS_LEADING_WHITE);
1006   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1007   EXPECT2(0,FAILDIG);
1008
1009   /* Test TAB once, then assume it acts as space for all cases */
1010   CONVERT("\t0", NUMPRS_LEADING_WHITE);
1011   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1012   EXPECT2(0,FAILDIG);
1013
1014
1015   /* Doesn't pick up trailing whitespace without flag */
1016   CONVERT("0 ", 0);
1017   EXPECT(1,0,0,1,0,0);
1018   EXPECT2(0,FAILDIG);
1019
1020   /* With flag, consumes trailing whitespace */
1021   CONVERT("0 ", NUMPRS_TRAILING_WHITE);
1022   EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1023   EXPECT2(0,FAILDIG);
1024
1025   /* Leading flag only consumes leading */
1026   CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
1027   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1028   EXPECT2(0,FAILDIG);
1029
1030   /* Both flags consumes both */
1031   CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
1032   EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
1033   EXPECT2(0,FAILDIG);
1034
1035   /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
1036
1037   /* Without flag, fails on + */
1038   CONVERT("+0", 0);
1039   EXPECTFAIL;
1040   EXPECTRGB(0,FAILDIG);
1041
1042   /* With flag, consumes + */
1043   CONVERT("+0", NUMPRS_LEADING_PLUS);
1044   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1045   EXPECT2(0,FAILDIG);
1046
1047   /* Without flag, doesn't consume trailing + */
1048   CONVERT("0+", 0);
1049   EXPECT(1,0,0,1,0,0);
1050   EXPECT2(0,FAILDIG);
1051
1052   /* With flag, consumes trailing + */
1053   CONVERT("0+", NUMPRS_TRAILING_PLUS);
1054   EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
1055   EXPECT2(0,FAILDIG);
1056
1057   /* With leading flag, doesn't consume trailing + */
1058   CONVERT("+0+", NUMPRS_LEADING_PLUS);
1059   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1060   EXPECT2(0,FAILDIG);
1061
1062   /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
1063   CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
1064   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1065   EXPECT2(0,FAILDIG);
1066
1067   /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
1068
1069   /* Without flag, fails on - */
1070   CONVERT("-0", 0);
1071   EXPECTFAIL;
1072   EXPECTRGB(0,FAILDIG);
1073
1074   /* With flag, consumes - */
1075   CONVERT("-0", NUMPRS_LEADING_MINUS);
1076   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1077   EXPECT2(0,FAILDIG);
1078
1079   /* Without flag, doesn't consume trailing - */
1080   CONVERT("0-", 0);
1081   EXPECT(1,0,0,1,0,0);
1082   EXPECT2(0,FAILDIG);
1083
1084   /* With flag, consumes trailing - */
1085   CONVERT("0-", NUMPRS_TRAILING_MINUS);
1086   EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
1087   EXPECT2(0,FAILDIG);
1088
1089   /* With leading flag, doesn't consume trailing - */
1090   CONVERT("-0-", NUMPRS_LEADING_MINUS);
1091   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1092   EXPECT2(0,FAILDIG);
1093
1094   /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
1095   CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
1096   EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1097   EXPECT2(0,FAILDIG);
1098
1099   /** NUMPRS_HEX_OCT **/
1100
1101   /* Could be hex, octal or decimal - With flag reads as decimal */
1102   CONVERT("0", NUMPRS_HEX_OCT);
1103   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1104   EXPECT2(0,FAILDIG);
1105
1106   /* Doesn't recognise hex in .asm syntax */
1107   CONVERT("0h", NUMPRS_HEX_OCT);
1108   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1109   EXPECT2(0,FAILDIG);
1110
1111   /* Doesn't fail with valid leading string but no digits */
1112   CONVERT("0x", NUMPRS_HEX_OCT);
1113   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1114   EXPECT2(0,FAILDIG);
1115
1116   /* Doesn't recognise hex format numbers at all! */
1117   CONVERT("0x0", NUMPRS_HEX_OCT);
1118   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1119   EXPECT2(0,FAILDIG);
1120
1121   /* Doesn't recognise plain hex digits either */
1122   CONVERT("FE", NUMPRS_HEX_OCT);
1123   EXPECTFAIL;
1124   EXPECTRGB(0,FAILDIG);
1125
1126   /* Octal */
1127   CONVERT("0100", NUMPRS_HEX_OCT);
1128   EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
1129   EXPECTRGB(0,1);
1130   EXPECTRGB(1,0);
1131   EXPECTRGB(2,0);
1132   EXPECTRGB(3,FAILDIG);
1133
1134   /* VB hex */
1135   CONVERT("&HF800", NUMPRS_HEX_OCT);
1136   EXPECT(4,NUMPRS_HEX_OCT,0x40,6,4,0);
1137   EXPECTRGB(0,15);
1138   EXPECTRGB(1,8);
1139   EXPECTRGB(2,0);
1140   EXPECTRGB(3,0);
1141   EXPECTRGB(4,FAILDIG);
1142
1143   /* VB hex lower case and leading zero */
1144   CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
1145   EXPECT(6,NUMPRS_HEX_OCT,0x40,9,4,0);
1146   EXPECTRGB(0,10);
1147   EXPECTRGB(1,11);
1148   EXPECTRGB(2,12);
1149   EXPECTRGB(3,13);
1150   EXPECTRGB(4,14);
1151   EXPECTRGB(5,15);
1152   EXPECTRGB(6,FAILDIG);
1153
1154   /* VB oct */
1155   CONVERT("&O300", NUMPRS_HEX_OCT);
1156   EXPECT(3,NUMPRS_HEX_OCT,0x40,5,3,0);
1157   EXPECTRGB(0,3);
1158   EXPECTRGB(1,0);
1159   EXPECTRGB(2,0);
1160   EXPECTRGB(3,FAILDIG);
1161
1162   /* VB oct lower case and leading zero */
1163   CONVERT("&o0777", NUMPRS_HEX_OCT);
1164   EXPECT(3,NUMPRS_HEX_OCT,0x40,6,3,0);
1165   EXPECTRGB(0,7);
1166   EXPECTRGB(1,7);
1167   EXPECTRGB(2,7);
1168   EXPECTRGB(3,FAILDIG);
1169
1170   /* VB oct char bigger than 7 */
1171   CONVERT("&o128", NUMPRS_HEX_OCT);
1172 /*
1173   Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
1174   EXPECTFAIL;
1175   EXPECTRGB(0,FAILDIG);
1176 */
1177   /** NUMPRS_PARENS **/
1178
1179   /* Empty parens = error */
1180   CONVERT("()", NUMPRS_PARENS);
1181   EXPECTFAIL;
1182   EXPECTRGB(0,FAILDIG);
1183
1184   /* With flag, trailing parens not consumed */
1185   CONVERT("0()", NUMPRS_PARENS);
1186   EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1187   EXPECT2(0,FAILDIG);
1188
1189   /* With flag, Number in parens made negative and parens consumed */
1190   CONVERT("(0)", NUMPRS_PARENS);
1191   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1192   EXPECT2(0,FAILDIG);
1193
1194   /** NUMPRS_THOUSANDS **/
1195
1196   /* With flag, thousands sep. not needed */
1197   CONVERT("0", NUMPRS_THOUSANDS);
1198   EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1199   EXPECT2(0,FAILDIG);
1200
1201   /* With flag, thousands sep. and following digits consumed */
1202   CONVERT("1,000", NUMPRS_THOUSANDS);
1203   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1204   EXPECTRGB(0,1);
1205
1206   /* With flag and decimal point, thousands sep. but not decimals consumed */
1207   CONVERT("1,000.0", NUMPRS_THOUSANDS);
1208   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1209   EXPECTRGB(0,1);
1210
1211   /** NUMPRS_CURRENCY **/
1212
1213   /* Without flag, chokes on currency sign */
1214   CONVERT("$11", 0);
1215   EXPECTFAIL;
1216   EXPECTRGB(0,FAILDIG);
1217
1218   /* With flag, consumes currency sign */
1219   CONVERT("$11", NUMPRS_CURRENCY);
1220   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1221   EXPECT2(1,1);
1222   EXPECTRGB(2,FAILDIG);
1223
1224   /* With flag only, doesn't consume decimal point */
1225   CONVERT("$11.1", NUMPRS_CURRENCY);
1226   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1227   EXPECT2(1,1);
1228   EXPECTRGB(2,FAILDIG);
1229
1230   /* With flag and decimal flag, consumes decimal point and following digits */
1231   CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1232   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1233   EXPECT2(1,1);
1234   EXPECTRGB(2,1);
1235   EXPECTRGB(3,FAILDIG);
1236
1237   /* Thousands flag can only be used with currency */
1238   CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1239   EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1240   EXPECT2(1,2);
1241   EXPECTRGB(2,3);
1242   EXPECTRGB(3,4);
1243   EXPECTRGB(4,FAILDIG);
1244
1245   /** NUMPRS_DECIMAL **/
1246
1247   /* With flag, consumes decimal point */
1248   CONVERT("1.1", NUMPRS_DECIMAL);
1249   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1250   EXPECT2(1,1);
1251   EXPECTRGB(2,FAILDIG);
1252
1253   /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1254   CONVERT("1.", NUMPRS_DECIMAL);
1255   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1256   EXPECT2(1,FAILDIG);
1257
1258   /* Consumes only one decimal point */
1259   CONVERT("1.1.", NUMPRS_DECIMAL);
1260   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1261   EXPECT2(1,1);
1262   EXPECTRGB(2,FAILDIG);
1263
1264   /** NUMPRS_EXPONENT **/
1265
1266   /* Without flag, doesn't consume exponent */
1267   CONVERT("1e1", 0);
1268   EXPECT(1,0,0,1,0,0);
1269   EXPECT2(1,FAILDIG);
1270
1271   /* With flag, consumes exponent */
1272   CONVERT("1e1", NUMPRS_EXPONENT);
1273   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1274   EXPECT2(1,FAILDIG);
1275
1276   /* Negative exponents are accepted without flags */
1277   CONVERT("1e-1", NUMPRS_EXPONENT);
1278   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1279   EXPECT2(1,FAILDIG);
1280
1281   /* As are positive exponents and leading exponent 0s */
1282   CONVERT("1e+01", NUMPRS_EXPONENT);
1283   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1284   EXPECT2(1,FAILDIG);
1285
1286   /* The same for zero exponents */
1287   CONVERT("1e0", NUMPRS_EXPONENT);
1288   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1289   EXPECT2(1,FAILDIG);
1290
1291   /* Sign on a zero exponent doesn't matter */
1292   CONVERT("1e+0", NUMPRS_EXPONENT);
1293   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1294   EXPECT2(1,FAILDIG);
1295
1296   CONVERT("1e-0", NUMPRS_EXPONENT);
1297   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1298   EXPECT2(1,FAILDIG);
1299
1300   /* Doesn't consume a real number exponent */
1301   CONVERT("1e1.", NUMPRS_EXPONENT);
1302   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1303   EXPECT2(1,FAILDIG);
1304
1305   /* Powers of 10 are calculated from the position of any decimal point */
1306   CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1307   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1308   EXPECT2(1,5);
1309
1310   CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1311   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1312   EXPECT2(1,5);
1313
1314   /** NUMPRS_USE_ALL **/
1315
1316   /* Flag expects all digits */
1317   CONVERT("0", NUMPRS_USE_ALL);
1318   EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1319   EXPECT2(0,FAILDIG);
1320
1321   /* Rejects anything trailing */
1322   CONVERT("0 ", NUMPRS_USE_ALL);
1323   EXPECTFAIL;
1324   EXPECT2(0,FAILDIG);
1325
1326   /* Unless consumed by trailing flag */
1327   CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1328   EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1329   EXPECT2(0,FAILDIG);
1330
1331   /** Combinations **/
1332
1333   /* Leading whitespace and plus, doesn't consume trailing whitespace */
1334   CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1335   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1336   EXPECT2(0,FAILDIG);
1337
1338   /* Order of whitespace and plus is unimportant */
1339   CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1340   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1341   EXPECT2(0,FAILDIG);
1342
1343   /* Leading whitespace can be repeated */
1344   CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1345   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1346   EXPECT2(0,FAILDIG);
1347
1348   /* But plus/minus etc. cannot */
1349   CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1350   EXPECTFAIL;
1351   EXPECTRGB(0,FAILDIG);
1352
1353   /* Inexact is not set if trailing zeros are removed */
1354   CONVERTN("10", 1, 0);
1355   EXPECT(1,0,0,2,0,1);
1356   EXPECT2(1,FAILDIG);
1357
1358   /* Make sure a leading 0 is stripped but decimals after it get read */
1359   CONVERT("-0.51", NUMPRS_STD);
1360   EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1361   EXPECT2(5,1);
1362
1363   /* Keep trailing zeros on whole number part of a decimal */
1364   CONVERT("10.1", NUMPRS_STD);
1365   EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1366   EXPECT2(1,0);
1367   EXPECTRGB(2,1);
1368
1369   /* Zeros after decimal sign */
1370   CONVERT("0.01", NUMPRS_STD);
1371   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1372   EXPECT2(1,FAILDIG);
1373
1374   /* Trailing zeros after decimal part */
1375   CONVERT("0.10", NUMPRS_STD);
1376   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1377   EXPECT2(1,0);
1378 }
1379
1380 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1381
1382 /* Macros for converting and testing the result of VarNumFromParseNum */
1383 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1384 #undef CONVERT
1385 #define CONVERT(a,b,c,d,e,f,bits) \
1386     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1387     np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1388 static const char *szFailOverflow = "Expected overflow, hres = %08x\n";
1389 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1390 static const char *szFailOk = "Call failed, hres = %08x\n";
1391 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1392   if (hres == (HRESULT)S_OK)
1393 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1394 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1395   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1396 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1397   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1398 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1399   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1400 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1401   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1402 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1403   ok(V_I4(&vOut) == val, "Expected i4 = %d, got %d\n", (LONG)val, V_I4(&vOut)); }
1404 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1405   ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
1406 #define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1407   ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
1408      (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
1409 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1410   ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
1411       (DWORD)((ULONG64)val >> 32), (DWORD)(ULONG64)val, (DWORD)(V_UI8(&vOut) >> 32), (DWORD)V_UI8(&vOut)); }
1412 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1413   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1414 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1415   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1416 #define CY_MULTIPLIER 10000
1417 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1418   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = 0x%x%08x, got 0x%x%08x\n", \
1419       (DWORD)((LONG64)val >> 23), (DWORD)(LONG64)val, (DWORD)(V_CY(&vOut).int64 >>32), (DWORD)V_CY(&vOut).int64); }
1420 #define EXPECT_DECIMAL(valHi, valMid, valLo) EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
1421       ok((V_DECIMAL(&vOut).Hi32 == valHi) && (S1(U1(V_DECIMAL(&vOut))).Mid32 == valMid) && \
1422       (S1(U1(V_DECIMAL(&vOut))).Lo32 == valLo),                      \
1423   "Expected decimal = %x/0x%x%08x, got %x/0x%x%08x\n", valHi, valMid, valLo, \
1424       V_DECIMAL(&vOut).Hi32, S1(U1(V_DECIMAL(&vOut))).Mid32, S1(U1(V_DECIMAL(&vOut))).Lo32); }
1425
1426 static void test_VarNumFromParseNum(void)
1427 {
1428   HRESULT hres;
1429   NUMPARSE np;
1430   BYTE rgb[128];
1431   VARIANT vOut;
1432
1433   CHECKPTR(VarNumFromParseNum);
1434
1435   /* Convert the number 1 to different types */
1436   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1437   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1438   /* Prefers a signed type to unsigned of the same size */
1439   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1440   /* But takes the smaller size if possible */
1441   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1442
1443   /* Try different integer sizes */
1444 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1445
1446   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1447   /* 127 */
1448   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1449   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1450   /* 128 */
1451   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1452   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1453   /* 255 */
1454   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1455   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1456   /* 256 */
1457   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1458   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1459   /* 32767 */
1460   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1461   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1462   /* 32768 */
1463   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1464   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1465
1466   /* Assume the above pattern holds for remaining positive integers; test negative */
1467
1468   /* -128 */
1469   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1470   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1471   /* -129 */
1472   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1473   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1474   /* -32768 */
1475   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1476   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1477   /* -32768 */
1478   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1479   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1480
1481   /* Assume the above pattern holds for remaining negative integers */
1482
1483   /* Test hexadecimal conversions */
1484   SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
1485   /* 0x7f */
1486   SETRGB(0, 7); SETRGB(1, 0xf);
1487   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
1488   SETRGB(0, 7); SETRGB(1, 0xf);
1489   CONVERT(2,0,0,2,4,0, VTBIT_DECIMAL); EXPECT_DECIMAL(0,0,0x7f);
1490   /* 0x7fff */
1491   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1492   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
1493   /* 0x7fffffff */
1494   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1495   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1496   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
1497   /* 0x7fffffffffffffff (64 bits) */
1498   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1499   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1500   SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
1501   SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
1502   if (HAVE_OLEAUT32_I8)
1503   {
1504     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1505        truncate the number to the smallest integer size requested:
1506        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
1507     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffff,0xffffffff);
1508   }
1509
1510   /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
1511   /* 0x82 */
1512   SETRGB(0, 8); SETRGB(1, 2);
1513   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
1514   EXPECT_I1((signed char)0x82);
1515   /* 0x8002 */
1516   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1517   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
1518   EXPECT_I2((signed short)0x8002);
1519   /* 0x80000002 */
1520   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1521   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1522   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
1523   /* 0x8000000000000002 (64 bits) */
1524   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1525   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1526   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1527   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1528   if (HAVE_OLEAUT32_I8)
1529   {
1530     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1531        truncate the number to the smallest integer size requested:
1532        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
1533        EXPECT_I2((signed short)0x0002); */
1534     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1535   }
1536
1537   /* Test (preservation of) hi-bit with STRICT type requesting */
1538   /* 0x82 */
1539   SETRGB(0, 8); SETRGB(1, 2);
1540   CONVERT(2,0,0,2,4,0, VTBIT_I1);
1541   EXPECT_I1((signed char)0x82);
1542   /* 0x8002 */
1543   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1544   CONVERT(4,0,0,4,4,0, VTBIT_I2);
1545   EXPECT_I2((signed short)0x8002);
1546   /* 0x80000002 */
1547   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1548   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1549   CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
1550   /* 0x8000000000000002 (64 bits) */
1551   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1552   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1553   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1554   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1555   if (HAVE_OLEAUT32_I8)
1556   {
1557     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1558   }
1559   /* Assume the above pattern holds for numbers with hi-bit set */
1560
1561   /* Negative numbers overflow if we have only unsigned outputs */
1562   /* -1 */
1563   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1564   /* -0.6 */
1565   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1566
1567   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1568   /* -0.5 */
1569   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1570
1571   /* Floating point zero is OK */
1572   /* 0.00000000E0 */
1573   SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
1574   EXPECT_R8(0.0);
1575
1576   /* Float is acceptable for an integer input value */
1577   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1578   /* As is double */
1579   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1580   /* As is currency */
1581   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1582
1583   /* Float is preferred over double */
1584   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1585
1586   /* Double is preferred over currency */
1587   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1588
1589   /* Currency is preferred over decimal */
1590   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1591 }
1592
1593
1594 static void test_UdateFromDate( int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y,
1595                                 WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)
1596 {
1597     UDATE ud;
1598     HRESULT res;
1599
1600     memset(&ud, 0, sizeof(ud));
1601     res = pVarUdateFromDate(dt, flags, &ud);
1602     ok_(__FILE__,line)(r == res && (res != S_OK || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
1603                        ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
1604                        ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)),
1605                        "%.16g expected res(%x) %d,%d,%d,%d,%d,%d,%d  %d %d, got res(%x) %d,%d,%d,%d,%d,%d,%d  %d %d\n",
1606                        dt, r, d, m, y, h, mn, s, ms, dw, dy,
1607                        res, ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
1608                        ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
1609 }
1610 #define DT2UD(dt,flags,r,d,m,y,h,mn,s,ms,dw,dy) test_UdateFromDate(__LINE__,dt,flags,r,d,m,y,h,mn,s,ms,dw,dy)
1611
1612 static void test_VarUdateFromDate(void)
1613 {
1614   CHECKPTR(VarUdateFromDate);
1615   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
1616   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
1617   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
1618   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
1619   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
1620   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1621   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
1622   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
1623
1624   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1625   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1626   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1627
1628   /* Times */
1629   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
1630   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
1631   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
1632   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1633   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1634
1635   /* Test handling of times on dates prior to the epoch */
1636   DT2UD(-5.25,0,S_OK,25,12,1899,6,0,0,0,1,359);
1637   DT2UD(-5.9999884259259,0,S_OK,25,12,1899,23,59,59,0,1,359);
1638   /* This just demonstrates the non-linear nature of values prior to the epoch */
1639   DT2UD(-4.0,0,S_OK,26,12,1899,0,0,0,0,2,360);
1640   /* Numerical oddity: for 0.0 < x < 1.0, x and -x represent the same datetime */
1641   DT2UD(-0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1642   DT2UD(0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1643 }
1644
1645
1646 static void test_DateFromUDate( int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms,
1647                                 WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt )
1648 {
1649     UDATE ud;
1650     double out;
1651     HRESULT res;
1652
1653     ud.st.wYear = y;
1654     ud.st.wMonth = m;
1655     ud.st.wDay = d;
1656     ud.st.wHour = h;
1657     ud.st.wMinute = mn;
1658     ud.st.wSecond = s;
1659     ud.st.wMilliseconds = ms;
1660     ud.st.wDayOfWeek = dw;
1661     ud.wDayOfYear = dy;
1662     res = pVarDateFromUdate(&ud, flags, &out);
1663     ok_(__FILE__,line)(r == res && (r != S_OK || EQ_DOUBLE(out, dt)),
1664                        "expected %x, %.16g, got %x, %.16g\n", r, dt, res, out);
1665 }
1666 #define UD2T(d,m,y,h,mn,s,ms,dw,dy,flags,r,dt) test_DateFromUDate(__LINE__,d,m,y,h,mn,s,ms,dw,dy,flags,r,dt)
1667
1668 static void test_VarDateFromUdate(void)
1669 {
1670   CHECKPTR(VarDateFromUdate);
1671   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
1672   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
1673   UD2T(2,1,1980,0,0,0,0,4,5,0,S_OK,29222.0);      /* 2 Jan 1980 */
1674   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
1675   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
1676   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
1677   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
1678   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
1679   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
1680   UD2T(1,1,-10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0);/* < -9999 => err  */
1681
1682   UD2T(30,12,1899,0,0,0,0,0,0,0,S_OK,0.0); /* 30 Dec 1899 0:00:00  */
1683   UD2T(30,12,1899,0,0,0,999,0,0,0,S_OK,0.0); /* Ignore milliseconds  */
1684
1685   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963);             /* 6:18:02 PM */
1686   UD2T(1,300,1980,18,1,16,0,2,1,0,S_OK,38322.75087962963);           /* Test fwdrolled month */
1687   UD2T(300,1,1980,18,1,16,0,2,1,0,S_OK,29520.75087962963);           /* Test fwdrolled days */
1688   UD2T(0,1,1980,42,1,16,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled hours */
1689   UD2T(1,1,1980,17,61,16,0,2,1,0,S_OK,29221.75087962963);            /* Test fwdrolled minutes */
1690   UD2T(1,1,1980,18,0,76,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled seconds */
1691   UD2T(1,-300,1980,18,1,16,0,2,1,0,S_OK,20059.75087962963);          /* Test backrolled month */
1692   UD2T(-300,1,1980,18,1,16,0,2,1,0,S_OK,28920.75087962963);          /* Test backrolled days */
1693   UD2T(3,1,1980,-30,1,16,0,2,1,0,S_OK,29221.75087962963);            /* Test backrolled hours */
1694   UD2T(1,1,1980,20,-119,16,0,2,1,0,S_OK,29221.75087962963);          /* Test backrolled minutes */
1695   UD2T(1,1,1980,18,3,-104,0,2,1,0,S_OK,29221.75087962963);           /* Test backrolled seconds */
1696   UD2T(1,12001,-1020,18,1,16,0,0,0,0,S_OK,29221.75087962963);        /* Test rolled year and month */
1697   UD2T(1,-23,1982,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled month */
1698   UD2T(-59,3,1980,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled days */
1699   UD2T(1,1,0,0,0,0,0,0,0,0,S_OK,36526);                              /* Test zero year */
1700   UD2T(0,0,1980,0,0,0,0,0,0,0,S_OK,29189);                           /* Test zero day and month */
1701   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);                         /* Test zero day = LastDayOfMonth */
1702   UD2T(-1,1,1980,18,1,16,0,0,0,0,S_OK,29219.75087962963);            /* Test day -1 = LastDayOfMonth - 1 */
1703   UD2T(1,1,-1,18,1,16,0,0,0,0,S_OK,36161.75087962963);               /* Test year -1 = 1999 */
1704   UD2T(1,-1,1980,18,1,16,0,0,0,0,S_OK,29160.7508796296);             /* Test month -1 = 11 */
1705   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);                        /* Rolls fwd to 1/1/1981 */
1706
1707   /* Test handling of times on dates prior to the epoch */
1708   UD2T(25,12,1899,6,0,0,0,1,359,0,S_OK,-5.25);
1709   UD2T(25,12,1899,23,59,59,0,1,359,0,S_OK,-5.9999884259259);
1710   /* This just demonstrates the non-linear nature of values prior to the epoch */
1711   UD2T(26,12,1899,0,0,0,0,2,360,0,S_OK,-4.0);
1712   /* for DATE values 0.0 < x < 1.0, x and -x represent the same datetime */
1713   /* but when converting to DATE, prefer the positive versions */
1714   UD2T(30,12,1899,6,0,0,0,6,364,0,S_OK,0.25);
1715 }
1716
1717 static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1718                        WORD s, WORD ms, INT r, double dt)
1719 {
1720     SYSTEMTIME st;
1721     double out;
1722     INT res;
1723
1724     st.wYear = y;
1725     st.wMonth = m;
1726     st.wDay = d;
1727     st.wHour = h;
1728     st.wMinute = mn;
1729     st.wSecond = s;
1730     st.wMilliseconds = ms;
1731     st.wDayOfWeek = 0;
1732     res = pSystemTimeToVariantTime(&st, &out);
1733     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1734                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1735 }
1736 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)
1737
1738 static void test_SystemTimeToVariantTime(void)
1739 {
1740   CHECKPTR(SystemTimeToVariantTime);
1741   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1742   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1743   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
1744   ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1745   ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* 30 <= year < 100 is 1900+year */
1746   ST2DT(1,1,30,0,0,0,0,TRUE,10959.0);     /* 30 <= year < 100 is 1900+year */
1747   ST2DT(1,1,29,0,0,0,0,TRUE,47119.0);     /* 0 <= year < 30 is 2000+year */
1748   ST2DT(1,1,0,0,0,0,0,TRUE,36526.0);      /* 0 <= year < 30 is 2000+year */
1749 }
1750
1751 static void test_dt2st(int line, double dt, INT r, WORD d, WORD m, WORD y,
1752                        WORD h, WORD mn, WORD s, WORD ms)
1753 {
1754   SYSTEMTIME st;
1755   INT res;
1756
1757   memset(&st, 0, sizeof(st));
1758   res = pVariantTimeToSystemTime(dt, &st);
1759   ok_(__FILE__,line)(r == res &&
1760                      (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
1761                              st.wHour == h && st.wMinute == mn &&
1762                              st.wSecond == s && st.wMilliseconds == ms)),
1763                      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
1764                      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
1765                      st.wYear, st.wHour, st.wMinute, st.wSecond,
1766                      st.wMilliseconds);
1767 }
1768 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)
1769
1770 static void test_VariantTimeToSystemTime(void)
1771 {
1772   CHECKPTR(VariantTimeToSystemTime);
1773   DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1774   DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1775 }
1776
1777 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1778 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1779
1780 static void test_dos2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1781                         WORD s, INT r, double dt)
1782 {
1783     unsigned short dosDate, dosTime;
1784     double out;
1785     INT res;
1786
1787     out = 0.0;
1788     dosDate = MKDOSDATE(d, m, y);
1789     dosTime = MKDOSTIME(h, mn, s);
1790     res = pDosDateTimeToVariantTime(dosDate, dosTime, &out);
1791     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1792                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1793 }
1794 #define DOS2DT(d,m,y,h,mn,s,r,dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)
1795
1796 static void test_DosDateTimeToVariantTime(void)
1797 {
1798   CHECKPTR(DosDateTimeToVariantTime);
1799
1800   /* Date */
1801   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1802   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1803   /* Dates are limited to the dos date max of 31/12/2099 */
1804   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1805   /* Days and months of 0 cause date to roll back 1 day or month */
1806   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1807   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
1808   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1809   /* Days > days in the month cause date to roll forward 1 month */
1810   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1811   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1812   /* Takes leap years into account when rolling forward */
1813   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1814   /* Months > 12 cause an error */
1815   DOS2DT(2,13,1980,0,0,0,0,0.0);
1816
1817   /* Time */
1818   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1819   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1820   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1821   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid minutes */
1822   DOS2DT(1,1,1980,0,0,60,0,0.0);               /* Invalid seconds */
1823   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1824   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
1825
1826   DOS2DT(1,1,1980,0,0,1,1,29221.0);
1827   DOS2DT(2,1,1980,0,0,0,1,29222.0);
1828   DOS2DT(2,1,1980,0,0,0,1,29222.0);
1829   DOS2DT(31,12,1990,0,0,0,1,33238.0);
1830   DOS2DT(31,12,90,0,0,0,1,40543.0);
1831   DOS2DT(30,12,1899,0,0,0,1,46751.0);
1832   DOS2DT(1,1,100,0,0,0,1,43831.0);
1833   DOS2DT(31,12,9999,0,0,0,1,59901.0);
1834   DOS2DT(1,1,10000,0,0,0,1,59902.0);
1835   DOS2DT(1,1,-10000,0,0,0,1,48214.0);
1836
1837   DOS2DT(30,12,1899,0,0,0,1,46751.0);
1838   DOS2DT(30,12,1899,0,0,1,1,46751.0);
1839
1840   DOS2DT(1,1,1980,18,1,16,1,29221.75087962963);
1841   DOS2DT(1,300,1980,18,1,16,1,29556.75087962963);
1842   DOS2DT(300,1,1980,18,1,16,1,29232.75087962963);
1843   DOS2DT(0,1,1980,42,1,16,1,29220.4175462963);
1844   DOS2DT(1,1,1980,17,61,16,0,0.0);
1845   DOS2DT(1,1,1980,18,0,76,1,29221.75013888889);
1846   DOS2DT(1,-300,1980,18,1,16,1,29312.75087962963);
1847   DOS2DT(-300,1,1980,18,1,16,1,29240.75087962963);
1848   DOS2DT(3,1,1980,-30,1,16,1,29223.08421296296);
1849   DOS2DT(1,1,1980,20,-119,16,1,29221.83976851852);
1850   DOS2DT(1,1,1980,18,3,-104,1,29221.75236111111);
1851   DOS2DT(1,12001,-1020,18,1,16,1,55519.75087962963);
1852   DOS2DT(1,-23,1982,18,1,16,1,30195.75087962963);
1853   DOS2DT(-59,3,1980,18,1,16,1,29285.75087962963);
1854   DOS2DT(1,1,0,0,0,0,1,54058.0);
1855   DOS2DT(0,0,1980,0,0,0,1,29189.0);
1856   DOS2DT(0,1,1980,0,0,0,1,29220.0);
1857   DOS2DT(-1,1,1980,18,1,16,1,29251.75087962963);
1858   DOS2DT(1,1,-1,18,1,16,1,53693.75087962963);
1859   DOS2DT(1,-1,1980,18,1,16,0,0);
1860 }
1861
1862 static void test_dt2dos(int line, double dt, INT r, WORD d, WORD m, WORD y,
1863                         WORD h, WORD mn, WORD s)
1864 {
1865     unsigned short dosDate, dosTime, expDosDate, expDosTime;
1866     INT res;
1867
1868     dosTime = dosDate = 0;
1869     expDosDate = MKDOSDATE(d,m,y);
1870     expDosTime = MKDOSTIME(h,mn,s);
1871     res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime);
1872     ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
1873                        "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
1874                        dt, r, expDosDate, expDosDate & 0x1f,
1875                        (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
1876                        expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
1877                        (expDosTime & 0x1f),
1878                        res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
1879                        1980 + (dosDate >> 9), dosTime, dosTime >> 11,
1880                        (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
1881 }
1882 #define DT2DOS(dt,r,d,m,y,h,mn,s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)
1883
1884 static void test_VariantTimeToDosDateTime(void)
1885 {
1886   CHECKPTR(VariantTimeToDosDateTime);
1887
1888   /* Date */
1889   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
1890   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1891   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
1892   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
1893
1894   /* Time */
1895   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1896   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1897   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1898   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1899 }
1900
1901 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1902
1903 #define VARABS(vt,val,rvt,rval)                  \
1904     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
1905     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1906     test_var_call1( __LINE__, pVarAbs, &v, &exp )
1907
1908 static void test_VarAbs(void)
1909 {
1910     static WCHAR szNum[] = {'-','1','.','1','\0' };
1911     char buff[8];
1912     HRESULT hres;
1913     VARIANT v, vDst, exp;
1914     size_t i;
1915
1916     CHECKPTR(VarAbs);
1917
1918     /* Test all possible V_VT values.
1919      */
1920     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1921     {
1922         VARTYPE vt;
1923
1924         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1925         {
1926             HRESULT hExpected = DISP_E_BADVARTYPE;
1927
1928             SKIPTESTS(vt);
1929
1930             memset(&v, 0, sizeof(v));
1931             V_VT(&v) = vt | ExtraFlags[i];
1932             V_VT(&vDst) = VT_EMPTY;
1933
1934             hres = pVarAbs(&v,&vDst);
1935             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1936                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1937                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1938             {
1939                 hExpected = DISP_E_TYPEMISMATCH;
1940             }
1941             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1942             {
1943                 hExpected = DISP_E_BADVARTYPE;
1944             }
1945             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1946                 hExpected = S_OK;
1947
1948             /* Native always fails on some vartypes that should be valid. don't
1949              * check that Wine does the same; these are bugs in native.
1950              */
1951             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1952                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1953                 continue;
1954             ok(hres == hExpected, "VarAbs: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
1955                hExpected, hres, vt, ExtraFlags[i]);
1956         }
1957     }
1958
1959     /* BOOL->I2, BSTR->R8, all others remain the same */
1960     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1961     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1962     VARABS(EMPTY,0,I2,0);
1963     VARABS(EMPTY,1,I2,0);
1964     VARABS(NULL,0,NULL,0);
1965     VARABS(NULL,1,NULL,0);
1966     VARABS(I2,1,I2,1);
1967     VARABS(I2,-1,I2,1);
1968     VARABS(I4,1,I4,1);
1969     VARABS(I4,-1,I4,1);
1970     VARABS(UI1,1,UI1,1);
1971     VARABS(R4,1,R4,1);
1972     VARABS(R4,-1,R4,1);
1973     VARABS(R8,1,R8,1);
1974     VARABS(R8,-1,R8,1);
1975     VARABS(DATE,1,DATE,1);
1976     VARABS(DATE,-1,DATE,1);
1977     V_VT(&v) = VT_CY;
1978     V_CY(&v).int64 = -10000;
1979     memset(&vDst,0,sizeof(vDst));
1980     hres = pVarAbs(&v,&vDst);
1981     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1982        "VarAbs(CY): expected 0x0 got 0x%X\n", hres);
1983     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1984     if (buff[1])
1985     {
1986         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1987         return;
1988     } else {
1989         szNum[2] = buff[0];
1990     }
1991     V_VT(&v) = VT_BSTR;
1992     V_BSTR(&v) = (BSTR)szNum;
1993     memset(&vDst,0,sizeof(vDst));
1994     hres = pVarAbs(&v,&vDst);
1995     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1996        "VarAbs: expected 0x0,%d,%g, got 0x%X,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1997 }
1998
1999 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
2000
2001 #define VARNOT(vt,val,rvt,rval)                  \
2002     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2003     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2004     test_var_call1( __LINE__, pVarNot, &v, &exp )
2005
2006 static void test_VarNot(void)
2007 {
2008     static const WCHAR szNum0[] = {'0','\0' };
2009     static const WCHAR szNum1[] = {'1','\0' };
2010     HRESULT hres;
2011     VARIANT v, exp, vDst;
2012     DECIMAL *pdec = &V_DECIMAL(&v);
2013     CY *pcy = &V_CY(&v);
2014     size_t i;
2015
2016     CHECKPTR(VarNot);
2017
2018     /* Test all possible V_VT values */
2019     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2020     {
2021         VARTYPE vt;
2022
2023         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2024         {
2025             HRESULT hExpected = DISP_E_BADVARTYPE;
2026
2027             SKIPTESTS(vt);
2028
2029             memset(&v, 0, sizeof(v));
2030             V_VT(&v) = vt | ExtraFlags[i];
2031             V_VT(&vDst) = VT_EMPTY;
2032
2033             switch (V_VT(&v))
2034             {
2035             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
2036             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
2037             case VT_R4:  case VT_R8:
2038             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2039             case VT_DATE: case VT_CY:
2040                 hExpected = S_OK;
2041                 break;
2042             case VT_I8: case VT_UI8:
2043                 if (HAVE_OLEAUT32_I8)
2044                     hExpected = S_OK;
2045                 break;
2046             case VT_RECORD:
2047                 if (HAVE_OLEAUT32_RECORD)
2048                     hExpected = DISP_E_TYPEMISMATCH;
2049                 break;
2050             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
2051                 hExpected = DISP_E_TYPEMISMATCH;
2052                 break;
2053             default:
2054                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
2055                    hExpected = DISP_E_TYPEMISMATCH;
2056                 break;
2057             }
2058
2059             hres = pVarNot(&v,&vDst);
2060             ok(hres == hExpected, "VarNot: expected 0x%X, got 0x%X vt %d|0x%X\n",
2061                hExpected, hres, vt, ExtraFlags[i]);
2062         }
2063     }
2064     /* Test the values returned by all cases that can succeed */
2065     VARNOT(EMPTY,0,I2,-1);
2066     VARNOT(EMPTY,1,I2,-1);
2067     VARNOT(NULL,0,NULL,0);
2068     VARNOT(NULL,1,NULL,0);
2069     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
2070     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
2071     VARNOT(I1,-1,I4,0);
2072     VARNOT(I1,0,I4,-1);
2073     VARNOT(I2,-1,I2,0);
2074     VARNOT(I2,0,I2,-1);
2075     VARNOT(I2,1,I2,-2);
2076     VARNOT(I4,1,I4,-2);
2077     VARNOT(I4,0,I4,-1);
2078     VARNOT(UI1,1,UI1,254);
2079     VARNOT(UI1,0,UI1,255);
2080     VARNOT(UI2,0,I4,-1);
2081     VARNOT(UI2,1,I4,-2);
2082     VARNOT(UI4,0,I4,-1);
2083     VARNOT(UI4,1,I4,-2);
2084     VARNOT(INT,0,I4,-1);
2085     VARNOT(INT,1,I4,-2);
2086     VARNOT(UINT,0,I4,-1);
2087     VARNOT(UINT,1,I4,-2);
2088     if (HAVE_OLEAUT32_I8)
2089     {
2090         VARNOT(I8,1,I8,-2);
2091         VARNOT(I8,0,I8,-1);
2092         VARNOT(UI8,0,I4,-1);
2093         VARNOT(UI8,1,I4,-2);
2094     }
2095     VARNOT(R4,1,I4,-2);
2096     VARNOT(R4,0,I4,-1);
2097     VARNOT(R8,1,I4,-2);
2098     VARNOT(R8,0,I4,-1);
2099     VARNOT(DATE,1,I4,-2);
2100     VARNOT(DATE,0,I4,-1);
2101     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
2102     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
2103     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
2104     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
2105
2106     V_VT(&v) = VT_DECIMAL;
2107     S(U(*pdec)).sign = DECIMAL_NEG;
2108     S(U(*pdec)).scale = 0;
2109     pdec->Hi32 = 0;
2110     S1(U1(*pdec)).Mid32 = 0;
2111     S1(U1(*pdec)).Lo32 = 1;
2112     VARNOT(DECIMAL,*pdec,I4,0);
2113
2114     pcy->int64 = 10000;
2115     VARNOT(CY,*pcy,I4,-2);
2116
2117     pcy->int64 = 0;
2118     VARNOT(CY,*pcy,I4,-1);
2119
2120     pcy->int64 = -1;
2121     VARNOT(CY,*pcy,I4,-1);
2122 }
2123
2124 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
2125
2126 #define VARSUB(vt1,val1,vt2,val2,rvt,rval)               \
2127         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2128         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2129         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2130         test_var_call2( __LINE__, pVarSub, &left, &right, &exp )
2131
2132 static void test_VarSub(void)
2133 {
2134     VARIANT left, right, exp, result, cy, dec;
2135     VARTYPE i;
2136     BSTR lbstr, rbstr;
2137     HRESULT hres, expectedhres;
2138     double r;
2139
2140     CHECKPTR(VarSub);
2141
2142     lbstr = SysAllocString(sz12);
2143     rbstr = SysAllocString(sz12);
2144
2145     VariantInit(&left);
2146     VariantInit(&right);
2147     VariantInit(&result);
2148
2149     /* Test all possible flag/vt combinations & the resulting vt type */
2150     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2151     {
2152
2153         VARTYPE leftvt, rightvt, resvt;
2154
2155         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
2156         {
2157
2158             SKIPTESTS(leftvt);
2159
2160             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
2161             {
2162
2163                 SKIPTESTS(rightvt);
2164                 expectedhres = S_OK;
2165
2166                 memset(&left, 0, sizeof(left));
2167                 memset(&right, 0, sizeof(right));
2168                 V_VT(&left) = leftvt | ExtraFlags[i];
2169                 if (leftvt == VT_BSTR)
2170                     V_BSTR(&left) = lbstr;
2171                 V_VT(&right) = rightvt | ExtraFlags[i];
2172                 if (rightvt == VT_BSTR)
2173                     V_BSTR(&right) = rbstr;
2174                 V_VT(&result) = VT_EMPTY;
2175
2176                 /* All extra flags produce errors */
2177                 if (ExtraFlags[i] == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
2178                     ExtraFlags[i] == (VT_VECTOR|VT_RESERVED) ||
2179                     ExtraFlags[i] == (VT_VECTOR|VT_BYREF) ||
2180                     ExtraFlags[i] == (VT_BYREF|VT_RESERVED) ||
2181                     ExtraFlags[i] == VT_VECTOR ||
2182                     ExtraFlags[i] == VT_BYREF ||
2183                     ExtraFlags[i] == VT_RESERVED)
2184                 {
2185                     expectedhres = DISP_E_BADVARTYPE;
2186                     resvt = VT_EMPTY;
2187                 }
2188                 else if (ExtraFlags[i] >= VT_ARRAY)
2189                 {
2190                     expectedhres = DISP_E_TYPEMISMATCH;
2191                     resvt = VT_EMPTY;
2192                 }
2193                 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
2194                    VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
2195                 else if (!IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
2196                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
2197                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
2198                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
2199                     leftvt == VT_I1 || rightvt == VT_I1 ||
2200                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
2201                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
2202                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
2203                     leftvt == VT_INT || rightvt == VT_INT ||
2204                     leftvt == VT_UINT || rightvt == VT_UINT ||
2205                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
2206                     leftvt == VT_RECORD || rightvt == VT_RECORD)
2207                 {
2208                     if (leftvt == VT_RECORD && rightvt == VT_I8)
2209                     {
2210                         if (HAVE_OLEAUT32_I8)
2211                             expectedhres = DISP_E_TYPEMISMATCH;
2212                         else
2213                             expectedhres = DISP_E_BADVARTYPE;
2214                     }
2215                     else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
2216                         expectedhres = DISP_E_TYPEMISMATCH;
2217                     else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
2218                         expectedhres = DISP_E_TYPEMISMATCH;
2219                     else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
2220                         expectedhres = DISP_E_TYPEMISMATCH;
2221                     else if (leftvt == VT_RECORD && rightvt > VT_UI1)
2222                         expectedhres = DISP_E_BADVARTYPE;
2223                     else
2224                         expectedhres = DISP_E_BADVARTYPE;
2225                     resvt = VT_EMPTY;
2226                 }
2227                 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
2228                     (leftvt == VT_DISPATCH && rightvt == VT_NULL))
2229                     resvt = VT_NULL;
2230                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
2231                     leftvt == VT_ERROR || rightvt == VT_ERROR)
2232                 {
2233                     resvt = VT_EMPTY;
2234                     expectedhres = DISP_E_TYPEMISMATCH;
2235                 }
2236                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
2237                     resvt = VT_NULL;
2238                 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
2239                     (leftvt == VT_DATE && rightvt == VT_DATE) ||
2240                     (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
2241                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
2242                     resvt = VT_R8;
2243                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
2244                     resvt = VT_DECIMAL;
2245                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
2246                     resvt = VT_DATE;
2247                 else if (leftvt == VT_CY || rightvt == VT_CY)
2248                     resvt = VT_CY;
2249                 else if (leftvt == VT_R8 || rightvt == VT_R8)
2250                     resvt = VT_R8;
2251                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
2252                     resvt = VT_R8;
2253                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
2254                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
2255                         leftvt == VT_I8 || rightvt == VT_I8)
2256                         resvt = VT_R8;
2257                     else
2258                         resvt = VT_R4;
2259                 }
2260                 else if (leftvt == VT_I8 || rightvt == VT_I8)
2261                     resvt = VT_I8;
2262                 else if (leftvt == VT_I4 || rightvt == VT_I4)
2263                     resvt = VT_I4;
2264                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
2265                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
2266                     (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
2267                     resvt = VT_I2;
2268                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
2269                     resvt = VT_UI1;
2270                 else
2271                 {
2272                     resvt = VT_EMPTY;
2273                     expectedhres = DISP_E_TYPEMISMATCH;
2274                 }
2275
2276                 hres = pVarSub(&left, &right, &result);
2277
2278                 ok(hres == expectedhres && V_VT(&result) == resvt,
2279                     "VarSub: %d|0x%X, %d|0x%X: Expected failure 0x%X, "
2280                     "got 0x%X, expected vt %d got vt %d\n",
2281                     leftvt, ExtraFlags[i], rightvt, ExtraFlags[i],
2282                     expectedhres, hres, resvt, V_VT(&result));
2283             }
2284         }
2285     }
2286
2287     /* Test returned values */
2288     VARSUB(I4,4,I4,2,I4,2);
2289     VARSUB(I2,4,I2,2,I2,2);
2290     VARSUB(I2,-13,I4,5,I4,-18);
2291     VARSUB(I4,-13,I4,5,I4,-18);
2292     VARSUB(I2,7,R4,0.5f,R4,6.5f);
2293     VARSUB(R4,0.5f,I4,5,R8,-4.5);
2294     VARSUB(R8,7.1,BOOL,0,R8,7.1);
2295     VARSUB(BSTR,lbstr,I2,4,R8,8);
2296     VARSUB(BSTR,lbstr,BOOL,1,R8,11);
2297     VARSUB(BSTR,lbstr,R4,0.1f,R8,11.9);
2298     VARSUB(R4,0.2f,BSTR,rbstr,R8,-11.8);
2299     VARSUB(DATE,2.25,I4,7,DATE,-4.75);
2300     VARSUB(DATE,1.25,R4,-1.7f,DATE,2.95);
2301
2302     VARSUB(UI1, UI1_MAX, UI1, UI1_MAX, UI1, 0);
2303     VARSUB(I2, I2_MAX, I2, I2_MAX, I2, 0);
2304     VARSUB(I2, I2_MIN, I2, I2_MIN, I2, 0);
2305     VARSUB(I4, I4_MAX, I4, I4_MAX, I4, 0);
2306     VARSUB(I4, I4_MIN, I4, I4_MIN, I4, 0);
2307     VARSUB(R4, R4_MAX, R4, R4_MAX, R4, 0.0f);
2308     VARSUB(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX - R4_MIN);
2309     VARSUB(R4, R4_MIN, R4, R4_MIN, R4, 0.0f);
2310     VARSUB(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX - R8_MIN);
2311     VARSUB(R8, R8_MIN, R8, R8_MIN, R8, 0.0);
2312
2313     /* Manually test BSTR + BSTR */
2314     V_VT(&left) = VT_BSTR;
2315     V_BSTR(&left) = lbstr;
2316     V_VT(&right) = VT_BSTR;
2317     V_BSTR(&right) = rbstr;
2318     hres = pVarSub(&left, &right, &result);
2319     ok(hres == S_OK && V_VT(&result) == VT_R8,
2320         "VarSub: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
2321     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0),
2322         "VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
2323
2324     /* Manually test some VT_CY and VT_DECIMAL variants */
2325     V_VT(&cy) = VT_CY;
2326     hres = VarCyFromI4(4711, &V_CY(&cy));
2327     ok(hres == S_OK, "VarCyFromI4 failed!\n");
2328     V_VT(&dec) = VT_DECIMAL;
2329     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
2330     ok(hres == S_OK, "VarDecFromR4 failed!\n");
2331     memset(&left, 0, sizeof(left));
2332     memset(&right, 0, sizeof(right));
2333     V_VT(&left) = VT_I4;
2334     V_I4(&left) = -11;
2335     V_VT(&right) = VT_UI1;
2336     V_UI1(&right) = 9;
2337
2338     hres = pVarSub(&cy, &right, &result);
2339     ok(hres == S_OK && V_VT(&result) == VT_CY,
2340         "VarSub: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
2341     hres = VarR8FromCy(V_CY(&result), &r);
2342     ok(hres == S_OK && EQ_DOUBLE(r, 4702),
2343         "VarSub: CY value %f, expected %f\n", r, (double)4720);
2344
2345     hres = pVarSub(&left, &dec, &result);
2346     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
2347         "VarSub: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
2348     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
2349     ok(hres == S_OK && EQ_DOUBLE(r, -6.8),
2350         "VarSub: DECIMAL value %f, expected %f\n", r, (double)-15.2);
2351
2352     SysFreeString(lbstr);
2353     SysFreeString(rbstr);
2354 }
2355
2356 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2357
2358 static void test_Mod( int line, VARIANT *left, VARIANT *right, VARIANT *expected, HRESULT expres )
2359 {
2360     VARIANT result;
2361     HRESULT hres;
2362
2363     memset( &result, 0, sizeof(result) );
2364     hres = pVarMod( left, right, &result );
2365     ok_(__FILE__,line)( hres == expres, "wrong result %x/%x\n", hres, expres );
2366     if (hres == S_OK)
2367         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
2368                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
2369 }
2370
2371 #define VARMOD(vt1,vt2,val1,val2,rvt,rval)               \
2372         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2373         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2374         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2375         test_var_call2( __LINE__, pVarMod, &left, &right, &exp )
2376
2377 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected)         \
2378         V_VT(&left) = VT_##vt1; V_I4(&left) = val1;           \
2379         V_VT(&right) = VT_##vt2; V_I4(&right) = val2;         \
2380         V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval;             \
2381         test_Mod( __LINE__, &left, &right, &exp, hexpected )
2382
2383 static void test_VarMod(void)
2384 {
2385   VARIANT v1, v2, vDst, left, right, exp;
2386   HRESULT hres;
2387   HRESULT hexpected = 0;
2388   static const WCHAR szNum0[] = {'1','2','5','\0'};
2389   static const WCHAR szNum1[] = {'1','0','\0'};
2390   int l, r;
2391   BOOL lFound, rFound;
2392   BOOL lValid;
2393   BSTR strNum0, strNum1;
2394
2395   CHECKPTR(VarMod);
2396
2397   VARMOD(I1,BOOL,100,10,I4,0);
2398   VARMOD(I1,I1,100,10,I4,0);
2399   VARMOD(I1,UI1,100,10,I4,0);
2400   VARMOD(I1,I2,100,10,I4,0);
2401   VARMOD(I1,UI2,100,10,I4,0);
2402   VARMOD(I1,I4,100,10,I4,0);
2403   VARMOD(I1,UI4,100,10,I4,0);
2404   VARMOD(I1,R4,100,10,I4,0);
2405   VARMOD(I1,R8,100,10,I4,0);
2406
2407   VARMOD(UI1,BOOL,100,10,I2,0);
2408   VARMOD(UI1,I1,100,10,I4,0);
2409   VARMOD(UI1,UI1,100,10,UI1,0);
2410   VARMOD(UI1,I2,100,10,I2,0);
2411   VARMOD(UI1,UI2,100,10,I4,0);
2412   VARMOD(UI1,I4,100,10,I4,0);
2413   VARMOD(UI1,UI4,100,10,I4,0);
2414   VARMOD(UI1,R4,100,10,I4,0);
2415   VARMOD(UI1,R8,100,10,I4,0);
2416
2417   VARMOD(I2,BOOL,100,10,I2,0);
2418   VARMOD(I2,I1,100,10,I4,0);
2419   VARMOD(I2,UI1,100,10,I2,0);
2420   VARMOD(I2,I2,100,10,I2,0);
2421   VARMOD(I2,UI2,100,10,I4,0);
2422   VARMOD(I2,I4,100,10,I4,0);
2423   VARMOD(I2,UI4,100,10,I4,0);
2424   VARMOD(I2,R4,100,10,I4,0);
2425   VARMOD(I2,R8,100,10,I4,0);
2426
2427   VARMOD(I4,BOOL,100,10,I4,0);
2428   VARMOD(I4,I1,100,10,I4,0);
2429   VARMOD(I4,UI1,100,10,I4,0);
2430   VARMOD(I4,I2,100,10,I4,0);
2431   VARMOD(I4,UI2,100,10,I4,0);
2432   VARMOD(I4,I4,100,10,I4,0);
2433   VARMOD(I4,UI4,100,10,I4,0);
2434   VARMOD(I4,R4,100,10,I4,0);
2435   VARMOD(I4,R8,100,10,I4,0);
2436   VARMOD(UI4,BOOL,100,10,I4,0);
2437   VARMOD(UI4,I1,100,10,I4,0);
2438   VARMOD(UI4,UI1,100,10,I4,0);
2439   VARMOD(UI4,I2,100,10,I4,0);
2440   VARMOD(UI4,UI2,100,10,I4,0);
2441   VARMOD(UI4,I4,100,10,I4,0);
2442   VARMOD(UI4,UI4,100,10,I4,0);
2443   VARMOD(UI4,R4,100,10,I4,0);
2444   VARMOD(UI4,R8,100,10,I4,0);
2445   VARMOD(R4,BOOL,100,10,I4,0);
2446   VARMOD(R4,I1,100,10,I4,0);
2447   VARMOD(R4,UI1,100,10,I4,0);
2448   VARMOD(R4,I2,100,10,I4,0);
2449   VARMOD(R4,UI2,100,10,I4,0);
2450   VARMOD(R4,I4,100,10,I4,0);
2451   VARMOD(R4,UI4,100,10,I4,0);
2452   VARMOD(R4,R4,100,10,I4,0);
2453   VARMOD(R4,R8,100,10,I4,0);
2454   VARMOD(R8,BOOL,100,10,I4,0);
2455   VARMOD(R8,I1,100,10,I4,0);
2456   VARMOD(R8,UI1,100,10,I4,0);
2457   VARMOD(R8,I2,100,10,I4,0);
2458   VARMOD(R8,UI2,100,10,I4,0);
2459   VARMOD(R8,I4,100,10,I4,0);
2460   VARMOD(R8,UI4,100,10,I4,0);
2461   VARMOD(R8,R4,100,10,I4,0);
2462   VARMOD(R8,R8,100,10,I4,0);
2463
2464   VARMOD(INT,INT,100,10,I4,0);
2465   VARMOD(INT,UINT,100,10,I4,0);
2466
2467   VARMOD(BOOL,BOOL,100,10,I2,0);
2468   VARMOD(BOOL,I1,100,10,I4,0);
2469   VARMOD(BOOL,UI1,100,10,I2,0);
2470   VARMOD(BOOL,I2,100,10,I2,0);
2471   VARMOD(BOOL,UI2,100,10,I4,0);
2472   VARMOD(BOOL,I4,100,10,I4,0);
2473   VARMOD(BOOL,UI4,100,10,I4,0);
2474   VARMOD(BOOL,R4,100,10,I4,0);
2475   VARMOD(BOOL,R8,100,10,I4,0);
2476   VARMOD(BOOL,DATE,100,10,I4,0);
2477
2478   VARMOD(DATE,BOOL,100,10,I4,0);
2479   VARMOD(DATE,I1,100,10,I4,0);
2480   VARMOD(DATE,UI1,100,10,I4,0);
2481   VARMOD(DATE,I2,100,10,I4,0);
2482   VARMOD(DATE,UI2,100,10,I4,0);
2483   VARMOD(DATE,I4,100,10,I4,0);
2484   VARMOD(DATE,UI4,100,10,I4,0);
2485   VARMOD(DATE,R4,100,10,I4,0);
2486   VARMOD(DATE,R8,100,10,I4,0);
2487   VARMOD(DATE,DATE,100,10,I4,0);
2488
2489   strNum0 = SysAllocString(szNum0);
2490   strNum1 = SysAllocString(szNum1);
2491   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5);
2492   VARMOD(BSTR,I1,strNum0,10,I4,5);
2493   VARMOD(BSTR,I2,strNum0,10,I4,5);
2494   VARMOD(BSTR,I4,strNum0,10,I4,5);
2495   VARMOD(BSTR,R4,strNum0,10,I4,5);
2496   VARMOD(BSTR,R8,strNum0,10,I4,5);
2497   VARMOD(I4,BSTR,125,strNum1,I4,5);
2498
2499   if (HAVE_OLEAUT32_I8)
2500   {
2501     VARMOD(BOOL,I8,100,10,I8,0);
2502     VARMOD(I1,I8,100,10,I8,0);
2503     VARMOD(UI1,I8,100,10,I8,0);
2504     VARMOD(I2,I8,100,10,I8,0);
2505     VARMOD(I4,I8,100,10,I8,0);
2506     VARMOD(UI4,I8,100,10,I8,0);
2507     VARMOD(R4,I8,100,10,I8,0);
2508     VARMOD(R8,I8,100,10,I8,0);
2509     VARMOD(DATE,I8,100,10,I8,0);
2510
2511     VARMOD(I8,BOOL,100,10,I8,0);
2512     VARMOD(I8,I1,100,10,I8,0);
2513     VARMOD(I8,UI1,100,10,I8,0);
2514     VARMOD(I8,I2,100,10,I8,0);
2515     VARMOD(I8,UI2,100,10,I8,0);
2516     VARMOD(I8,I4,100,10,I8,0);
2517     VARMOD(I8,UI4,100,10,I8,0);
2518     VARMOD(I8,R4,100,10,I8,0);
2519     VARMOD(I8,R8,100,10,I8,0);
2520     VARMOD(I8,I8,100,10,I8,0);
2521
2522     VARMOD(BSTR,I8,strNum0,10,I8,5);
2523   }
2524
2525   /* test all combinations of types */
2526   for(l = 0; l < VT_BSTR_BLOB; l++)
2527   {
2528     SKIPTESTS(l);
2529
2530     for(r = 0; r < VT_BSTR_BLOB; r++)
2531     {
2532       SKIPTESTS(r);
2533
2534       if(l == VT_BSTR) continue;
2535       if(l == VT_DISPATCH) continue;
2536       if(r == VT_BSTR) continue;
2537       if(r == VT_DISPATCH) continue;
2538
2539       lFound = TRUE;
2540       lValid = TRUE;
2541       switch(l)
2542         {
2543         case VT_EMPTY:
2544         case VT_NULL:
2545         case VT_I1:
2546         case VT_UI1:
2547         case VT_I2:
2548         case VT_UI2:
2549         case VT_I4:
2550         case VT_I8:
2551         case VT_UI4:
2552         case VT_UI8:
2553         case VT_INT:
2554         case VT_UINT:
2555         case VT_R4:
2556         case VT_R8:
2557         case VT_BOOL:
2558         case VT_DATE:
2559         case VT_CY:
2560         case VT_DECIMAL:
2561           hexpected = S_OK;
2562           break;
2563         case VT_ERROR:
2564         case VT_VARIANT:
2565         case VT_UNKNOWN:
2566         case VT_RECORD:
2567           lValid = FALSE;
2568           break;
2569         default:
2570           lFound = FALSE;
2571           hexpected = DISP_E_BADVARTYPE;
2572           break;
2573         }
2574
2575       rFound = TRUE;
2576       switch(r)
2577         {
2578         case VT_EMPTY:
2579         case VT_NULL:
2580         case VT_I1:
2581         case VT_UI1:
2582         case VT_I2:
2583         case VT_UI2:
2584         case VT_I4:
2585         case VT_I8:
2586         case VT_UI4:
2587         case VT_UI8:
2588         case VT_INT:
2589         case VT_UINT:
2590         case VT_R4:
2591         case VT_R8:
2592         case VT_BOOL:
2593         case VT_DATE:
2594         case VT_DECIMAL:
2595         case VT_CY:
2596           hexpected = S_OK;
2597           break;
2598         case VT_ERROR:
2599         case VT_VARIANT:
2600         case VT_UNKNOWN:
2601         case VT_RECORD:
2602           break;
2603         default:
2604           rFound = FALSE;
2605           break;
2606         }
2607
2608       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2609       {
2610         hexpected = DISP_E_TYPEMISMATCH;
2611       } else if((l == VT_EMPTY) && (r == VT_NULL))
2612       {
2613         hexpected = S_OK;
2614       } else if((l == VT_NULL) && (r == VT_EMPTY))
2615       {
2616         hexpected = S_OK;
2617       } else if((l == VT_EMPTY) && (r == VT_CY))
2618       {
2619         hexpected = S_OK;
2620       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2621       {
2622         hexpected = DISP_E_TYPEMISMATCH;
2623       } else if((r == VT_EMPTY) && lFound && lValid)
2624       {
2625         hexpected = DISP_E_DIVBYZERO;
2626       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2627       {
2628         hexpected = DISP_E_TYPEMISMATCH;
2629       } else if((l == VT_NULL) && (r == VT_NULL))
2630       {
2631         hexpected = S_OK;
2632       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2633       {
2634         hexpected = DISP_E_TYPEMISMATCH;
2635       } else if((l == VT_NULL) && (r == VT_RECORD))
2636       {
2637         hexpected = DISP_E_TYPEMISMATCH;
2638       } else if((l == VT_I8) && (r == VT_DECIMAL))
2639       {
2640         hexpected = S_OK;
2641       } else if((l == VT_DECIMAL) && (r == VT_I8))
2642       {
2643         hexpected = S_OK;
2644       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2645       {
2646         hexpected = DISP_E_TYPEMISMATCH;
2647       } else if((l == VT_NULL) && rFound)
2648       {
2649         hexpected = S_OK;
2650       } else if(l == VT_RECORD)
2651       {
2652         hexpected = DISP_E_TYPEMISMATCH;
2653       } else if((r == VT_RECORD) && lValid && lFound)
2654       {
2655         hexpected = DISP_E_TYPEMISMATCH;
2656       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2657       {
2658         hexpected = DISP_E_DIVBYZERO;
2659       } else if((l == VT_CY) && !rFound)
2660       {
2661         hexpected = DISP_E_BADVARTYPE;
2662       } else if(lFound && !rFound)
2663       {
2664         hexpected = DISP_E_BADVARTYPE;
2665       } else if(!lFound && rFound)
2666       {
2667         hexpected = DISP_E_BADVARTYPE;
2668       } else if((r == VT_NULL) && lFound && lValid)
2669       {
2670         hexpected = S_OK;
2671       } else if((l == VT_NULL) || (r == VT_NULL))
2672       {
2673         hexpected = DISP_E_BADVARTYPE;
2674       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2675       {
2676         hexpected = DISP_E_BADVARTYPE;
2677       } else if(lFound && !rFound)
2678       {
2679         hexpected = DISP_E_BADVARTYPE;
2680       } else if(!lFound && !rFound)
2681       {
2682         hexpected = DISP_E_BADVARTYPE;
2683       }
2684
2685       V_VT(&v1) = l;
2686       V_VT(&v2) = r;
2687
2688       if(l == VT_CY)
2689         V_CY(&v1).int64 = 1000000;
2690       else if(l == VT_R4)
2691         V_R4(&v1) = 100;
2692       else if(l == VT_R8)
2693         V_R8(&v1) = 100;
2694       else if(l == VT_UI8)
2695         V_UI8(&v1) = 100;
2696       else if(l == VT_I8)
2697         V_I8(&v1) = 100;
2698       else if(l == VT_DATE)
2699         V_DATE(&v1) = 1000;
2700       else if (l == VT_DECIMAL)
2701       {
2702         V_DECIMAL(&v1).Hi32 = 0;
2703         U1(V_DECIMAL(&v1)).Lo64 = 100;
2704         U(V_DECIMAL(&v1)).signscale = 0;
2705       }
2706       else
2707         V_I4(&v1) = 10000;
2708
2709       if(r == VT_CY)
2710         V_CY(&v2).int64 = 10000;
2711       else if(r == VT_R4)
2712         V_R4(&v2) = 100;
2713       else if(r == VT_R8)
2714         V_R8(&v2) = 100;
2715       else if(r == VT_UI8)
2716         V_UI8(&v2) = 100;
2717       else if(r == VT_I8)
2718         V_I8(&v2) = 100;
2719       else if(r == VT_DATE)
2720         V_DATE(&v2) = 1000;
2721       else if (r == VT_DECIMAL)
2722       {
2723         V_DECIMAL(&v2).Hi32 = 0;
2724         U1(V_DECIMAL(&v2)).Lo64 = 100;
2725         U(V_DECIMAL(&v2)).signscale = 0;
2726       }
2727       else
2728         V_I4(&v2) = 10000;
2729
2730       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2731       {
2732         hres = pVarMod(&v1,&v2,&vDst);
2733         ok(hres == hexpected,
2734            "VarMod: expected 0x%x, got 0x%X for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2735       }
2736     }
2737   }
2738
2739
2740   /****************************/
2741   /* test some bad parameters */
2742   VARMOD(I4,I4,-1,-1,I4,0);
2743
2744   /* test modulus with zero */
2745   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2746
2747   VARMOD(I4,I4,0,10,I4,0); /* test 0 mod 10 */
2748
2749   /* right parameter is type empty */
2750   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2751
2752   /* left parameter is type empty */
2753   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2754
2755   /* mod with a null left value */
2756   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2757
2758   /* mod with a null right value */
2759   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2760
2761   /* void left value */
2762   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2763
2764   /* void right value */
2765   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2766
2767   /* null left value, void right value */
2768   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2769
2770   /* void left value, null right value */
2771   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2772
2773   /* some currencies */
2774   V_VT(&v1) = VT_CY;
2775   V_VT(&v2) = VT_CY;
2776   V_CY(&v1).int64 = 100000;
2777   V_CY(&v2).int64 = 100000;
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_CY;
2784   V_I4(&v1) = 100;
2785   V_CY(&v2).int64 = 100000;
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   /* some decimals */
2791   V_VT(&v1) = VT_DECIMAL;
2792   V_VT(&v2) = VT_DECIMAL;
2793   VarDecFromI4(100, &V_DECIMAL(&v1));
2794   VarDecFromI4(10, &V_DECIMAL(&v2));
2795   hres = pVarMod(&v1,&v2,&vDst);
2796   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2797      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2798
2799   V_VT(&v1) = VT_I4;
2800   V_VT(&v2) = VT_DECIMAL;
2801   V_I4(&v1) = 100;
2802   VarDecFromI4(10, &V_DECIMAL(&v2));
2803   hres = pVarMod(&v1,&v2,&vDst);
2804   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2805      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2806
2807   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2808
2809   /* test that an error results in the type of the result changing but not its value */
2810   V_VT(&v1) = VT_UNKNOWN;
2811   V_VT(&v2) = VT_EMPTY;
2812   V_I4(&v1) = 100;
2813   V_CY(&v2).int64 = 100000;
2814   V_VT(&vDst) = VT_I4;
2815   V_I4(&vDst) = 1231;
2816   hres = pVarMod(&v1,&v2,&vDst);
2817   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2818      "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));
2819
2820
2821   /* test some invalid types */
2822   /*TODO: not testing VT_DISPATCH */
2823   if (HAVE_OLEAUT32_I8)
2824   {
2825     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2826   }
2827   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2828   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2829   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2830   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2831   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2832   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2833   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2834   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2835   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2836   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2837   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2838   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2839   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2840   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2841   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2842   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2843   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2844   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2845   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2846   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2847   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2848   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2849   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2850   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2851
2852   /* test some more invalid types */
2853   V_VT(&v1) = 456;
2854   V_VT(&v2) = 234;
2855   V_I4(&v1) = 100;
2856   V_I4(&v2)=  10;
2857   hres = pVarMod(&v1,&v2,&vDst);
2858   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY,
2859      "VarMod: expected 0x%x,%d, got 0x%X,%d\n", DISP_E_BADVARTYPE, VT_EMPTY, hres, V_VT(&vDst));
2860
2861   SysFreeString(strNum0);
2862   SysFreeString(strNum1);
2863 }
2864
2865 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2866
2867 #define VARFIX(vt,val,rvt,rval)                  \
2868     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2869     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2870     test_var_call1( __LINE__, pVarFix, &v, &exp )
2871
2872 static void test_VarFix(void)
2873 {
2874     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2875     HRESULT hres;
2876     VARIANT v, exp, vDst;
2877     DECIMAL *pdec = &V_DECIMAL(&v);
2878     CY *pcy = &V_CY(&v);
2879     size_t i;
2880
2881     CHECKPTR(VarFix);
2882
2883     /* Test all possible V_VT values */
2884     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2885     {
2886         VARTYPE vt;
2887
2888         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2889         {
2890             HRESULT bFail = TRUE;
2891
2892             SKIPTESTS(vt);
2893
2894             memset(&v, 0, sizeof(v));
2895             V_VT(&v) = vt | ExtraFlags[i];
2896             V_VT(&vDst) = VT_EMPTY;
2897
2898             switch (V_VT(&v))
2899             {
2900               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2901               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2902               case VT_DATE: case VT_CY:
2903                 bFail = FALSE;
2904                 break;
2905               case VT_I8:
2906                 if (HAVE_OLEAUT32_I8)
2907                   bFail = FALSE;
2908                 break;
2909             }
2910
2911             hres = pVarFix(&v,&vDst);
2912             if (bFail)
2913               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2914                  "VarFix: expected failure, got 0x%X vt %d|0x%X\n",
2915                  hres, vt, ExtraFlags[i]);
2916             else
2917                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%X vt %d|0x%X\n",
2918                     hres, vt, ExtraFlags[i]);
2919         }
2920     }
2921
2922     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2923     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2924     VARFIX(BOOL,1,I2,1);
2925     VARFIX(UI1,1,UI1,1);
2926     VARFIX(I2,-1,I2,-1);
2927     VARFIX(I4,-1,I4,-1);
2928     if (HAVE_OLEAUT32_I8)
2929     {
2930         VARFIX(I8,-1,I8,-1);
2931     }
2932     VARFIX(R4,1.4f,R4,1);
2933     VARFIX(R4,1.5f,R4,1);
2934     VARFIX(R4,1.6f,R4,1);
2935     VARFIX(R4,-1.4f,R4,-1);
2936     VARFIX(R4,-1.5f,R4,-1);
2937     VARFIX(R4,-1.6f,R4,-1);
2938     /* DATE & R8 round as for R4 */
2939     VARFIX(DATE,-1,DATE,-1);
2940     VARFIX(R8,-1,R8,-1);
2941     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2942
2943     V_VT(&v) = VT_EMPTY;
2944     hres = pVarFix(&v,&vDst);
2945     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2946        "VarFix: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
2947        hres, V_VT(&vDst), V_I2(&vDst));
2948
2949     V_VT(&v) = VT_NULL;
2950     hres = pVarFix(&v,&vDst);
2951     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2952        "VarFix: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
2953
2954     V_VT(&v) = VT_DECIMAL;
2955     S(U(*pdec)).sign = DECIMAL_NEG;
2956     S(U(*pdec)).scale = 0;
2957     pdec->Hi32 = 0;
2958     S1(U1(*pdec)).Mid32 = 0;
2959     S1(U1(*pdec)).Lo32 = 1;
2960     hres = pVarFix(&v,&vDst);
2961     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
2962        "VarFix: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
2963        hres, V_VT(&vDst));
2964
2965     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2966
2967     V_VT(&v) = VT_CY;
2968     pcy->int64 = -10000;
2969     hres = pVarFix(&v,&vDst);
2970     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2971        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2972
2973     V_VT(&v) = VT_CY;
2974     pcy->int64 = -16000;
2975     hres = pVarFix(&v,&vDst);
2976     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2977        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2978 }
2979
2980 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2981
2982 #define VARINT(vt,val,rvt,rval)                  \
2983     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2984     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2985     test_var_call1( __LINE__, pVarInt, &v, &exp )
2986
2987 static void test_VarInt(void)
2988 {
2989     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2990     HRESULT hres;
2991     VARIANT v, exp, vDst;
2992     DECIMAL *pdec = &V_DECIMAL(&v);
2993     CY *pcy = &V_CY(&v);
2994     size_t i;
2995
2996     CHECKPTR(VarInt);
2997
2998     /* Test all possible V_VT values */
2999     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3000     {
3001         VARTYPE vt;
3002
3003         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3004         {
3005             HRESULT bFail = TRUE;
3006
3007             SKIPTESTS(vt);
3008
3009             memset(&v, 0, sizeof(v));
3010             V_VT(&v) = vt | ExtraFlags[i];
3011             V_VT(&vDst) = VT_EMPTY;
3012
3013             switch (V_VT(&v))
3014             {
3015               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
3016               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3017               case VT_DATE: case VT_CY:
3018                 bFail = FALSE;
3019                 break;
3020               case VT_I8:
3021                 if (HAVE_OLEAUT32_I8)
3022                   bFail = FALSE;
3023                 break;
3024             }
3025
3026             hres = pVarInt(&v,&vDst);
3027             if (bFail)
3028               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3029                  "VarInt: expected failure, got 0x%X vt %d|0x%X\n",
3030                  hres, vt, ExtraFlags[i]);
3031             else
3032                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%X vt %d|0x%X\n",
3033                     hres, vt, ExtraFlags[i]);
3034         }
3035     }
3036
3037     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
3038     VARINT(BOOL,VARIANT_FALSE,I2,0);
3039     VARINT(BOOL,1,I2,1);
3040     VARINT(UI1,1,UI1,1);
3041     VARINT(I2,-1,I2,-1);
3042     VARINT(I4,-1,I4,-1);
3043     if (HAVE_OLEAUT32_I8)
3044     {
3045         VARINT(I8,-1,I8,-1);
3046     }
3047     VARINT(R4,1.4f,R4,1);
3048     VARINT(R4,1.5f,R4,1);
3049     VARINT(R4,1.6f,R4,1);
3050     VARINT(R4,-1.4f,R4,-2); /* Note these 3 are different from VarFix */
3051     VARINT(R4,-1.5f,R4,-2);
3052     VARINT(R4,-1.6f,R4,-2);
3053     /* DATE & R8 round as for R4 */
3054     VARINT(DATE,-1,DATE,-1);
3055     VARINT(R8,-1,R8,-1);
3056     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
3057
3058     V_VT(&v) = VT_EMPTY;
3059     hres = pVarInt(&v,&vDst);
3060     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3061        "VarInt: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3062        hres, V_VT(&vDst), V_I2(&vDst));
3063
3064     V_VT(&v) = VT_NULL;
3065     hres = pVarInt(&v,&vDst);
3066     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3067        "VarInt: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3068
3069     V_VT(&v) = VT_DECIMAL;
3070     S(U(*pdec)).sign = DECIMAL_NEG;
3071     S(U(*pdec)).scale = 0;
3072     pdec->Hi32 = 0;
3073     S1(U1(*pdec)).Mid32 = 0;
3074     S1(U1(*pdec)).Lo32 = 1;
3075     hres = pVarInt(&v,&vDst);
3076     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
3077        "VarInt: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
3078        hres, V_VT(&vDst));
3079
3080     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
3081
3082     V_VT(&v) = VT_CY;
3083     pcy->int64 = -10000;
3084     hres = pVarInt(&v,&vDst);
3085     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
3086        "VarInt: VT_CY wrong, hres=0x%X\n", hres);
3087
3088     V_VT(&v) = VT_CY;
3089     pcy->int64 = -11000;
3090     hres = pVarInt(&v,&vDst);
3091     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
3092        "VarInt: VT_CY wrong, hres=0x%X 0x%x%08x\n",
3093        hres, (DWORD)(V_CY(&vDst).int64 >> 32), (DWORD)V_CY(&vDst).int64);
3094 }
3095
3096 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
3097
3098 #define VARNEG(vt,val,rvt,rval)                  \
3099     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3100     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3101     test_var_call1( __LINE__, pVarNeg, &v, &exp )
3102
3103 static void test_VarNeg(void)
3104 {
3105     static const WCHAR szNumMinus1[] = {'-','1','\0' };
3106     static const WCHAR szNum1[] = {'1','\0' };
3107     HRESULT hres;
3108     VARIANT v, exp, vDst;
3109     DECIMAL *pdec = &V_DECIMAL(&v);
3110     CY *pcy = &V_CY(&v);
3111     size_t i;
3112
3113     CHECKPTR(VarNeg);
3114
3115     /* Test all possible V_VT values. But don't test the exact return values
3116      * except for success/failure, since M$ made a hash of them in the
3117      * native version. This at least ensures (as with all tests here) that
3118      * we will notice if/when new vtypes/flags are added in native.
3119      */
3120     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3121     {
3122         VARTYPE vt;
3123
3124         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3125         {
3126             HRESULT bFail = TRUE;
3127
3128             SKIPTESTS(vt);
3129
3130             memset(&v, 0, sizeof(v));
3131             V_VT(&v) = vt | ExtraFlags[i];
3132             V_VT(&vDst) = VT_EMPTY;
3133
3134             switch (V_VT(&v))
3135             {
3136             case VT_UI1: case VT_I2: case VT_I4:
3137             case VT_R4:  case VT_R8:
3138             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3139             case VT_DATE: case VT_CY:
3140                 bFail = FALSE;
3141                 break;
3142             case VT_I8:
3143                 if (HAVE_OLEAUT32_I8)
3144                     bFail = FALSE;
3145             }
3146
3147             hres = pVarNeg(&v,&vDst);
3148             if (bFail)
3149                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3150                    "VarNeg: expected failure, got 0x%X vt %d|0x%X\n",
3151                    hres, vt, ExtraFlags[i]);
3152             else
3153                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%X vt %d|0x%X\n",
3154                     hres, vt, ExtraFlags[i]);
3155         }
3156     }
3157
3158     VARNEG(BOOL,VARIANT_TRUE,I2,1);
3159     VARNEG(BOOL,VARIANT_FALSE,I2,0);
3160     VARNEG(BOOL,1,I2,-1);
3161     VARNEG(UI1,1,I2,-1);
3162     VARNEG(UI1,254,I2,-254);
3163     VARNEG(I2,-32768,I4,32768);
3164     VARNEG(I2,-1,I2,1);
3165     VARNEG(I2,1,I2,-1);
3166     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
3167     VARNEG(I4,-1,I4,1);
3168     VARNEG(I4,1,I4,-1);
3169     if (HAVE_OLEAUT32_I8)
3170     {
3171         VARNEG(I8,1,I8,-1);
3172         VARNEG(I8,-1,I8,1);
3173     }
3174     VARNEG(R4,1,R4,-1);
3175     VARNEG(R4,-1,R4,1);
3176     VARNEG(DATE,1,DATE,-1);
3177     VARNEG(DATE,-1,DATE,1);
3178     VARNEG(R8,1,R8,-1);
3179     VARNEG(R8,-1,R8,1);
3180     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
3181     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
3182
3183     V_VT(&v) = VT_EMPTY;
3184     hres = pVarNeg(&v,&vDst);
3185     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3186        "VarNeg: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3187        hres, V_VT(&vDst), V_I2(&vDst));
3188
3189     V_VT(&v) = VT_NULL;
3190     hres = pVarNeg(&v,&vDst);
3191     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3192        "VarNeg: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3193
3194     V_VT(&v) = VT_DECIMAL;
3195     S(U(*pdec)).sign = DECIMAL_NEG;
3196     S(U(*pdec)).scale = 0;
3197     pdec->Hi32 = 0;
3198     S1(U1(*pdec)).Mid32 = 0;
3199     S1(U1(*pdec)).Lo32 = 1;
3200     hres = pVarNeg(&v,&vDst);
3201     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3202        S(U(V_DECIMAL(&vDst))).sign == 0,
3203        "VarNeg: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3204        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3205
3206     S(U(*pdec)).sign = 0;
3207     hres = pVarNeg(&v,&vDst);
3208     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3209        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3210        "VarNeg: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3211        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3212
3213     V_VT(&v) = VT_CY;
3214     pcy->int64 = -10000;
3215     hres = pVarNeg(&v,&vDst);
3216     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3217        "VarNeg: VT_CY wrong, hres=0x%X\n", hres);
3218 }
3219
3220 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
3221
3222 static void test_Round( int line, VARIANT *arg, int deci, VARIANT *expected )
3223 {
3224     VARIANT result;
3225     HRESULT hres;
3226
3227     memset( &result, 0, sizeof(result) );
3228     hres = pVarRound( arg, deci, &result );
3229     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
3230     if (hres == S_OK)
3231         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
3232                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
3233 }
3234 #define VARROUND(vt,val,deci,rvt,rval)           \
3235     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3236     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3237     test_Round( __LINE__, &v, deci, &exp )
3238
3239 static void test_VarRound(void)
3240 {
3241     static WCHAR szNumMin[] = {'-','1','.','4','4','9','\0' };
3242     static WCHAR szNum[] = {'1','.','4','5','1','\0' };
3243     HRESULT hres;
3244     VARIANT v, exp, vDst;
3245     CY *pcy = &V_CY(&v);
3246     char buff[8];
3247
3248     CHECKPTR(VarRound);
3249
3250     /* first check valid integer types */
3251     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
3252     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
3253     VARROUND(BOOL,1,0,I2,1);
3254     VARROUND(UI1,1,0,UI1,1);
3255     VARROUND(UI1,254,0,UI1,254);
3256     VARROUND(I2,-32768,0,I2,-32768);
3257     VARROUND(I2,-1,0,I2,-1);
3258     VARROUND(I2,1,0,I2,1);
3259     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
3260     VARROUND(I4,-1,0,I4,-1);
3261     VARROUND(I4,1,0,I4,1);
3262
3263
3264     /* MSDN states that rounding of R4/R8 is dependent on the underlying
3265      * bit pattern of the number and so is architecture dependent. In this
3266      * case Wine returns .2 (which is more correct) and Native returns .3
3267      */
3268
3269     VARROUND(R4,1.0f,0,R4,1.0f);
3270     VARROUND(R4,-1.0f,0,R4,-1.0f);
3271     VARROUND(R8,1.0,0,R8,1.0);
3272     VARROUND(R8,-1.0,0,R8,-1.0);
3273
3274     /* floating point numbers aren't exactly equal and we can't just
3275      * compare the first few digits. */
3276     VARROUND(DATE,1.451,1,DATE,1.5);
3277     VARROUND(DATE,-1.449,1,DATE,-1.4);
3278
3279     /* replace the decimal separator */
3280     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
3281     if (!buff[1]) {
3282         szNumMin[2] = buff[0];
3283         szNum[1] = buff[0];
3284         VARROUND(BSTR,(BSTR)szNumMin,1,R8,-1.40);
3285         VARROUND(BSTR,(BSTR)szNum,1,R8,1.50);
3286     } else {
3287         skip("Skipping VarRound(BSTR) as decimal separator is '%s'\n", buff);
3288     }
3289
3290     VARROUND(R4,1.23456f,0,R4,1.0f);
3291     VARROUND(R4,1.23456f,1,R4,1.2f);
3292     VARROUND(R4,1.23456f,2,R4,1.23f);
3293     VARROUND(R4,1.23456f,3,R4,1.235f);
3294     VARROUND(R4,1.23456f,4,R4,1.2346f);
3295     VARROUND(R4,-1.23456f,0,R4,-1.0f);
3296     VARROUND(R4,-1.23456f,1,R4,-1.2f);
3297     VARROUND(R4,-1.23456f,2,R4,-1.23f);
3298     VARROUND(R4,-1.23456f,3,R4,-1.235f);
3299     VARROUND(R4,-1.23456f,4,R4,-1.2346f);
3300
3301     VARROUND(R8,1.23456,0,R8,1.0);
3302     VARROUND(R8,1.23456,1,R8,1.2);
3303     VARROUND(R8,1.23456,2,R8,1.23);
3304     VARROUND(R8,1.23456,3,R8,1.235);
3305     VARROUND(R8,1.23456,4,R8,1.2346);
3306     VARROUND(R8,-1.23456,0,R8,-1.0);
3307     VARROUND(R8,-1.23456,1,R8,-1.2);
3308     VARROUND(R8,-1.23456,2,R8,-1.23);
3309     VARROUND(R8,-1.23456,3,R8,-1.235);
3310     VARROUND(R8,-1.23456,4,R8,-1.2346);
3311
3312     V_VT(&v) = VT_EMPTY;
3313     hres = pVarRound(&v,0,&vDst);
3314     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3315         "VarRound: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3316         hres, V_VT(&vDst), V_I2(&vDst));
3317
3318     V_VT(&v) = VT_NULL;
3319     hres = pVarRound(&v,0,&vDst);
3320     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3321         "VarRound: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3322
3323     /* not yet implemented so no use testing yet
3324     todo_wine {
3325         DECIMAL *pdec = &V_DECIMAL(&v);
3326         V_VT(&v) = VT_DECIMAL;
3327         S(U(*pdec)).sign = DECIMAL_NEG;
3328         S(U(*pdec)).scale = 0;
3329         pdec->Hi32 = 0;
3330         S1(U1(*pdec)).Mid32 = 0;
3331         S1(U1(*pdec)).Lo32 = 1;
3332         hres = pVarRound(&v,0,&vDst);
3333         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3334             S(U(V_DECIMAL(&vDst))).sign == 0,
3335             "VarRound: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3336             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3337
3338         S(U(*pdec)).sign = 0;
3339         hres = pVarRound(&v,0,&vDst);
3340         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3341             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3342             "VarRound: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3343             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3344     }
3345     */
3346
3347     V_VT(&v) = VT_CY;
3348     pcy->int64 = 10000;
3349     hres = pVarRound(&v,0,&vDst);
3350     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3351         "VarRound: VT_CY wrong, hres=0x%X\n", hres);
3352
3353 }
3354
3355 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
3356
3357 #define VARXOR(vt1,val1,vt2,val2,rvt,rval)               \
3358         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3359         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3360         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3361         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3362
3363 #define VARXORCY(vt1,val1,val2,rvt,rval)                 \
3364         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3365         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3366         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3367         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3368
3369 static void test_VarXor(void)
3370 {
3371     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3372     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3373     VARIANT left, right, exp, result;
3374     BSTR lbstr, rbstr;
3375     VARTYPE i;
3376     HRESULT hres;
3377
3378     CHECKPTR(VarXor);
3379
3380     /* Test all possible flag/vt combinations & the resulting vt type */
3381     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3382     {
3383         VARTYPE leftvt, rightvt, resvt;
3384
3385         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3386         {
3387
3388             SKIPTESTS(leftvt);
3389
3390             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3391             {
3392                 BOOL bFail = FALSE;
3393
3394                 SKIPTESTS(rightvt);
3395
3396                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3397                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3398                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3399                     continue;
3400
3401                 memset(&left, 0, sizeof(left));
3402                 memset(&right, 0, sizeof(right));
3403                 V_VT(&left) = leftvt | ExtraFlags[i];
3404                 V_VT(&right) = rightvt | ExtraFlags[i];
3405                 V_VT(&result) = VT_EMPTY;
3406                 resvt = VT_I4;
3407
3408                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3409                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3410                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3411                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3412                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3413                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3414                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3415                 {
3416                     bFail = TRUE;
3417                 }
3418                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3419                 {
3420                     if (leftvt == rightvt ||
3421                         leftvt == VT_I2 || rightvt == VT_I2 ||
3422                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3423                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3424                         resvt = VT_I2;
3425                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3426                         resvt = VT_NULL;
3427                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3428                         resvt = VT_I8;
3429                 }
3430                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3431                 {
3432                     resvt = VT_NULL;
3433                 }
3434                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3435                 {
3436                     if (leftvt == rightvt)
3437                         resvt = VT_UI1;
3438                     else if (leftvt == rightvt ||
3439                         leftvt == VT_I2 || rightvt == VT_I2 ||
3440                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3441                     {
3442                         resvt = VT_I2;
3443                     }
3444                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3445                         resvt = VT_I8;
3446                 }
3447                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3448                 {
3449                     if (leftvt == rightvt ||
3450                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3451                         resvt = VT_I2;
3452                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3453                         resvt = VT_I8;
3454                 }
3455                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3456                 {
3457                     resvt = VT_BOOL;
3458                 }
3459                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3460                 {
3461                     if (leftvt == VT_INT || rightvt == VT_INT)
3462                         bFail = TRUE;
3463                     else
3464                         resvt = VT_I8;
3465                 }
3466                 hres = pVarXor(&left, &right, &result);
3467                 if (bFail)
3468                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3469                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
3470                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3471                        V_VT(&result));
3472                 else
3473                     ok(hres == S_OK && V_VT(&result) == resvt,
3474                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
3475                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3476                        V_VT(&result));
3477             }
3478         }
3479     }
3480
3481     /* Test returned values
3482      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3483      */
3484     VARXOR(EMPTY,0,EMPTY,0,I2,0);
3485     VARXOR(EMPTY,1,EMPTY,0,I2,0);
3486     VARXOR(EMPTY,0,NULL,0,NULL,0);
3487     VARXOR(EMPTY,0,I1,0,I4,0);
3488     VARXOR(EMPTY,0,I1,1,I4,1);
3489     VARXOR(EMPTY,0,UI1,0,I2,0);
3490     VARXOR(EMPTY,0,UI1,1,I2,1);
3491     VARXOR(EMPTY,0,I2,0,I2,0);
3492     VARXOR(EMPTY,0,I2,1,I2,1);
3493     VARXOR(EMPTY,0,UI2,0,I4,0);
3494     VARXOR(EMPTY,0,UI2,1,I4,1);
3495     VARXOR(EMPTY,0,I4,0,I4,0);
3496     VARXOR(EMPTY,0,I4,1,I4,1);
3497     VARXOR(EMPTY,0,UI4,0,I4,0);
3498     VARXOR(EMPTY,0,UI4,1,I4,1);
3499     if (HAVE_OLEAUT32_I8)
3500     {
3501         VARXOR(EMPTY,0,I8,0,I8,0);
3502         VARXOR(EMPTY,0,I8,1,I8,1);
3503         VARXOR(EMPTY,0,UI8,0,I4,0);
3504         VARXOR(EMPTY,0,UI8,1,I4,1);
3505     }
3506     VARXOR(EMPTY,0,INT,0,I4,0);
3507     VARXOR(EMPTY,0,INT,1,I4,1);
3508     VARXOR(EMPTY,0,UINT,0,I4,0);
3509     VARXOR(EMPTY,0,UINT,1,I4,1);
3510     VARXOR(EMPTY,0,BOOL,0,I2,0);
3511     VARXOR(EMPTY,0,BOOL,1,I2,1);
3512     VARXOR(EMPTY,0,R4,0,I4,0);
3513     VARXOR(EMPTY,0,R4,1,I4,1);
3514     VARXOR(EMPTY,0,R8,0,I4,0);
3515     VARXOR(EMPTY,0,R8,1,I4,1);
3516     rbstr = SysAllocString(szFalse);
3517     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3518     SysFreeString(rbstr);
3519     rbstr = SysAllocString(szTrue);
3520     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3521     VARXORCY(EMPTY,0,10000,I4,1);
3522     SysFreeString(rbstr);
3523
3524     /* NULL OR 0 = NULL. NULL OR n = n */
3525     VARXOR(NULL,0,NULL,0,NULL,0);
3526     VARXOR(NULL,1,NULL,0,NULL,0);
3527     VARXOR(NULL,0,I1,0,NULL,0);
3528     VARXOR(NULL,0,I1,1,NULL,0);
3529     VARXOR(NULL,0,UI1,0,NULL,0);
3530     VARXOR(NULL,0,UI1,1,NULL,0);
3531     VARXOR(NULL,0,I2,0,NULL,0);
3532     VARXOR(NULL,0,I2,1,NULL,0);
3533     VARXOR(NULL,0,UI2,0,NULL,0);
3534     VARXOR(NULL,0,UI2,1,NULL,0);
3535     VARXOR(NULL,0,I4,0,NULL,0);
3536     VARXOR(NULL,0,I4,1,NULL,0);
3537     VARXOR(NULL,0,UI4,0,NULL,0);
3538     VARXOR(NULL,0,UI4,1,NULL,0);
3539     if (HAVE_OLEAUT32_I8)
3540     {
3541         VARXOR(NULL,0,I8,0,NULL,0);
3542         VARXOR(NULL,0,I8,1,NULL,0);
3543         VARXOR(NULL,0,UI8,0,NULL,0);
3544         VARXOR(NULL,0,UI8,1,NULL,0);
3545     }
3546     VARXOR(NULL,0,INT,0,NULL,0);
3547     VARXOR(NULL,0,INT,1,NULL,0);
3548     VARXOR(NULL,0,UINT,0,NULL,0);
3549     VARXOR(NULL,0,UINT,1,NULL,0);
3550     VARXOR(NULL,0,BOOL,0,NULL,0);
3551     VARXOR(NULL,0,BOOL,1,NULL,0);
3552     VARXOR(NULL,0,R4,0,NULL,0);
3553     VARXOR(NULL,0,R4,1,NULL,0);
3554     VARXOR(NULL,0,R8,0,NULL,0);
3555     VARXOR(NULL,0,R8,1,NULL,0);
3556     rbstr = SysAllocString(szFalse);
3557     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3558     SysFreeString(rbstr);
3559     rbstr = SysAllocString(szTrue);
3560     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3561     SysFreeString(rbstr);
3562     VARXORCY(NULL,0,10000,NULL,0);
3563     VARXORCY(NULL,0,0,NULL,0);
3564
3565     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3566     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3567     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3568     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3569     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3570     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3571     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3572     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3573     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3574     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3575     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3576     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3577     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3578     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3579     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3580     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3581     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3582     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3583     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3584     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3585     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3586     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3587     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3588     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3589     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3590     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3591     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3592     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3593     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3594     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3595     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3596     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3597     if (HAVE_OLEAUT32_I8)
3598     {
3599         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3600         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3601         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3602         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3603          * to I4 is performed.
3604          */
3605         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3606         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3607         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3608     }
3609     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3610     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3611     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3612     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3613     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3614     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3615     rbstr = SysAllocString(szFalse);
3616     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3617     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3618     SysFreeString(rbstr);
3619     rbstr = SysAllocString(szTrue);
3620     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3621     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3622     SysFreeString(rbstr);
3623     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3624     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3625     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3626
3627     VARXOR(I1,-1,I1,-1,I4,0);
3628     VARXOR(I1,-1,I1,0,I4,-1);
3629     VARXOR(I1,0,I1,0,I4,0);
3630     VARXOR(I1,-1,UI1,255,I4,-256);
3631     VARXOR(I1,-1,UI1,0,I4,-1);
3632     VARXOR(I1,0,UI1,0,I4,0);
3633     VARXOR(I1,-1,I2,-1,I4,0);
3634     VARXOR(I1,-1,I2,0,I4,-1);
3635     VARXOR(I1,0,I2,0,I4,0);
3636     VARXOR(I1,-1,UI2,65535,I4,-65536);
3637     VARXOR(I1,-1,UI2,0,I4,-1);
3638     VARXOR(I1,0,UI2,0,I4,0);
3639     VARXOR(I1,-1,I4,-1,I4,0);
3640     VARXOR(I1,-1,I4,0,I4,-1);
3641     VARXOR(I1,0,I4,0,I4,0);
3642     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3643     VARXOR(I1,-1,UI4,0,I4,-1);
3644     VARXOR(I1,0,UI4,0,I4,0);
3645     VARXOR(I1,-1,R4,-1,I4,0);
3646     VARXOR(I1,-1,R4,0,I4,-1);
3647     VARXOR(I1,0,R4,0,I4,0);
3648     VARXOR(I1,-1,R8,-1,I4,0);
3649     VARXOR(I1,-1,R8,0,I4,-1);
3650     VARXOR(I1,0,R8,0,I4,0);
3651     VARXOR(I1,-1,DATE,-1,I4,0);
3652     VARXOR(I1,-1,DATE,0,I4,-1);
3653     VARXOR(I1,0,DATE,0,I4,0);
3654     if (HAVE_OLEAUT32_I8)
3655     {
3656         VARXOR(I1,-1,I8,-1,I8,0);
3657         VARXOR(I1,-1,I8,0,I8,-1);
3658         VARXOR(I1,0,I8,0,I8,0);
3659         VARXOR(I1,-1,UI8,0,I4,-1);
3660         VARXOR(I1,0,UI8,0,I4,0);
3661     }
3662     VARXOR(I1,-1,INT,-1,I4,0);
3663     VARXOR(I1,-1,INT,0,I4,-1);
3664     VARXOR(I1,0,INT,0,I4,0);
3665     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3666     VARXOR(I1,-1,UINT,0,I4,-1);
3667     VARXOR(I1,0,UINT,0,I4,0);
3668     rbstr = SysAllocString(szFalse);
3669     VARXOR(I1,0,BSTR,rbstr,I4,0);
3670     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3671     SysFreeString(rbstr);
3672     rbstr = SysAllocString(szTrue);
3673     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3674     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3675     SysFreeString(rbstr);
3676     VARXORCY(I1,-1,10000,I4,-2);
3677     VARXORCY(I1,-1,0,I4,-1);
3678     VARXORCY(I1,0,0,I4,0);
3679
3680     VARXOR(UI1,255,UI1,255,UI1,0);
3681     VARXOR(UI1,255,UI1,0,UI1,255);
3682     VARXOR(UI1,0,UI1,0,UI1,0);
3683     VARXOR(UI1,255,I2,-1,I2,-256);
3684     VARXOR(UI1,255,I2,0,I2,255);
3685     VARXOR(UI1,0,I2,0,I2,0);
3686     VARXOR(UI1,255,UI2,65535,I4,65280);
3687     VARXOR(UI1,255,UI2,0,I4,255);
3688     VARXOR(UI1,0,UI2,0,I4,0);
3689     VARXOR(UI1,255,I4,-1,I4,-256);
3690     VARXOR(UI1,255,I4,0,I4,255);
3691     VARXOR(UI1,0,I4,0,I4,0);
3692     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3693     VARXOR(UI1,255,UI4,0,I4,255);
3694     VARXOR(UI1,0,UI4,0,I4,0);
3695     VARXOR(UI1,255,R4,-1,I4,-256);
3696     VARXOR(UI1,255,R4,0,I4,255);
3697     VARXOR(UI1,0,R4,0,I4,0);
3698     VARXOR(UI1,255,R8,-1,I4,-256);
3699     VARXOR(UI1,255,R8,0,I4,255);
3700     VARXOR(UI1,0,R8,0,I4,0);
3701     VARXOR(UI1,255,DATE,-1,I4,-256);
3702     VARXOR(UI1,255,DATE,0,I4,255);
3703     VARXOR(UI1,0,DATE,0,I4,0);
3704     if (HAVE_OLEAUT32_I8)
3705     {
3706         VARXOR(UI1,255,I8,-1,I8,-256);
3707         VARXOR(UI1,255,I8,0,I8,255);
3708         VARXOR(UI1,0,I8,0,I8,0);
3709         VARXOR(UI1,255,UI8,0,I4,255);
3710         VARXOR(UI1,0,UI8,0,I4,0);
3711     }
3712     VARXOR(UI1,255,INT,-1,I4,-256);
3713     VARXOR(UI1,255,INT,0,I4,255);
3714     VARXOR(UI1,0,INT,0,I4,0);
3715     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3716     VARXOR(UI1,255,UINT,0,I4,255);
3717     VARXOR(UI1,0,UINT,0,I4,0);
3718     rbstr = SysAllocString(szFalse);
3719     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3720     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3721     SysFreeString(rbstr);
3722     rbstr = SysAllocString(szTrue);
3723     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3724     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3725     SysFreeString(rbstr);
3726     VARXORCY(UI1,255,10000,I4,254);
3727     VARXORCY(UI1,255,0,I4,255);
3728     VARXORCY(UI1,0,0,I4,0);
3729
3730     VARXOR(I2,-1,I2,-1,I2,0);
3731     VARXOR(I2,-1,I2,0,I2,-1);
3732     VARXOR(I2,0,I2,0,I2,0);
3733     VARXOR(I2,-1,UI2,65535,I4,-65536);
3734     VARXOR(I2,-1,UI2,0,I4,-1);
3735     VARXOR(I2,0,UI2,0,I4,0);
3736     VARXOR(I2,-1,I4,-1,I4,0);
3737     VARXOR(I2,-1,I4,0,I4,-1);
3738     VARXOR(I2,0,I4,0,I4,0);
3739     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3740     VARXOR(I2,-1,UI4,0,I4,-1);
3741     VARXOR(I2,0,UI4,0,I4,0);
3742     VARXOR(I2,-1,R4,-1,I4,0);
3743     VARXOR(I2,-1,R4,0,I4,-1);
3744     VARXOR(I2,0,R4,0,I4,0);
3745     VARXOR(I2,-1,R8,-1,I4,0);
3746     VARXOR(I2,-1,R8,0,I4,-1);
3747     VARXOR(I2,0,R8,0,I4,0);
3748     VARXOR(I2,-1,DATE,-1,I4,0);
3749     VARXOR(I2,-1,DATE,0,I4,-1);
3750     VARXOR(I2,0,DATE,0,I4,0);
3751     if (HAVE_OLEAUT32_I8)
3752     {
3753         VARXOR(I2,-1,I8,-1,I8,0);
3754         VARXOR(I2,-1,I8,0,I8,-1);
3755         VARXOR(I2,0,I8,0,I8,0);
3756         VARXOR(I2,-1,UI8,0,I4,-1);
3757         VARXOR(I2,0,UI8,0,I4,0);
3758     }
3759     VARXOR(I2,-1,INT,-1,I4,0);
3760     VARXOR(I2,-1,INT,0,I4,-1);
3761     VARXOR(I2,0,INT,0,I4,0);
3762     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3763     VARXOR(I2,-1,UINT,0,I4,-1);
3764     VARXOR(I2,0,UINT,0,I4,0);
3765     rbstr = SysAllocString(szFalse);
3766     VARXOR(I2,0,BSTR,rbstr,I2,0);
3767     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3768     SysFreeString(rbstr);
3769     rbstr = SysAllocString(szTrue);
3770     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3771     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3772     SysFreeString(rbstr);
3773     VARXORCY(I2,-1,10000,I4,-2);
3774     VARXORCY(I2,-1,0,I4,-1);
3775     VARXORCY(I2,0,0,I4,0);
3776
3777     VARXOR(UI2,65535,UI2,65535,I4,0);
3778     VARXOR(UI2,65535,UI2,0,I4,65535);
3779     VARXOR(UI2,0,UI2,0,I4,0);
3780     VARXOR(UI2,65535,I4,-1,I4,-65536);
3781     VARXOR(UI2,65535,I4,0,I4,65535);
3782     VARXOR(UI2,0,I4,0,I4,0);
3783     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3784     VARXOR(UI2,65535,UI4,0,I4,65535);
3785     VARXOR(UI2,0,UI4,0,I4,0);
3786     VARXOR(UI2,65535,R4,-1,I4,-65536);
3787     VARXOR(UI2,65535,R4,0,I4,65535);
3788     VARXOR(UI2,0,R4,0,I4,0);
3789     VARXOR(UI2,65535,R8,-1,I4,-65536);
3790     VARXOR(UI2,65535,R8,0,I4,65535);
3791     VARXOR(UI2,0,R8,0,I4,0);
3792     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3793     VARXOR(UI2,65535,DATE,0,I4,65535);
3794     VARXOR(UI2,0,DATE,0,I4,0);
3795     if (HAVE_OLEAUT32_I8)
3796     {
3797         VARXOR(UI2,65535,I8,-1,I8,-65536);
3798         VARXOR(UI2,65535,I8,0,I8,65535);
3799         VARXOR(UI2,0,I8,0,I8,0);
3800         VARXOR(UI2,65535,UI8,0,I4,65535);
3801         VARXOR(UI2,0,UI8,0,I4,0);
3802     }
3803     VARXOR(UI2,65535,INT,-1,I4,-65536);
3804     VARXOR(UI2,65535,INT,0,I4,65535);
3805     VARXOR(UI2,0,INT,0,I4,0);
3806     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3807     VARXOR(UI2,65535,UINT,0,I4,65535);
3808     VARXOR(UI2,0,UINT,0,I4,0);
3809     rbstr = SysAllocString(szFalse);
3810     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3811     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3812     SysFreeString(rbstr);
3813     rbstr = SysAllocString(szTrue);
3814     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3815     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3816     SysFreeString(rbstr);
3817     VARXORCY(UI2,65535,10000,I4,65534);
3818     VARXORCY(UI2,65535,0,I4,65535);
3819     VARXORCY(UI2,0,0,I4,0);
3820
3821     VARXOR(I4,-1,I4,-1,I4,0);
3822     VARXOR(I4,-1,I4,0,I4,-1);
3823     VARXOR(I4,0,I4,0,I4,0);
3824     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3825     VARXOR(I4,-1,UI4,0,I4,-1);
3826     VARXOR(I4,0,UI4,0,I4,0);
3827     VARXOR(I4,-1,R4,-1,I4,0);
3828     VARXOR(I4,-1,R4,0,I4,-1);
3829     VARXOR(I4,0,R4,0,I4,0);
3830     VARXOR(I4,-1,R8,-1,I4,0);
3831     VARXOR(I4,-1,R8,0,I4,-1);
3832     VARXOR(I4,0,R8,0,I4,0);
3833     VARXOR(I4,-1,DATE,-1,I4,0);
3834     VARXOR(I4,-1,DATE,0,I4,-1);
3835     VARXOR(I4,0,DATE,0,I4,0);
3836     if (HAVE_OLEAUT32_I8)
3837     {
3838         VARXOR(I4,-1,I8,-1,I8,0);
3839         VARXOR(I4,-1,I8,0,I8,-1);
3840         VARXOR(I4,0,I8,0,I8,0);
3841         VARXOR(I4,-1,UI8,0,I4,-1);
3842         VARXOR(I4,0,UI8,0,I4,0);
3843     }
3844     VARXOR(I4,-1,INT,-1,I4,0);
3845     VARXOR(I4,-1,INT,0,I4,-1);
3846     VARXOR(I4,0,INT,0,I4,0);
3847     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3848     VARXOR(I4,-1,UINT,0,I4,-1);
3849     VARXOR(I4,0,UINT,0,I4,0);
3850     rbstr = SysAllocString(szFalse);
3851     VARXOR(I4,0,BSTR,rbstr,I4,0);
3852     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3853     SysFreeString(rbstr);
3854     rbstr = SysAllocString(szTrue);
3855     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3856     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3857     SysFreeString(rbstr);
3858     VARXORCY(I4,-1,10000,I4,-2);
3859     VARXORCY(I4,-1,0,I4,-1);
3860     VARXORCY(I4,0,0,I4,0);
3861
3862     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3863     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3864     VARXOR(UI4,0,UI4,0,I4,0);
3865     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3866     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3867     VARXOR(UI4,0,R4,0,I4,0);
3868     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3869     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3870     VARXOR(UI4,0,R8,0,I4,0);
3871     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3872     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3873     VARXOR(UI4,0,DATE,0,I4,0);
3874     if (HAVE_OLEAUT32_I8)
3875     {
3876         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3877         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3878         VARXOR(UI4,0,I8,0,I8,0);
3879         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3880         VARXOR(UI4,0,UI8,0,I4,0);
3881     }
3882     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3883     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3884     VARXOR(UI4,0,INT,0,I4,0);
3885     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3886     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3887     VARXOR(UI4,0,UINT,0,I4,0);
3888     rbstr = SysAllocString(szFalse);
3889     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3890     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3891     SysFreeString(rbstr);
3892     rbstr = SysAllocString(szTrue);
3893     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3894     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3895     SysFreeString(rbstr);
3896     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3897     VARXORCY(UI4,0xffffffff,0,I4,-1);
3898     VARXORCY(UI4,0,0,I4,0);
3899
3900     VARXOR(R4,-1,R4,-1,I4,0);
3901     VARXOR(R4,-1,R4,0,I4,-1);
3902     VARXOR(R4,0,R4,0,I4,0);
3903     VARXOR(R4,-1,R8,-1,I4,0);
3904     VARXOR(R4,-1,R8,0,I4,-1);
3905     VARXOR(R4,0,R8,0,I4,0);
3906     VARXOR(R4,-1,DATE,-1,I4,0);
3907     VARXOR(R4,-1,DATE,0,I4,-1);
3908     VARXOR(R4,0,DATE,0,I4,0);
3909     if (HAVE_OLEAUT32_I8)
3910     {
3911         VARXOR(R4,-1,I8,-1,I8,0);
3912         VARXOR(R4,-1,I8,0,I8,-1);
3913         VARXOR(R4,0,I8,0,I8,0);
3914         VARXOR(R4,-1,UI8,0,I4,-1);
3915         VARXOR(R4,0,UI8,0,I4,0);
3916     }
3917     VARXOR(R4,-1,INT,-1,I4,0);
3918     VARXOR(R4,-1,INT,0,I4,-1);
3919     VARXOR(R4,0,INT,0,I4,0);
3920     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3921     VARXOR(R4,-1,UINT,0,I4,-1);
3922     VARXOR(R4,0,UINT,0,I4,0);
3923     rbstr = SysAllocString(szFalse);
3924     VARXOR(R4,0,BSTR,rbstr,I4,0);
3925     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3926     SysFreeString(rbstr);
3927     rbstr = SysAllocString(szTrue);
3928     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3929     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3930     SysFreeString(rbstr);
3931     VARXORCY(R4,-1,10000,I4,-2);
3932     VARXORCY(R4,-1,0,I4,-1);
3933     VARXORCY(R4,0,0,I4,0);
3934
3935     VARXOR(R8,-1,R8,-1,I4,0);
3936     VARXOR(R8,-1,R8,0,I4,-1);
3937     VARXOR(R8,0,R8,0,I4,0);
3938     VARXOR(R8,-1,DATE,-1,I4,0);
3939     VARXOR(R8,-1,DATE,0,I4,-1);
3940     VARXOR(R8,0,DATE,0,I4,0);
3941     if (HAVE_OLEAUT32_I8)
3942     {
3943         VARXOR(R8,-1,I8,-1,I8,0);
3944         VARXOR(R8,-1,I8,0,I8,-1);
3945         VARXOR(R8,0,I8,0,I8,0);
3946         VARXOR(R8,-1,UI8,0,I4,-1);
3947         VARXOR(R8,0,UI8,0,I4,0);
3948     }
3949     VARXOR(R8,-1,INT,-1,I4,0);
3950     VARXOR(R8,-1,INT,0,I4,-1);
3951     VARXOR(R8,0,INT,0,I4,0);
3952     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3953     VARXOR(R8,-1,UINT,0,I4,-1);
3954     VARXOR(R8,0,UINT,0,I4,0);
3955     rbstr = SysAllocString(szFalse);
3956     VARXOR(R8,0,BSTR,rbstr,I4,0);
3957     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3958     SysFreeString(rbstr);
3959     rbstr = SysAllocString(szTrue);
3960     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3961     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3962     SysFreeString(rbstr);
3963     VARXORCY(R8,-1,10000,I4,-2);
3964     VARXORCY(R8,-1,0,I4,-1);
3965     VARXORCY(R8,0,0,I4,0);
3966
3967     VARXOR(DATE,-1,DATE,-1,I4,0);
3968     VARXOR(DATE,-1,DATE,0,I4,-1);
3969     VARXOR(DATE,0,DATE,0,I4,0);
3970     if (HAVE_OLEAUT32_I8)
3971     {
3972         VARXOR(DATE,-1,I8,-1,I8,0);
3973         VARXOR(DATE,-1,I8,0,I8,-1);
3974         VARXOR(DATE,0,I8,0,I8,0);
3975         VARXOR(DATE,-1,UI8,0,I4,-1);
3976         VARXOR(DATE,0,UI8,0,I4,0);
3977     }
3978     VARXOR(DATE,-1,INT,-1,I4,0);
3979     VARXOR(DATE,-1,INT,0,I4,-1);
3980     VARXOR(DATE,0,INT,0,I4,0);
3981     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3982     VARXOR(DATE,-1,UINT,0,I4,-1);
3983     VARXOR(DATE,0,UINT,0,I4,0);
3984     rbstr = SysAllocString(szFalse);
3985     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3986     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3987     SysFreeString(rbstr);
3988     rbstr = SysAllocString(szTrue);
3989     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3990     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3991     SysFreeString(rbstr);
3992     VARXORCY(DATE,-1,10000,I4,-2);
3993     VARXORCY(DATE,-1,0,I4,-1);
3994     VARXORCY(DATE,0,0,I4,0);
3995
3996     if (HAVE_OLEAUT32_I8)
3997     {
3998         VARXOR(I8,-1,I8,-1,I8,0);
3999         VARXOR(I8,-1,I8,0,I8,-1);
4000         VARXOR(I8,0,I8,0,I8,0);
4001         VARXOR(I8,-1,UI8,0,I8,-1);
4002         VARXOR(I8,0,UI8,0,I8,0);
4003         VARXOR(I8,-1,UINT,0,I8,-1);
4004         VARXOR(I8,0,UINT,0,I8,0);
4005         rbstr = SysAllocString(szFalse);
4006         VARXOR(I8,0,BSTR,rbstr,I8,0);
4007         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
4008         SysFreeString(rbstr);
4009         rbstr = SysAllocString(szTrue);
4010         VARXOR(I8,0,BSTR,rbstr,I8,-1);
4011         VARXOR(I8,-1,BSTR,rbstr,I8,0);
4012         SysFreeString(rbstr);
4013         VARXORCY(I8,-1,10000,I8,-2);
4014         VARXORCY(I8,-1,0,I8,-1);
4015         VARXORCY(I8,0,0,I8,0);
4016
4017         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
4018         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
4019         VARXOR(UI8,0,UI8,0,I4,0);
4020         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
4021         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
4022         VARXOR(UI8,0,INT,0,I4,0);
4023         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
4024         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
4025         VARXOR(UI8,0,UINT,0,I4,0);
4026         rbstr = SysAllocString(szFalse);
4027         VARXOR(UI8,0,BSTR,rbstr,I4,0);
4028         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4029         SysFreeString(rbstr);
4030         rbstr = SysAllocString(szTrue);
4031         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
4032         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
4033         SysFreeString(rbstr);
4034         VARXORCY(UI8,0xffff,10000,I4,65534);
4035         VARXORCY(UI8,0xffff,0,I4,0xffff);
4036         VARXORCY(UI8,0,0,I4,0);
4037     }
4038
4039     VARXOR(INT,-1,INT,-1,I4,0);
4040     VARXOR(INT,-1,INT,0,I4,-1);
4041     VARXOR(INT,0,INT,0,I4,0);
4042     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
4043     VARXOR(INT,-1,UINT,0,I4,-1);
4044     VARXOR(INT,0,UINT,0,I4,0);
4045     rbstr = SysAllocString(szFalse);
4046     VARXOR(INT,0,BSTR,rbstr,I4,0);
4047     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
4048     SysFreeString(rbstr);
4049     rbstr = SysAllocString(szTrue);
4050     VARXOR(INT,0,BSTR,rbstr,I4,-1);
4051     VARXOR(INT,-1,BSTR,rbstr,I4,0);
4052     SysFreeString(rbstr);
4053     VARXORCY(INT,-1,10000,I4,-2);
4054     VARXORCY(INT,-1,0,I4,-1);
4055     VARXORCY(INT,0,0,I4,0);
4056
4057     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
4058     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
4059     VARXOR(UINT,0,UINT,0,I4,0);
4060     rbstr = SysAllocString(szFalse);
4061     VARXOR(UINT,0,BSTR,rbstr,I4,0);
4062     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4063     SysFreeString(rbstr);
4064     rbstr = SysAllocString(szTrue);
4065     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
4066     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
4067     SysFreeString(rbstr);
4068     VARXORCY(UINT,0xffff,10000,I4,65534);
4069     VARXORCY(UINT,0xffff,0,I4,0xffff);
4070     VARXORCY(UINT,0,0,I4,0);
4071
4072     lbstr = SysAllocString(szFalse);
4073     rbstr = SysAllocString(szFalse);
4074     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4075     SysFreeString(rbstr);
4076     rbstr = SysAllocString(szTrue);
4077     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4078     SysFreeString(lbstr);
4079     lbstr = SysAllocString(szTrue);
4080     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
4081     VARXORCY(BSTR,lbstr,10000,I4,-2);
4082     SysFreeString(lbstr);
4083     lbstr = SysAllocString(szFalse);
4084     VARXORCY(BSTR,lbstr,10000,I4,1);
4085     SysFreeString(lbstr);
4086     SysFreeString(rbstr);
4087 }
4088
4089 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
4090
4091 #define VAROR(vt1,val1,vt2,val2,rvt,rval)                \
4092         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4093         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4094         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4095         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4096
4097 #define VARORCY(vt1,val1,val2,rvt,rval)                  \
4098         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4099         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
4100         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4101         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4102
4103 static void test_VarOr(void)
4104 {
4105     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
4106     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
4107     VARIANT left, right, exp, result;
4108     BSTR lbstr, rbstr;
4109     VARTYPE i;
4110     HRESULT hres;
4111
4112     CHECKPTR(VarOr);
4113
4114     /* Test all possible flag/vt combinations & the resulting vt type */
4115     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4116     {
4117         VARTYPE leftvt, rightvt, resvt;
4118
4119         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4120         {
4121
4122             SKIPTESTS(leftvt);
4123
4124             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4125             {
4126                 BOOL bFail = FALSE;
4127
4128                 SKIPTESTS(rightvt);
4129
4130                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4131                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4132                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4133                     continue;
4134
4135                 memset(&left, 0, sizeof(left));
4136                 memset(&right, 0, sizeof(right));
4137                 V_VT(&left) = leftvt | ExtraFlags[i];
4138                 V_VT(&right) = rightvt | ExtraFlags[i];
4139                 V_VT(&result) = VT_EMPTY;
4140                 resvt = VT_I4;
4141
4142                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4143                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4144                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4145                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4146                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4147                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4148                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4149                 {
4150                     bFail = TRUE;
4151                 }
4152                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4153                 {
4154                     if (leftvt == rightvt ||
4155                         leftvt == VT_I2 || rightvt == VT_I2 ||
4156                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4157                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4158                         resvt = VT_I2;
4159                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4160                         resvt = VT_NULL;
4161                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4162                         resvt = VT_I8;
4163                 }
4164                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4165                 {
4166                     resvt = VT_NULL;
4167                 }
4168                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4169                 {
4170                     if (leftvt == rightvt)
4171                         resvt = VT_UI1;
4172                     else if (leftvt == rightvt ||
4173                         leftvt == VT_I2 || rightvt == VT_I2 ||
4174                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4175                     {
4176                         resvt = VT_I2;
4177                     }
4178                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4179                         resvt = VT_I8;
4180                 }
4181                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4182                 {
4183                     if (leftvt == rightvt ||
4184                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4185                         resvt = VT_I2;
4186                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4187                         resvt = VT_I8;
4188                 }
4189                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4190                 {
4191                     resvt = VT_BOOL;
4192                 }
4193                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4194                 {
4195                     if (leftvt == VT_INT || rightvt == VT_INT)
4196                         bFail = TRUE;
4197                     else
4198                         resvt = VT_I8;
4199                 }
4200                 hres = pVarOr(&left, &right, &result);
4201                 if (bFail)
4202                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4203                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4204                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4205                        V_VT(&result));
4206                 else
4207                     ok(hres == S_OK && V_VT(&result) == resvt,
4208                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4209                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4210                        V_VT(&result));
4211             }
4212         }
4213     }
4214
4215     /* Test returned values. Since we know the returned type is correct
4216      * and that we handle all combinations of invalid types, just check
4217      * that good type combinations produce the desired value.
4218      * FIXME: Test VT_DECIMAL/VT_DISPATCH
4219      */
4220     VAROR(EMPTY,0,EMPTY,0,I2,0);
4221     VAROR(EMPTY,1,EMPTY,0,I2,0);
4222     VAROR(EMPTY,0,NULL,0,NULL,0);
4223     VAROR(EMPTY,0,I1,0,I4,0);
4224     VAROR(EMPTY,0,I1,1,I4,1);
4225     VAROR(EMPTY,0,UI1,0,I2,0);
4226     VAROR(EMPTY,0,UI1,1,I2,1);
4227     VAROR(EMPTY,0,I2,0,I2,0);
4228     VAROR(EMPTY,0,I2,1,I2,1);
4229     VAROR(EMPTY,0,UI2,0,I4,0);
4230     VAROR(EMPTY,0,UI2,1,I4,1);
4231     VAROR(EMPTY,0,I4,0,I4,0);
4232     VAROR(EMPTY,0,I4,1,I4,1);
4233     VAROR(EMPTY,0,UI4,0,I4,0);
4234     VAROR(EMPTY,0,UI4,1,I4,1);
4235     if (HAVE_OLEAUT32_I8)
4236     {
4237         VAROR(EMPTY,0,I8,0,I8,0);
4238         VAROR(EMPTY,0,I8,1,I8,1);
4239         VAROR(EMPTY,0,UI8,0,I4,0);
4240         VAROR(EMPTY,0,UI8,1,I4,1);
4241     }
4242     VAROR(EMPTY,0,INT,0,I4,0);
4243     VAROR(EMPTY,0,INT,1,I4,1);
4244     VAROR(EMPTY,0,UINT,0,I4,0);
4245     VAROR(EMPTY,0,UINT,1,I4,1);
4246     VAROR(EMPTY,0,BOOL,0,I2,0);
4247     VAROR(EMPTY,0,BOOL,1,I2,1);
4248     VAROR(EMPTY,0,R4,0,I4,0);
4249     VAROR(EMPTY,0,R4,1,I4,1);
4250     VAROR(EMPTY,0,R8,0,I4,0);
4251     VAROR(EMPTY,0,R8,1,I4,1);
4252     rbstr = SysAllocString(szFalse);
4253     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
4254     SysFreeString(rbstr);
4255     rbstr = SysAllocString(szTrue);
4256     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
4257     SysFreeString(rbstr);
4258     VARORCY(EMPTY,0,10000,I4,1);
4259
4260     /* NULL OR 0 = NULL. NULL OR n = n */
4261     VAROR(NULL,0,NULL,0,NULL,0);
4262     VAROR(NULL,1,NULL,0,NULL,0);
4263     VAROR(NULL,0,I1,0,NULL,0);
4264     VAROR(NULL,0,I1,1,I4,1);
4265     VAROR(NULL,0,UI1,0,NULL,0);
4266     VAROR(NULL,0,UI1,1,UI1,1);
4267     VAROR(NULL,0,I2,0,NULL,0);
4268     VAROR(NULL,0,I2,1,I2,1);
4269     VAROR(NULL,0,UI2,0,NULL,0);
4270     VAROR(NULL,0,UI2,1,I4,1);
4271     VAROR(NULL,0,I4,0,NULL,0);
4272     VAROR(NULL,0,I4,1,I4,1);
4273     VAROR(NULL,0,UI4,0,NULL,0);
4274     VAROR(NULL,0,UI4,1,I4,1);
4275     if (HAVE_OLEAUT32_I8)
4276     {
4277         VAROR(NULL,0,I8,0,NULL,0);
4278         VAROR(NULL,0,I8,1,I8,1);
4279         VAROR(NULL,0,UI8,0,NULL,0);
4280         VAROR(NULL,0,UI8,1,I4,1);
4281     }
4282     VAROR(NULL,0,INT,0,NULL,0);
4283     VAROR(NULL,0,INT,1,I4,1);
4284     VAROR(NULL,0,UINT,0,NULL,0);
4285     VAROR(NULL,0,UINT,1,I4,1);
4286     VAROR(NULL,0,BOOL,0,NULL,0);
4287     VAROR(NULL,0,BOOL,1,BOOL,1);
4288     VAROR(NULL,0,R4,0,NULL,0);
4289     VAROR(NULL,0,R4,1,I4,1);
4290     VAROR(NULL,0,R8,0,NULL,0);
4291     VAROR(NULL,0,R8,1,I4,1);
4292     rbstr = SysAllocString(szFalse);
4293     VAROR(NULL,0,BSTR,rbstr,NULL,0);
4294     SysFreeString(rbstr);
4295     rbstr = SysAllocString(szTrue);
4296     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
4297     SysFreeString(rbstr);
4298     VARORCY(NULL,0,10000,I4,1);
4299     VARORCY(NULL,0,0,NULL,0);
4300
4301     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4302     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4303     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4304     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4305     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4306     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
4307     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4308     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4309     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
4310     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4311     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4312     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
4313     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4314     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4315     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
4316     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4317     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4318     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
4319     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4320     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4321     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
4322     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4323     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4324     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
4325     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4326     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4327     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
4328     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4329     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4330     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
4331     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4332     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4333     if (HAVE_OLEAUT32_I8)
4334     {
4335         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
4336         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4337         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4338         /* This returns DISP_E_OVERFLOW which indicates that a conversion
4339          * to I4 is performed.
4340          */
4341         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4342         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4343         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4344     }
4345     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
4346     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4347     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4348     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
4349     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4350     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4351     rbstr = SysAllocString(szFalse);
4352     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4353     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4354     SysFreeString(rbstr);
4355     rbstr = SysAllocString(szTrue);
4356     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4357     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4358     SysFreeString(rbstr);
4359     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
4360     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4361     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
4362
4363     VAROR(I1,-1,I1,-1,I4,-1);
4364     VAROR(I1,-1,I1,0,I4,-1);
4365     VAROR(I1,0,I1,0,I4,0);
4366     VAROR(I1,-1,UI1,255,I4,-1);
4367     VAROR(I1,-1,UI1,0,I4,-1);
4368     VAROR(I1,0,UI1,0,I4,0);
4369     VAROR(I1,-1,I2,-1,I4,-1);
4370     VAROR(I1,-1,I2,0,I4,-1);
4371     VAROR(I1,0,I2,0,I4,0);
4372     VAROR(I1,-1,UI2,65535,I4,-1);
4373     VAROR(I1,-1,UI2,0,I4,-1);
4374     VAROR(I1,0,UI2,0,I4,0);
4375     VAROR(I1,-1,I4,-1,I4,-1);
4376     VAROR(I1,-1,I4,0,I4,-1);
4377     VAROR(I1,0,I4,0,I4,0);
4378     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
4379     VAROR(I1,-1,UI4,0,I4,-1);
4380     VAROR(I1,0,UI4,0,I4,0);
4381     VAROR(I1,-1,R4,-1,I4,-1);
4382     VAROR(I1,-1,R4,0,I4,-1);
4383     VAROR(I1,0,R4,0,I4,0);
4384     VAROR(I1,-1,R8,-1,I4,-1);
4385     VAROR(I1,-1,R8,0,I4,-1);
4386     VAROR(I1,0,R8,0,I4,0);
4387     VAROR(I1,-1,DATE,-1,I4,-1);
4388     VAROR(I1,-1,DATE,0,I4,-1);
4389     VAROR(I1,0,DATE,0,I4,0);
4390     if (HAVE_OLEAUT32_I8)
4391     {
4392         VAROR(I1,-1,I8,-1,I8,-1);
4393         VAROR(I1,-1,I8,0,I8,-1);
4394         VAROR(I1,0,I8,0,I8,0);
4395         VAROR(I1,-1,UI8,0,I4,-1);
4396         VAROR(I1,0,UI8,0,I4,0);
4397     }
4398     VAROR(I1,-1,INT,-1,I4,-1);
4399     VAROR(I1,-1,INT,0,I4,-1);
4400     VAROR(I1,0,INT,0,I4,0);
4401     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
4402     VAROR(I1,-1,UINT,0,I4,-1);
4403     VAROR(I1,0,UINT,0,I4,0);
4404     rbstr = SysAllocString(szFalse);
4405     VAROR(I1,0,BSTR,rbstr,I4,0);
4406     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4407     SysFreeString(rbstr);
4408     rbstr = SysAllocString(szTrue);
4409     VAROR(I1,0,BSTR,rbstr,I4,-1);
4410     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4411     SysFreeString(rbstr);
4412     VARORCY(I1,-1,10000,I4,-1);
4413     VARORCY(I1,-1,0,I4,-1);
4414     VARORCY(I1,0,0,I4,0);
4415
4416     VAROR(UI1,255,UI1,255,UI1,255);
4417     VAROR(UI1,255,UI1,0,UI1,255);
4418     VAROR(UI1,0,UI1,0,UI1,0);
4419     VAROR(UI1,255,I2,-1,I2,-1);
4420     VAROR(UI1,255,I2,0,I2,255);
4421     VAROR(UI1,0,I2,0,I2,0);
4422     VAROR(UI1,255,UI2,65535,I4,65535);
4423     VAROR(UI1,255,UI2,0,I4,255);
4424     VAROR(UI1,0,UI2,0,I4,0);
4425     VAROR(UI1,255,I4,-1,I4,-1);
4426     VAROR(UI1,255,I4,0,I4,255);
4427     VAROR(UI1,0,I4,0,I4,0);
4428     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4429     VAROR(UI1,255,UI4,0,I4,255);
4430     VAROR(UI1,0,UI4,0,I4,0);
4431     VAROR(UI1,255,R4,-1,I4,-1);
4432     VAROR(UI1,255,R4,0,I4,255);
4433     VAROR(UI1,0,R4,0,I4,0);
4434     VAROR(UI1,255,R8,-1,I4,-1);
4435     VAROR(UI1,255,R8,0,I4,255);
4436     VAROR(UI1,0,R8,0,I4,0);
4437     VAROR(UI1,255,DATE,-1,I4,-1);
4438     VAROR(UI1,255,DATE,0,I4,255);
4439     VAROR(UI1,0,DATE,0,I4,0);
4440     if (HAVE_OLEAUT32_I8)
4441     {
4442         VAROR(UI1,255,I8,-1,I8,-1);
4443         VAROR(UI1,255,I8,0,I8,255);
4444         VAROR(UI1,0,I8,0,I8,0);
4445         VAROR(UI1,255,UI8,0,I4,255);
4446         VAROR(UI1,0,UI8,0,I4,0);
4447     }
4448     VAROR(UI1,255,INT,-1,I4,-1);
4449     VAROR(UI1,255,INT,0,I4,255);
4450     VAROR(UI1,0,INT,0,I4,0);
4451     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4452     VAROR(UI1,255,UINT,0,I4,255);
4453     VAROR(UI1,0,UINT,0,I4,0);
4454     rbstr = SysAllocString(szFalse);
4455     VAROR(UI1,0,BSTR,rbstr,I2,0);
4456     VAROR(UI1,255,BSTR,rbstr,I2,255);
4457     SysFreeString(rbstr);
4458     rbstr = SysAllocString(szTrue);
4459     VAROR(UI1,0,BSTR,rbstr,I2,-1);
4460     VAROR(UI1,255,BSTR,rbstr,I2,-1);
4461     SysFreeString(rbstr);
4462     VARORCY(UI1,255,10000,I4,255);
4463     VARORCY(UI1,255,0,I4,255);
4464     VARORCY(UI1,0,0,I4,0);
4465
4466     VAROR(I2,-1,I2,-1,I2,-1);
4467     VAROR(I2,-1,I2,0,I2,-1);
4468     VAROR(I2,0,I2,0,I2,0);
4469     VAROR(I2,-1,UI2,65535,I4,-1);
4470     VAROR(I2,-1,UI2,0,I4,-1);
4471     VAROR(I2,0,UI2,0,I4,0);
4472     VAROR(I2,-1,I4,-1,I4,-1);
4473     VAROR(I2,-1,I4,0,I4,-1);
4474     VAROR(I2,0,I4,0,I4,0);
4475     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4476     VAROR(I2,-1,UI4,0,I4,-1);
4477     VAROR(I2,0,UI4,0,I4,0);
4478     VAROR(I2,-1,R4,-1,I4,-1);
4479     VAROR(I2,-1,R4,0,I4,-1);
4480     VAROR(I2,0,R4,0,I4,0);
4481     VAROR(I2,-1,R8,-1,I4,-1);
4482     VAROR(I2,-1,R8,0,I4,-1);
4483     VAROR(I2,0,R8,0,I4,0);
4484     VAROR(I2,-1,DATE,-1,I4,-1);
4485     VAROR(I2,-1,DATE,0,I4,-1);
4486     VAROR(I2,0,DATE,0,I4,0);
4487     if (HAVE_OLEAUT32_I8)
4488     {
4489         VAROR(I2,-1,I8,-1,I8,-1);
4490         VAROR(I2,-1,I8,0,I8,-1);
4491         VAROR(I2,0,I8,0,I8,0);
4492         VAROR(I2,-1,UI8,0,I4,-1);
4493         VAROR(I2,0,UI8,0,I4,0);
4494     }
4495     VAROR(I2,-1,INT,-1,I4,-1);
4496     VAROR(I2,-1,INT,0,I4,-1);
4497     VAROR(I2,0,INT,0,I4,0);
4498     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4499     VAROR(I2,-1,UINT,0,I4,-1);
4500     VAROR(I2,0,UINT,0,I4,0);
4501     rbstr = SysAllocString(szFalse);
4502     VAROR(I2,0,BSTR,rbstr,I2,0);
4503     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4504     SysFreeString(rbstr);
4505     rbstr = SysAllocString(szTrue);
4506     VAROR(I2,0,BSTR,rbstr,I2,-1);
4507     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4508     SysFreeString(rbstr);
4509     VARORCY(I2,-1,10000,I4,-1);
4510     VARORCY(I2,-1,0,I4,-1);
4511     VARORCY(I2,0,0,I4,0);
4512
4513     VAROR(UI2,65535,UI2,65535,I4,65535);
4514     VAROR(UI2,65535,UI2,0,I4,65535);
4515     VAROR(UI2,0,UI2,0,I4,0);
4516     VAROR(UI2,65535,I4,-1,I4,-1);
4517     VAROR(UI2,65535,I4,0,I4,65535);
4518     VAROR(UI2,0,I4,0,I4,0);
4519     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4520     VAROR(UI2,65535,UI4,0,I4,65535);
4521     VAROR(UI2,0,UI4,0,I4,0);
4522     VAROR(UI2,65535,R4,-1,I4,-1);
4523     VAROR(UI2,65535,R4,0,I4,65535);
4524     VAROR(UI2,0,R4,0,I4,0);
4525     VAROR(UI2,65535,R8,-1,I4,-1);
4526     VAROR(UI2,65535,R8,0,I4,65535);
4527     VAROR(UI2,0,R8,0,I4,0);
4528     VAROR(UI2,65535,DATE,-1,I4,-1);
4529     VAROR(UI2,65535,DATE,0,I4,65535);
4530     VAROR(UI2,0,DATE,0,I4,0);
4531     if (HAVE_OLEAUT32_I8)
4532     {
4533         VAROR(UI2,65535,I8,-1,I8,-1);
4534         VAROR(UI2,65535,I8,0,I8,65535);
4535         VAROR(UI2,0,I8,0,I8,0);
4536         VAROR(UI2,65535,UI8,0,I4,65535);
4537         VAROR(UI2,0,UI8,0,I4,0);
4538     }
4539     VAROR(UI2,65535,INT,-1,I4,-1);
4540     VAROR(UI2,65535,INT,0,I4,65535);
4541     VAROR(UI2,0,INT,0,I4,0);
4542     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4543     VAROR(UI2,65535,UINT,0,I4,65535);
4544     VAROR(UI2,0,UINT,0,I4,0);
4545     rbstr = SysAllocString(szFalse);
4546     VAROR(UI2,0,BSTR,rbstr,I4,0);
4547     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4548     SysFreeString(rbstr);
4549     rbstr = SysAllocString(szTrue);
4550     VAROR(UI2,0,BSTR,rbstr,I4,-1);
4551     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4552     SysFreeString(rbstr);
4553     VARORCY(UI2,65535,10000,I4,65535);
4554     VARORCY(UI2,65535,0,I4,65535);
4555     VARORCY(UI2,0,0,I4,0);
4556
4557     VAROR(I4,-1,I4,-1,I4,-1);
4558     VAROR(I4,-1,I4,0,I4,-1);
4559     VAROR(I4,0,I4,0,I4,0);
4560     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4561     VAROR(I4,-1,UI4,0,I4,-1);
4562     VAROR(I4,0,UI4,0,I4,0);
4563     VAROR(I4,-1,R4,-1,I4,-1);
4564     VAROR(I4,-1,R4,0,I4,-1);
4565     VAROR(I4,0,R4,0,I4,0);
4566     VAROR(I4,-1,R8,-1,I4,-1);
4567     VAROR(I4,-1,R8,0,I4,-1);
4568     VAROR(I4,0,R8,0,I4,0);
4569     VAROR(I4,-1,DATE,-1,I4,-1);
4570     VAROR(I4,-1,DATE,0,I4,-1);
4571     VAROR(I4,0,DATE,0,I4,0);
4572     if (HAVE_OLEAUT32_I8)
4573     {
4574         VAROR(I4,-1,I8,-1,I8,-1);
4575         VAROR(I4,-1,I8,0,I8,-1);
4576         VAROR(I4,0,I8,0,I8,0);
4577         VAROR(I4,-1,UI8,0,I4,-1);
4578         VAROR(I4,0,UI8,0,I4,0);
4579     }
4580     VAROR(I4,-1,INT,-1,I4,-1);
4581     VAROR(I4,-1,INT,0,I4,-1);
4582     VAROR(I4,0,INT,0,I4,0);
4583     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4584     VAROR(I4,-1,UINT,0,I4,-1);
4585     VAROR(I4,0,UINT,0,I4,0);
4586     rbstr = SysAllocString(szFalse);
4587     VAROR(I4,0,BSTR,rbstr,I4,0);
4588     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4589     SysFreeString(rbstr);
4590     rbstr = SysAllocString(szTrue);
4591     VAROR(I4,0,BSTR,rbstr,I4,-1);
4592     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4593     SysFreeString(rbstr);
4594     VARORCY(I4,-1,10000,I4,-1);
4595     VARORCY(I4,-1,0,I4,-1);
4596     VARORCY(I4,0,0,I4,0);
4597
4598     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4599     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4600     VAROR(UI4,0,UI4,0,I4,0);
4601     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4602     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4603     VAROR(UI4,0,R4,0,I4,0);
4604     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4605     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4606     VAROR(UI4,0,R8,0,I4,0);
4607     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4608     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4609     VAROR(UI4,0,DATE,0,I4,0);
4610     if (HAVE_OLEAUT32_I8)
4611     {
4612         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4613         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4614         VAROR(UI4,0,I8,0,I8,0);
4615         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4616         VAROR(UI4,0,UI8,0,I4,0);
4617     }
4618     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4619     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4620     VAROR(UI4,0,INT,0,I4,0);
4621     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4622     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4623     VAROR(UI4,0,UINT,0,I4,0);
4624     rbstr = SysAllocString(szFalse);
4625     VAROR(UI4,0,BSTR,rbstr,I4,0);
4626     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4627     SysFreeString(rbstr);
4628     rbstr = SysAllocString(szTrue);
4629     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4630     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4631     SysFreeString(rbstr);
4632     VARORCY(UI4,0xffffffff,10000,I4,-1);
4633     VARORCY(UI4,0xffffffff,0,I4,-1);
4634     VARORCY(UI4,0,0,I4,0);
4635
4636     VAROR(R4,-1,R4,-1,I4,-1);
4637     VAROR(R4,-1,R4,0,I4,-1);
4638     VAROR(R4,0,R4,0,I4,0);
4639     VAROR(R4,-1,R8,-1,I4,-1);
4640     VAROR(R4,-1,R8,0,I4,-1);
4641     VAROR(R4,0,R8,0,I4,0);
4642     VAROR(R4,-1,DATE,-1,I4,-1);
4643     VAROR(R4,-1,DATE,0,I4,-1);
4644     VAROR(R4,0,DATE,0,I4,0);
4645     if (HAVE_OLEAUT32_I8)
4646     {
4647         VAROR(R4,-1,I8,-1,I8,-1);
4648         VAROR(R4,-1,I8,0,I8,-1);
4649         VAROR(R4,0,I8,0,I8,0);
4650         VAROR(R4,-1,UI8,0,I4,-1);
4651         VAROR(R4,0,UI8,0,I4,0);
4652     }
4653     VAROR(R4,-1,INT,-1,I4,-1);
4654     VAROR(R4,-1,INT,0,I4,-1);
4655     VAROR(R4,0,INT,0,I4,0);
4656     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4657     VAROR(R4,-1,UINT,0,I4,-1);
4658     VAROR(R4,0,UINT,0,I4,0);
4659     rbstr = SysAllocString(szFalse);
4660     VAROR(R4,0,BSTR,rbstr,I4,0);
4661     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4662     SysFreeString(rbstr);
4663     rbstr = SysAllocString(szTrue);
4664     VAROR(R4,0,BSTR,rbstr,I4,-1);
4665     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4666     SysFreeString(rbstr);
4667     VARORCY(R4,-1,10000,I4,-1);
4668     VARORCY(R4,-1,0,I4,-1);
4669     VARORCY(R4,0,0,I4,0);
4670
4671     VAROR(R8,-1,R8,-1,I4,-1);
4672     VAROR(R8,-1,R8,0,I4,-1);
4673     VAROR(R8,0,R8,0,I4,0);
4674     VAROR(R8,-1,DATE,-1,I4,-1);
4675     VAROR(R8,-1,DATE,0,I4,-1);
4676     VAROR(R8,0,DATE,0,I4,0);
4677     if (HAVE_OLEAUT32_I8)
4678     {
4679         VAROR(R8,-1,I8,-1,I8,-1);
4680         VAROR(R8,-1,I8,0,I8,-1);
4681         VAROR(R8,0,I8,0,I8,0);
4682         VAROR(R8,-1,UI8,0,I4,-1);
4683         VAROR(R8,0,UI8,0,I4,0);
4684     }
4685     VAROR(R8,-1,INT,-1,I4,-1);
4686     VAROR(R8,-1,INT,0,I4,-1);
4687     VAROR(R8,0,INT,0,I4,0);
4688     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4689     VAROR(R8,-1,UINT,0,I4,-1);
4690     VAROR(R8,0,UINT,0,I4,0);
4691     rbstr = SysAllocString(szFalse);
4692     VAROR(R8,0,BSTR,rbstr,I4,0);
4693     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4694     SysFreeString(rbstr);
4695     rbstr = SysAllocString(szTrue);
4696     VAROR(R8,0,BSTR,rbstr,I4,-1);
4697     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4698     SysFreeString(rbstr);
4699     VARORCY(R8,-1,10000,I4,-1);
4700     VARORCY(R8,-1,0,I4,-1);
4701     VARORCY(R8,0,0,I4,0);
4702
4703     VAROR(DATE,-1,DATE,-1,I4,-1);
4704     VAROR(DATE,-1,DATE,0,I4,-1);
4705     VAROR(DATE,0,DATE,0,I4,0);
4706     if (HAVE_OLEAUT32_I8)
4707     {
4708         VAROR(DATE,-1,I8,-1,I8,-1);
4709         VAROR(DATE,-1,I8,0,I8,-1);
4710         VAROR(DATE,0,I8,0,I8,0);
4711         VAROR(DATE,-1,UI8,0,I4,-1);
4712         VAROR(DATE,0,UI8,0,I4,0);
4713     }
4714     VAROR(DATE,-1,INT,-1,I4,-1);
4715     VAROR(DATE,-1,INT,0,I4,-1);
4716     VAROR(DATE,0,INT,0,I4,0);
4717     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4718     VAROR(DATE,-1,UINT,0,I4,-1);
4719     VAROR(DATE,0,UINT,0,I4,0);
4720     rbstr = SysAllocString(szFalse);
4721     VAROR(DATE,0,BSTR,rbstr,I4,0);
4722     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4723     SysFreeString(rbstr);
4724     rbstr = SysAllocString(szTrue);
4725     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4726     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4727     SysFreeString(rbstr);
4728     VARORCY(DATE,-1,10000,I4,-1);
4729     VARORCY(DATE,-1,0,I4,-1);
4730     VARORCY(DATE,0,0,I4,0);
4731
4732     if (HAVE_OLEAUT32_I8)
4733     {
4734         VAROR(I8,-1,I8,-1,I8,-1);
4735         VAROR(I8,-1,I8,0,I8,-1);
4736         VAROR(I8,0,I8,0,I8,0);
4737         VAROR(I8,-1,UI8,0,I8,-1);
4738         VAROR(I8,0,UI8,0,I8,0);
4739         /* These overflow under native and Wine
4740         VAROR(I8,-1,INT,-1,I4,-1);
4741         VAROR(I8,-1,INT,0,I4,-1);
4742         VAROR(I8,0,INT,0,I4,0); */
4743         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4744         VAROR(I8,-1,UINT,0,I8,-1);
4745         VAROR(I8,0,UINT,0,I8,0);
4746         rbstr = SysAllocString(szFalse);
4747         VAROR(I8,0,BSTR,rbstr,I8,0);
4748         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4749         SysFreeString(rbstr);
4750         rbstr = SysAllocString(szTrue);
4751         VAROR(I8,0,BSTR,rbstr,I8,-1);
4752         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4753         SysFreeString(rbstr);
4754         VARORCY(I8,-1,10000,I8,-1);
4755         VARORCY(I8,-1,0,I8,-1);
4756         VARORCY(I8,0,0,I8,0);
4757
4758         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4759         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4760         VAROR(UI8,0,UI8,0,I4,0);
4761         VAROR(UI8,0xffff,INT,-1,I4,-1);
4762         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4763         VAROR(UI8,0,INT,0,I4,0);
4764         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4765         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4766         VAROR(UI8,0,UINT,0,I4,0);
4767         rbstr = SysAllocString(szFalse);
4768         VAROR(UI8,0,BSTR,rbstr,I4,0);
4769         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4770         SysFreeString(rbstr);
4771         rbstr = SysAllocString(szTrue);
4772         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4773         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4774         SysFreeString(rbstr);
4775         VARORCY(UI8,0xffff,10000,I4,0xffff);
4776         VARORCY(UI8,0xffff,0,I4,0xffff);
4777         VARORCY(UI8,0,0,I4,0);
4778     }
4779
4780     VAROR(INT,-1,INT,-1,I4,-1);
4781     VAROR(INT,-1,INT,0,I4,-1);
4782     VAROR(INT,0,INT,0,I4,0);
4783     VAROR(INT,-1,UINT,0xffff,I4,-1);
4784     VAROR(INT,-1,UINT,0,I4,-1);
4785     VAROR(INT,0,UINT,0,I4,0);
4786     rbstr = SysAllocString(szFalse);
4787     VAROR(INT,0,BSTR,rbstr,I4,0);
4788     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4789     SysFreeString(rbstr);
4790     rbstr = SysAllocString(szTrue);
4791     VAROR(INT,0,BSTR,rbstr,I4,-1);
4792     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4793     SysFreeString(rbstr);
4794     VARORCY(INT,-1,10000,I4,-1);
4795     VARORCY(INT,-1,0,I4,-1);
4796     VARORCY(INT,0,0,I4,0);
4797
4798     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4799     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4800     VAROR(UINT,0,UINT,0,I4,0);
4801     rbstr = SysAllocString(szFalse);
4802     VAROR(UINT,0,BSTR,rbstr,I4,0);
4803     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4804     SysFreeString(rbstr);
4805     rbstr = SysAllocString(szTrue);
4806     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4807     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4808     SysFreeString(rbstr);
4809     VARORCY(UINT,0xffff,10000,I4,0xffff);
4810     VARORCY(UINT,0xffff,0,I4,0xffff);
4811     VARORCY(UINT,0,0,I4,0);
4812
4813     lbstr = SysAllocString(szFalse);
4814     rbstr = SysAllocString(szFalse);
4815     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4816     SysFreeString(rbstr);
4817     rbstr = SysAllocString(szTrue);
4818     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4819     SysFreeString(lbstr);
4820     lbstr = SysAllocString(szTrue);
4821     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4822     VARORCY(BSTR,lbstr,10000,I4,-1);
4823     SysFreeString(lbstr);
4824     lbstr = SysAllocString(szFalse);
4825     VARORCY(BSTR,lbstr,10000,I4,1);
4826     SysFreeString(lbstr);
4827     SysFreeString(rbstr);
4828 }
4829
4830 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4831
4832 #define VAREQV(vt1,val1,vt2,val2,rvt,rval)           \
4833     V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4834     V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4835     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4836     test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )
4837
4838 static void test_VarEqv(void)
4839 {
4840     VARIANT left, right, exp, result;
4841     VARTYPE i;
4842     HRESULT hres;
4843
4844     CHECKPTR(VarEqv);
4845
4846     /* Test all possible flag/vt combinations & the resulting vt type */
4847     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4848     {
4849         VARTYPE leftvt, rightvt, resvt;
4850
4851         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4852         {
4853             SKIPTESTS(leftvt);
4854
4855             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4856             {
4857                 BOOL bFail = FALSE;
4858
4859                 SKIPTESTS(rightvt);
4860
4861                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4862                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4863                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4864                     continue;
4865
4866                 memset(&left, 0, sizeof(left));
4867                 memset(&right, 0, sizeof(right));
4868                 V_VT(&left) = leftvt | ExtraFlags[i];
4869                 V_VT(&right) = rightvt | ExtraFlags[i];
4870                 V_VT(&result) = VT_EMPTY;
4871                 resvt = VT_I4;
4872
4873                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4874                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4875                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4876                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4877                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4878                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4879                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4880                 {
4881                     bFail = TRUE;
4882                 }
4883                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4884                 {
4885                     if (leftvt == rightvt ||
4886                         leftvt == VT_I2 || rightvt == VT_I2 ||
4887                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4888                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4889                         resvt = VT_I2;
4890                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4891                         resvt = VT_NULL;
4892                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4893                         resvt = VT_I8;
4894                 }
4895                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4896                 {
4897                     resvt = VT_NULL;
4898                 }
4899                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4900                 {
4901                     if (leftvt == rightvt)
4902                         resvt = VT_UI1;
4903                     else if (leftvt == rightvt ||
4904                         leftvt == VT_I2 || rightvt == VT_I2 ||
4905                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4906                     {
4907                         resvt = VT_I2;
4908                     }
4909                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4910                         resvt = VT_I8;
4911                 }
4912                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4913                 {
4914                     if (leftvt == rightvt ||
4915                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4916                         resvt = VT_I2;
4917                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4918                         resvt = VT_I8;
4919                 }
4920                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4921                 {
4922                     resvt = VT_BOOL;
4923                 }
4924                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4925                 {
4926                     if (leftvt == VT_INT || rightvt == VT_INT)
4927                         bFail = TRUE;
4928                     else
4929                         resvt = VT_I8;
4930                 }
4931                 hres = pVarEqv(&left, &right, &result);
4932                 if (bFail)
4933                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4934                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4935                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4936                        V_VT(&result));
4937                 else
4938                     ok(hres == S_OK && V_VT(&result) == resvt,
4939                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4940                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4941                        V_VT(&result));
4942             }
4943         }
4944     }
4945
4946     /* Test returned values */
4947     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4948     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4949     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4950     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4951     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4952     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4953     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4954     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4955     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4956     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4957     VAREQV(BOOL,6,I2,7,I2,-2);
4958     VAREQV(UI1,1,UI1,1,UI1,255);
4959     VAREQV(UI1,1,UI1,0,UI1,254);
4960     VAREQV(UI1,0,UI1,1,UI1,254);
4961     if (HAVE_OLEAUT32_I8)
4962     {
4963         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4964         VAREQV(UI4,5,I8,19,I8,-23);
4965         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4966     }
4967 }
4968
4969 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4970
4971 #define VARMUL(vt1,val1,vt2,val2,rvt,rval)               \
4972         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4973         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4974         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4975         test_var_call2( __LINE__, pVarMul, &left, &right, &exp )
4976
4977 static void test_VarMul(void)
4978 {
4979     VARIANT left, right, exp, result, cy, dec;
4980     VARTYPE i;
4981     BSTR lbstr, rbstr;
4982     HRESULT hres;
4983     double r;
4984
4985     CHECKPTR(VarMul);
4986
4987     lbstr = SysAllocString(sz12);
4988     rbstr = SysAllocString(sz12);
4989
4990     /* Test all possible flag/vt combinations & the resulting vt type */
4991     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4992     {
4993         VARTYPE leftvt, rightvt, resvt;
4994
4995         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4996         {
4997
4998             SKIPTESTS(leftvt);
4999
5000             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5001             {
5002                 BOOL bFail = FALSE;
5003
5004                 SKIPTESTS(rightvt);
5005
5006                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5007                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5008                     continue;
5009
5010                 memset(&left, 0, sizeof(left));
5011                 memset(&right, 0, sizeof(right));
5012                 V_VT(&left) = leftvt | ExtraFlags[i];
5013                 if (leftvt == VT_BSTR)
5014                     V_BSTR(&left) = lbstr;
5015                 V_VT(&right) = rightvt | ExtraFlags[i];
5016                 if (rightvt == VT_BSTR)
5017                     V_BSTR(&right) = rbstr;
5018                 V_VT(&result) = VT_EMPTY;
5019                 resvt = VT_UNKNOWN;
5020
5021                 /* Don't ask me why but native VarMul cannot handle:
5022                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5023                    Tested with DCOM98, Win2k, WinXP */
5024                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5025                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5026                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5027                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5028                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5029                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5030                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5031                     leftvt == VT_I1 || rightvt == VT_I1 ||
5032                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5033                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5034                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5035                     leftvt == VT_INT || rightvt == VT_INT ||
5036                     leftvt == VT_UINT || rightvt == VT_UINT) {
5037                     bFail = TRUE;
5038                 }
5039
5040                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5041                     resvt = VT_NULL;
5042                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5043                     resvt = VT_DECIMAL;
5044                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
5045                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
5046                          leftvt == VT_DATE || rightvt == VT_DATE)
5047                     resvt = VT_R8;
5048                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
5049                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5050                         leftvt == VT_I8 || rightvt == VT_I8 ||
5051                         leftvt == VT_CY || rightvt == VT_CY)
5052                         resvt = VT_R8;
5053                     else
5054                         resvt = VT_R4;
5055                 } else if (leftvt == VT_CY || rightvt == VT_CY)
5056                     resvt = VT_CY;
5057                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5058                     resvt = VT_I8;
5059                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5060                     resvt = VT_I4;
5061                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5062                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5063                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5064                     resvt = VT_I2;
5065                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5066                     resvt = VT_UI1;
5067
5068                 hres = pVarMul(&left, &right, &result);
5069                 if (bFail) {
5070                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5071                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5072                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5073                        V_VT(&result));
5074                 } else {
5075                     ok(hres == S_OK && V_VT(&result) == resvt,
5076                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5077                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5078                        V_VT(&result));
5079                 }
5080             }
5081         }
5082     }
5083
5084     /* Test returned values */
5085     VARMUL(I4,4,I4,2,I4,8);
5086     VARMUL(I2,4,I2,2,I2,8);
5087     VARMUL(I2,-13,I4,5,I4,-65);
5088     VARMUL(I4,-13,I4,5,I4,-65);
5089     VARMUL(I2,7,R4,0.5f,R4,3.5f);
5090     VARMUL(R4,0.5f,I4,5,R8,2.5);
5091     VARMUL(R8,7.1,BOOL,0,R8,0);
5092     VARMUL(BSTR,lbstr,I2,4,R8,48);
5093     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
5094     VARMUL(BSTR,lbstr,R4,0.1f,R8,1.2);
5095     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
5096     VARMUL(R4,0.2f,BSTR,rbstr,R8,2.4);
5097     VARMUL(DATE,2.25,I4,7,R8,15.75);
5098
5099     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
5100     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
5101     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
5102     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
5103     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
5104     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
5105     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
5106     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
5107     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
5108     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
5109     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
5110     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
5111
5112     /* Manuly test some VT_CY and VT_DECIMAL variants */
5113     V_VT(&cy) = VT_CY;
5114     hres = VarCyFromI4(4711, &V_CY(&cy));
5115     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5116     V_VT(&dec) = VT_DECIMAL;
5117     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5118     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5119     memset(&left, 0, sizeof(left));
5120     memset(&right, 0, sizeof(right));
5121     V_VT(&left) = VT_I4;
5122     V_I4(&left) = -11;
5123     V_VT(&right) = VT_UI1;
5124     V_UI1(&right) = 9;
5125
5126     hres = pVarMul(&cy, &right, &result);
5127     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5128     hres = VarR8FromCy(V_CY(&result), &r);
5129     ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
5130
5131     hres = pVarMul(&left, &dec, &result);
5132     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5133     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5134     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
5135
5136     SysFreeString(lbstr);
5137     SysFreeString(rbstr);
5138 }
5139
5140 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
5141
5142 #define VARADD(vt1,val1,vt2,val2,rvt,rval)               \
5143         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5144         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5145         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5146         test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )
5147
5148 static void test_VarAdd(void)
5149 {
5150     VARIANT left, right, exp, result, cy, dec;
5151     VARTYPE i;
5152     BSTR lbstr, rbstr;
5153     HRESULT hres;
5154     double r;
5155
5156     CHECKPTR(VarAdd);
5157
5158     lbstr = SysAllocString(sz12);
5159     rbstr = SysAllocString(sz12);
5160
5161     /* Test all possible flag/vt combinations & the resulting vt type */
5162     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5163     {
5164         VARTYPE leftvt, rightvt, resvt;
5165
5166         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5167         {
5168
5169             SKIPTESTS(leftvt);
5170
5171             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5172             {
5173                 BOOL bFail = FALSE;
5174
5175                 SKIPTESTS(rightvt);
5176
5177                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5178                     continue;
5179
5180                 memset(&left, 0, sizeof(left));
5181                 memset(&right, 0, sizeof(right));
5182                 V_VT(&left) = leftvt | ExtraFlags[i];
5183                 if (leftvt == VT_BSTR)
5184                     V_BSTR(&left) = lbstr;
5185                 V_VT(&right) = rightvt | ExtraFlags[i];
5186                 if (rightvt == VT_BSTR)
5187                     V_BSTR(&right) = rbstr;
5188                 V_VT(&result) = VT_EMPTY;
5189                 resvt = VT_ERROR;
5190
5191                 /* Don't ask me why but native VarAdd cannot handle:
5192                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5193                    Tested with DCOM98, Win2k, WinXP */
5194                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5195                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5196                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5197                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5198                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5199                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5200                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5201                     leftvt == VT_I1 || rightvt == VT_I1 ||
5202                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5203                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5204                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5205                     leftvt == VT_INT || rightvt == VT_INT ||
5206                     leftvt == VT_UINT || rightvt == VT_UINT) {
5207                     bFail = TRUE;
5208                 }
5209
5210                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5211                     resvt = VT_NULL;
5212                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
5213                     bFail = TRUE;
5214                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5215                     resvt = VT_DECIMAL;
5216                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
5217                     resvt = VT_DATE;
5218                 else if (leftvt == VT_CY || rightvt == VT_CY)
5219                     resvt = VT_CY;
5220                 else if (leftvt == VT_R8 || rightvt == VT_R8)
5221                     resvt = VT_R8;
5222                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
5223                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
5224                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5225                         resvt = VT_BSTR;
5226                     else
5227                         resvt = VT_R8;
5228                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
5229                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5230                         leftvt == VT_I8 || rightvt == VT_I8)
5231                         resvt = VT_R8;
5232                     else
5233                         resvt = VT_R4;
5234                 }
5235                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5236                     resvt = VT_I8;
5237                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5238                     resvt = VT_I4;
5239                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5240                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5241                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5242                     resvt = VT_I2;
5243                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5244                     resvt = VT_UI1;
5245
5246                 hres = pVarAdd(&left, &right, &result);
5247                 if (bFail) {
5248                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5249                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5250                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5251                        V_VT(&result));
5252                 } else {
5253                     ok(hres == S_OK && V_VT(&result) == resvt,
5254                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5255                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5256                        V_VT(&result));
5257                 }
5258                 /* Note, we don't clear left/right deliberately here */
5259                 VariantClear(&result);
5260             }
5261         }
5262     }
5263
5264     /* Test returned values */
5265     VARADD(I4,4,I4,2,I4,6);
5266     VARADD(I2,4,I2,2,I2,6);
5267     VARADD(I2,-13,I4,5,I4,-8);
5268     VARADD(I4,-13,I4,5,I4,-8);
5269     VARADD(I2,7,R4,0.5f,R4,7.5f);
5270     VARADD(R4,0.5f,I4,5,R8,5.5);
5271     VARADD(R8,7.1,BOOL,0,R8,7.1);
5272     VARADD(BSTR,lbstr,I2,4,R8,16);
5273     VARADD(BSTR,lbstr,BOOL,1,R8,13);
5274     VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
5275     VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
5276     VARADD(DATE,2.25,I4,7,DATE,9.25);
5277     VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
5278
5279     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
5280     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
5281     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
5282     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
5283     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
5284     VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
5285     VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
5286     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
5287     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
5288     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
5289     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
5290     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
5291
5292     /* Manually test BSTR + BSTR */
5293     V_VT(&left) = VT_BSTR;
5294     V_BSTR(&left) = lbstr;
5295     V_VT(&right) = VT_BSTR;
5296     V_BSTR(&right) = rbstr;
5297     hres = pVarAdd(&left, &right, &result);
5298     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
5299     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
5300     ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
5301     VariantClear(&result);
5302
5303     /* Manuly test some VT_CY and VT_DECIMAL variants */
5304     V_VT(&cy) = VT_CY;
5305     hres = VarCyFromI4(4711, &V_CY(&cy));
5306     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5307     V_VT(&dec) = VT_DECIMAL;
5308     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5309     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5310     memset(&left, 0, sizeof(left));
5311     memset(&right, 0, sizeof(right));
5312     V_VT(&left) = VT_I4;
5313     V_I4(&left) = -11;
5314     V_VT(&right) = VT_UI1;
5315     V_UI1(&right) = 9;
5316
5317     hres = pVarAdd(&cy, &right, &result);
5318     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5319     hres = VarR8FromCy(V_CY(&result), &r);
5320     ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
5321
5322     hres = pVarAdd(&left, &dec, &result);
5323     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5324     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5325     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
5326     VariantClear(&result);
5327
5328     SysFreeString(lbstr);
5329     SysFreeString(rbstr);
5330 }
5331
5332 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
5333 static HRESULT (WINAPI *pVarCat)(LPVARIANT,LPVARIANT,LPVARIANT);
5334
5335 static void test_VarCat(void)
5336 {
5337     LCID lcid;
5338     VARIANT left, right, result, expected, expected_broken;
5339     static const WCHAR sz34[] = {'3','4','\0'};
5340     static const WCHAR sz1234[] = {'1','2','3','4','\0'};
5341     static const WCHAR date_sz12[] = {'9','/','3','0','/','1','9','8','0','1','2','\0'};
5342     static const WCHAR date_sz12_broken[] = {'9','/','3','0','/','8','0','1','2','\0'};
5343     static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
5344     static const WCHAR sz12_date_broken[] = {'1','2','9','/','3','0','/','8','0','\0'};
5345     static const WCHAR sz_empty[] = {'\0'};
5346     TCHAR orig_date_format[128];
5347     VARTYPE leftvt, rightvt, resultvt;
5348     HRESULT hres;
5349     HRESULT expected_error_num;
5350
5351     CHECKPTR(VarCat);
5352
5353     /* Set date format for testing */
5354     lcid = LOCALE_USER_DEFAULT;
5355     GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
5356     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
5357
5358     VariantInit(&left);
5359     VariantInit(&right);
5360     VariantInit(&result);
5361     VariantInit(&expected);
5362
5363     /* Check expected types for all combinations */
5364     for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5365     {
5366
5367         SKIPTESTS(leftvt);
5368
5369         /* Check if we need/have support for I8 and/or UI8 */
5370         if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5371             continue;
5372
5373         for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5374         {
5375
5376             SKIPTESTS(rightvt);
5377             expected_error_num = S_OK;
5378             resultvt = VT_EMPTY;
5379
5380             if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5381                 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN  ||
5382                 leftvt == VT_RECORD || rightvt == VT_RECORD  ||
5383                 leftvt == 15 || rightvt == 15 /* Undefined type */)
5384                 continue;
5385
5386             /* Check if we need/have support for I8 and/or UI8 */
5387             if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5388                 continue;
5389
5390             if (leftvt == VT_NULL && rightvt == VT_NULL)
5391                 resultvt = VT_NULL;
5392             else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
5393                 rightvt == VT_DATE || rightvt == VT_DECIMAL))
5394                 expected_error_num = DISP_E_TYPEMISMATCH;
5395             else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
5396                 leftvt == VT_R4 || leftvt == VT_R8 ||
5397                 leftvt == VT_CY || leftvt == VT_BOOL ||
5398                 leftvt == VT_BSTR || leftvt == VT_I1 ||
5399                 leftvt == VT_UI1 || leftvt == VT_UI2 ||
5400                 leftvt == VT_UI4 || leftvt == VT_I8 ||
5401                 leftvt == VT_UI8 || leftvt == VT_INT ||
5402                 leftvt == VT_UINT || leftvt == VT_EMPTY ||
5403                 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
5404                 leftvt == VT_DATE)
5405                 &&
5406                 (rightvt == VT_I2 || rightvt == VT_I4 ||
5407                 rightvt == VT_R4 || rightvt == VT_R8 ||
5408                 rightvt == VT_CY || rightvt == VT_BOOL ||
5409                 rightvt == VT_BSTR || rightvt == VT_I1 ||
5410                 rightvt == VT_UI1 || rightvt == VT_UI2 ||
5411                 rightvt == VT_UI4 || rightvt == VT_I8 ||
5412                 rightvt == VT_UI8 || rightvt == VT_INT ||
5413                 rightvt == VT_UINT || rightvt == VT_EMPTY ||
5414                 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
5415                 rightvt == VT_DATE))
5416                 resultvt = VT_BSTR;
5417             else if (rightvt == VT_ERROR && leftvt < VT_VOID)
5418                 expected_error_num = DISP_E_TYPEMISMATCH;
5419             else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
5420                 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
5421                 expected_error_num = DISP_E_TYPEMISMATCH;
5422             else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
5423                 rightvt == VT_DECIMAL)
5424                 expected_error_num = DISP_E_BADVARTYPE;
5425             else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
5426                 expected_error_num = DISP_E_TYPEMISMATCH;
5427             else if (leftvt == VT_VARIANT)
5428                 expected_error_num = DISP_E_TYPEMISMATCH;
5429             else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
5430                 leftvt == VT_NULL || leftvt ==  VT_I2 ||
5431                 leftvt == VT_I4 || leftvt == VT_R4 ||
5432                 leftvt == VT_R8 || leftvt == VT_CY ||
5433                 leftvt == VT_DATE || leftvt == VT_BSTR ||
5434                 leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
5435                 leftvt == VT_I1 || leftvt == VT_UI1 ||
5436                 leftvt == VT_UI2 || leftvt == VT_UI4 ||
5437                 leftvt == VT_I8 || leftvt == VT_UI8 ||
5438                 leftvt == VT_INT || leftvt == VT_UINT
5439                 ))
5440                 expected_error_num = DISP_E_TYPEMISMATCH;
5441             else
5442                 expected_error_num = DISP_E_BADVARTYPE;
5443
5444             V_VT(&left) = leftvt;
5445             V_VT(&right) = rightvt;
5446
5447             switch (leftvt) {
5448             case VT_BSTR:
5449                 V_BSTR(&left) = SysAllocString(sz_empty); break;
5450             case VT_DATE:
5451                 V_DATE(&left) = 0.0; break;
5452             case VT_DECIMAL:
5453                 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
5454             default:
5455                 V_I8(&left) = 0;
5456             }
5457
5458             switch (rightvt) {
5459             case VT_BSTR:
5460                 V_BSTR(&right) = SysAllocString(sz_empty); break;
5461             case VT_DATE:
5462                 V_DATE(&right) = 0.0; break;
5463             case VT_DECIMAL:
5464                 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
5465             default:
5466                 V_I8(&right) = 0;
5467             }
5468
5469             hres = pVarCat(&left, &right, &result);
5470
5471             /* Determine the error code for the vt combination */
5472             ok(hres == expected_error_num,
5473                 "VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
5474                 leftvt, rightvt, expected_error_num, hres);
5475
5476             /* Check types are correct */
5477             ok(V_VT(&result) == resultvt,
5478                 "VarCat: %d, %d: expected vt %d, got vt %d\n",
5479                 leftvt, rightvt, resultvt, V_VT(&result));
5480
5481             VariantClear(&left);
5482             VariantClear(&right);
5483             VariantClear(&result);
5484         }
5485     }
5486
5487     /* Running single comparison tests to compare outputs */
5488
5489     /* Test concat strings */
5490     V_VT(&left) = VT_BSTR;
5491     V_VT(&right) = VT_BSTR;
5492     V_VT(&expected) = VT_BSTR;
5493     V_BSTR(&left) = SysAllocString(sz12);
5494     V_BSTR(&right) = SysAllocString(sz34);
5495     V_BSTR(&expected) = SysAllocString(sz1234);
5496     hres = pVarCat(&left,&right,&result);
5497     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5498     if (pVarCmp)
5499         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5500            "VarCat: VT_BSTR concat with VT_BSTR failed to return correct result\n");
5501
5502     VariantClear(&left);
5503     VariantClear(&right);
5504     VariantClear(&result);
5505
5506     /* Test if expression is VT_ERROR */
5507     V_VT(&left) = VT_ERROR;
5508     V_VT(&right) = VT_BSTR;
5509     V_BSTR(&right) = SysAllocString(sz1234);
5510     hres = pVarCat(&left,&right,&result);
5511     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5512     ok(V_VT(&result) == VT_EMPTY,
5513         "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
5514
5515     VariantClear(&left);
5516     VariantClear(&right);
5517     VariantClear(&result);
5518
5519     V_VT(&left) = VT_BSTR;
5520     V_VT(&right) = VT_ERROR;
5521     V_BSTR(&left) = SysAllocString(sz1234);
5522     hres = pVarCat(&left,&right,&result);
5523     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5524     ok(V_VT(&result) == VT_EMPTY,
5525         "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
5526
5527     VariantClear(&left);
5528     VariantClear(&right);
5529     VariantClear(&result);
5530     VariantClear(&expected);
5531
5532     /* Test combining boolean with number */
5533     V_VT(&left) = VT_INT;
5534     V_VT(&right) = VT_BOOL;
5535     V_VT(&expected) = VT_BSTR;
5536     V_INT(&left) = 12;
5537     V_BOOL(&right) = TRUE;
5538     V_BSTR(&expected) = SysAllocString(sz12_true);
5539     hres = pVarCat(&left,&right,&result);
5540     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5541     if (pVarCmp)
5542     {
5543         hres = pVarCmp(&result,&expected,lcid,0);
5544         ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5545            hres, variantstr(&result), variantstr(&expected));
5546     }
5547
5548     VariantClear(&left);
5549     VariantClear(&right);
5550     VariantClear(&result);
5551     VariantClear(&expected);
5552
5553     V_VT(&left) = VT_INT;
5554     V_VT(&right) = VT_BOOL;
5555     V_VT(&expected) = VT_BSTR;
5556     V_INT(&left) = 12;
5557     V_BOOL(&right) = FALSE;
5558     V_BSTR(&expected) = SysAllocString(sz12_false);
5559     hres = pVarCat(&left,&right,&result);
5560     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5561     if (pVarCmp)
5562     {
5563         hres = pVarCmp(&result,&expected,lcid,0);
5564         ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5565            hres, variantstr(&result), variantstr(&expected));
5566     }
5567
5568     VariantClear(&left);
5569     VariantClear(&right);
5570     VariantClear(&result);
5571     VariantClear(&expected);
5572
5573     /* Test when both expressions are numeric */
5574     V_VT(&left) = VT_INT;
5575     V_VT(&right) = VT_INT;
5576     V_VT(&expected) = VT_BSTR;
5577     V_INT(&left)  = 12;
5578     V_INT(&right) = 34;
5579     V_BSTR(&expected) = SysAllocString(sz1234);
5580     hres = pVarCat(&left,&right,&result);
5581     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5582     if (pVarCmp)
5583         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5584            "VarCat: NUMBER concat with NUMBER returned incorrect result\n");
5585
5586     VariantClear(&left);
5587     VariantClear(&right);
5588     VariantClear(&result);
5589
5590     /* Test if one expression is numeric and the other is a string */
5591     V_VT(&left) = VT_INT;
5592     V_VT(&right) = VT_BSTR;
5593     V_INT(&left) = 12;
5594     V_BSTR(&right) = SysAllocString(sz34);
5595     hres = pVarCat(&left,&right,&result);
5596     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5597     if (pVarCmp)
5598         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5599            "VarCat: NUMBER concat with VT_BSTR, incorrect result\n");
5600
5601     VariantClear(&left);
5602     VariantClear(&right);
5603     VariantClear(&result);
5604
5605     V_VT(&left) = VT_BSTR;
5606     V_VT(&right) = VT_INT;
5607     V_BSTR(&left) = SysAllocString(sz12);
5608     V_INT(&right) = 34;
5609     hres = pVarCat(&left,&right,&result);
5610     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5611     if (pVarCmp)
5612         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5613            "VarCat: VT_BSTR concat with NUMBER, incorrect result\n");
5614
5615     VariantClear(&left);
5616     VariantClear(&right);
5617     VariantClear(&result);
5618     VariantClear(&expected);
5619
5620     /* Test concat dates with strings */
5621     V_VT(&left) = VT_BSTR;
5622     V_VT(&right) = VT_DATE;
5623     V_VT(&expected) = VT_BSTR;
5624     V_VT(&expected_broken) = VT_BSTR;
5625     V_BSTR(&left) = SysAllocString(sz12);
5626     V_DATE(&right) = 29494.0;
5627     V_BSTR(&expected)= SysAllocString(sz12_date);
5628     V_BSTR(&expected_broken)= SysAllocString(sz12_date_broken);
5629     hres = pVarCat(&left,&right,&result);
5630     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5631     if (pVarCmp)
5632         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5633            broken(pVarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5634            "VarCat: VT_BSTR concat with VT_DATE returned incorrect result\n");
5635
5636     VariantClear(&left);
5637     VariantClear(&right);
5638     VariantClear(&result);
5639     VariantClear(&expected);
5640     VariantClear(&expected_broken);
5641
5642     V_VT(&left) = VT_DATE;
5643     V_VT(&right) = VT_BSTR;
5644     V_VT(&expected) = VT_BSTR;
5645     V_VT(&expected_broken) = VT_BSTR;
5646     V_DATE(&left) = 29494.0;
5647     V_BSTR(&right) = SysAllocString(sz12);
5648     V_BSTR(&expected)= SysAllocString(date_sz12);
5649     V_BSTR(&expected_broken)= SysAllocString(date_sz12_broken);
5650     hres = pVarCat(&left,&right,&result);
5651     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5652     if (pVarCmp)
5653         ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5654            broken(pVarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5655            "VarCat: VT_DATE concat with VT_BSTR returned incorrect result\n");
5656
5657     VariantClear(&left);
5658     VariantClear(&right);
5659     VariantClear(&result);
5660     VariantClear(&expected);
5661     VariantClear(&expected_broken);
5662
5663     /* Test of both expressions are empty */
5664     V_VT(&left) = VT_BSTR;
5665     V_VT(&right) = VT_BSTR;
5666     V_VT(&expected) = VT_BSTR;
5667     V_BSTR(&left) = SysAllocString(sz_empty);
5668     V_BSTR(&right) = SysAllocString(sz_empty);
5669     V_BSTR(&expected)= SysAllocString(sz_empty);
5670     hres = pVarCat(&left,&right,&result);
5671     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5672     if (pVarCmp)
5673         ok(pVarCmp(&result,&left,lcid,0) == VARCMP_EQ,
5674            "VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
5675
5676     /* Restore original date format settings */
5677     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
5678
5679     VariantClear(&left);
5680     VariantClear(&right);
5681     VariantClear(&result);
5682     VariantClear(&expected);
5683
5684     /* Test boolean conversion */
5685     V_VT(&left) = VT_BOOL;
5686     V_BOOL(&left) = VARIANT_TRUE;
5687     V_VT(&right) = VT_BSTR;
5688     V_BSTR(&right) = SysAllocStringLen(NULL,0);
5689     hres = pVarCat(&left, &right, &result);
5690     ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5691     if(!strcmp_wa(V_BSTR(&result), "True")) {
5692         V_VT(&right) = VT_BOOL;
5693         V_BOOL(&right) = 100;
5694         hres = pVarCat(&left, &right, &result);
5695         ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5696         test_bstr_var(&result, "TrueTrue");
5697         VariantClear(&result);
5698
5699         V_BOOL(&right) = VARIANT_FALSE;
5700         hres = pVarCat(&left, &right, &result);
5701         ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5702         test_bstr_var(&result, "TrueFalse");
5703         VariantClear(&result);
5704     }else {
5705         skip("Got %s as True, assuming non-English locale\n", wine_dbgstr_w(V_BSTR(&result)));
5706     }
5707 }
5708
5709 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
5710
5711 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
5712         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5713         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5714         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5715         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5716
5717 #define VARANDCY(vt1,val1,val2,rvt,rval)                 \
5718         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5719         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5720         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5721         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5722
5723 /* Skip any type that is not defined or produces an error for every case */
5724 #define SKIPTESTAND(a)                                \
5725         if (a == VT_ERROR || a == VT_VARIANT ||       \
5726             a == VT_DISPATCH || a == VT_UNKNOWN ||    \
5727             a > VT_UINT || a == 15 /*not defined*/)   \
5728             continue
5729
5730 static void test_VarAnd(void)
5731 {
5732     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5733     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5734     VARIANT left, right, exp, result;
5735     BSTR false_str, true_str;
5736     VARTYPE i;
5737     HRESULT hres;
5738
5739     true_str = SysAllocString(szTrue);
5740     false_str = SysAllocString(szFalse);
5741
5742     CHECKPTR(VarAnd);
5743
5744     /* Test all possible flag/vt combinations & the resulting vt type */
5745     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5746     {
5747         VARTYPE leftvt, rightvt, resvt;
5748
5749         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5750         {
5751             SKIPTESTAND(leftvt);
5752
5753             /* Check if we need/have support for I8 and/or UI8 */
5754             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5755                 continue;
5756
5757             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5758             {
5759                 BOOL bFail = FALSE;
5760                 SKIPTESTAND(rightvt);
5761
5762                 /* Check if we need/have support for I8 and/or UI8 */
5763                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5764                     continue;
5765
5766                 memset(&left, 0, sizeof(left));
5767                 memset(&right, 0, sizeof(right));
5768                 V_VT(&left) = leftvt | ExtraFlags[i];
5769                 V_VT(&right) = rightvt | ExtraFlags[i];
5770                 V_VT(&result) = VT_EMPTY;
5771                 resvt = VT_EMPTY;
5772                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
5773                     V_BSTR(&left) = true_str;
5774                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
5775                     V_BSTR(&right) = true_str;
5776
5777                 /* Native VarAnd always returns an error when using extra
5778                  * flags or if the variant combination is I8 and INT.
5779                  */
5780                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5781                     (leftvt == VT_INT && rightvt == VT_I8) ||
5782                     ExtraFlags[i] != 0)
5783                     bFail = TRUE;
5784
5785                 /* Determine return type */
5786                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5787                     resvt = VT_I8;
5788                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5789                     leftvt == VT_UINT || rightvt == VT_UINT ||
5790                     leftvt == VT_INT || rightvt == VT_INT ||
5791                     leftvt == VT_UINT || rightvt == VT_UINT ||
5792                     leftvt == VT_R4 || rightvt == VT_R4 ||
5793                     leftvt == VT_R8 || rightvt == VT_R8 ||
5794                     leftvt == VT_CY || rightvt == VT_CY ||
5795                     leftvt == VT_DATE || rightvt == VT_DATE ||
5796                     leftvt == VT_I1 || rightvt == VT_I1 ||
5797                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5798                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5799                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5800                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5801                     resvt = VT_I4;
5802                 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
5803                     leftvt == VT_I2 || rightvt == VT_I2 ||
5804                     leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5805                     if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
5806                         (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5807                         (leftvt == VT_UI1 && rightvt == VT_UI1))
5808                         resvt = VT_UI1;
5809                     else
5810                         resvt = VT_I2;
5811                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5812                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
5813                     resvt = VT_BOOL;
5814                 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
5815                     leftvt == VT_BSTR || rightvt == VT_BSTR)
5816                     resvt = VT_NULL;
5817                 else
5818                     bFail = TRUE;
5819
5820                 hres = pVarAnd(&left, &right, &result);
5821
5822                 /* Check expected HRESULT and if result variant type is correct */
5823                 if (bFail)
5824                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
5825                         "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
5826                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
5827                         vtstr(V_VT(&result)), hres);
5828                 else
5829                     ok (hres == S_OK && resvt == V_VT(&result),
5830                         "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
5831                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
5832                         S_OK, vtstr(V_VT(&result)), hres);
5833             }
5834         }
5835     }
5836
5837     /*
5838      * Test returned values. Since we know the returned type is correct
5839      * and that we handle all combinations of invalid types, just check
5840      * that good type combinations produce the desired value.
5841      * FIXME: Test VT_DECIMAL
5842      */
5843     VARAND(EMPTY,0,EMPTY,0,I2,0);
5844     VARAND(EMPTY,1,EMPTY,0,I2,0);
5845     VARAND(EMPTY,1,EMPTY,1,I2,0);
5846     VARAND(EMPTY,0,NULL,0,I2,0);
5847     VARAND(EMPTY,1,NULL,0,I2,0);
5848     VARAND(EMPTY,1,NULL,1,I2,0);
5849     VARAND(EMPTY,0,I1,0,I4,0);
5850     VARAND(EMPTY,0,I1,1,I4,0);
5851     VARAND(EMPTY,1,I1,1,I4,0);
5852     VARAND(EMPTY,0,UI1,0,I2,0);
5853     VARAND(EMPTY,0,UI1,1,I2,0);
5854     VARAND(EMPTY,1,UI1,1,I2,0);
5855     VARAND(EMPTY,0,I2,0,I2,0);
5856     VARAND(EMPTY,0,I2,1,I2,0);
5857     VARAND(EMPTY,1,I2,1,I2,0);
5858     VARAND(EMPTY,0,UI2,0,I4,0);
5859     VARAND(EMPTY,0,UI2,1,I4,0);
5860     VARAND(EMPTY,1,UI2,1,I4,0);
5861     VARAND(EMPTY,0,I4,0,I4,0);
5862     VARAND(EMPTY,0,I4,1,I4,0);
5863     VARAND(EMPTY,1,I4,1,I4,0);
5864     VARAND(EMPTY,0,UI4,0,I4,0);
5865     VARAND(EMPTY,0,UI4,1,I4,0);
5866     VARAND(EMPTY,1,UI4,1,I4,0);
5867     if (HAVE_OLEAUT32_I8)
5868     {
5869         VARAND(EMPTY,0,I8,0,I8,0);
5870         VARAND(EMPTY,0,I8,1,I8,0);
5871         VARAND(EMPTY,1,I8,1,I8,0);
5872         VARAND(EMPTY,0,UI8,0,I4,0);
5873         VARAND(EMPTY,0,UI8,1,I4,0);
5874         VARAND(EMPTY,1,UI8,1,I4,0);
5875     }
5876     VARAND(EMPTY,0,INT,0,I4,0);
5877     VARAND(EMPTY,0,INT,1,I4,0);
5878     VARAND(EMPTY,1,INT,1,I4,0);
5879     VARAND(EMPTY,0,UINT,0,I4,0);
5880     VARAND(EMPTY,0,UINT,1,I4,0);
5881     VARAND(EMPTY,1,UINT,1,I4,0);
5882     VARAND(EMPTY,0,BOOL,0,I2,0);
5883     VARAND(EMPTY,0,BOOL,1,I2,0);
5884     VARAND(EMPTY,1,BOOL,1,I2,0);
5885     VARAND(EMPTY,0,R4,0,I4,0);
5886     VARAND(EMPTY,0,R4,1,I4,0);
5887     VARAND(EMPTY,1,R4,1,I4,0);
5888     VARAND(EMPTY,0,R8,0,I4,0);
5889     VARAND(EMPTY,0,R8,1,I4,0);
5890     VARAND(EMPTY,1,R8,1,I4,0);
5891     VARAND(EMPTY,0,BSTR,false_str,I2,0);
5892     VARAND(EMPTY,0,BSTR,true_str,I2,0);
5893     VARANDCY(EMPTY,0,10000,I4,0);
5894
5895     /* NULL OR 0 = NULL. NULL OR n = n */
5896     VARAND(NULL,0,NULL,0,NULL,0);
5897     VARAND(NULL,1,NULL,0,NULL,0);
5898     VARAND(NULL,0,I1,0,I4,0);
5899     VARAND(NULL,0,I1,1,NULL,0);
5900     VARAND(NULL,0,UI1,0,UI1,0);
5901     VARAND(NULL,0,UI1,1,NULL,0);
5902     VARAND(NULL,0,I2,0,I2,0);
5903     VARAND(NULL,0,I2,1,NULL,0);
5904     VARAND(NULL,0,UI2,0,I4,0);
5905     VARAND(NULL,0,UI2,1,NULL,0);
5906     VARAND(NULL,0,I4,0,I4,0);
5907     VARAND(NULL,0,I4,1,NULL,0);
5908     VARAND(NULL,0,UI4,0,I4,0);
5909     VARAND(NULL,0,UI4,1,NULL,0);
5910     if (HAVE_OLEAUT32_I8)
5911     {
5912         VARAND(NULL,0,I8,0,I8,0);
5913         VARAND(NULL,0,I8,1,NULL,0);
5914         VARAND(NULL,0,UI8,0,I4,0);
5915         VARAND(NULL,0,UI8,1,NULL,0);
5916     }
5917     VARAND(NULL,0,INT,0,I4,0);
5918     VARAND(NULL,0,INT,1,NULL,0);
5919     VARAND(NULL,0,UINT,0,I4,0);
5920     VARAND(NULL,0,UINT,1,NULL,0);
5921     VARAND(NULL,0,BOOL,0,BOOL,0);
5922     VARAND(NULL,0,BOOL,1,NULL,0);
5923     VARAND(NULL,0,R4,0,I4,0);
5924     VARAND(NULL,0,R4,1,NULL,0);
5925     VARAND(NULL,0,R8,0,I4,0);
5926     VARAND(NULL,0,R8,1,NULL,0);
5927     VARAND(NULL,0,BSTR,false_str,BOOL,0);
5928     VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
5929     VARANDCY(NULL,0,10000,NULL,0);
5930     VARANDCY(NULL,0,0,I4,0);
5931     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5932     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5933     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
5934     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5935
5936     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5937     VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5938     VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
5939     VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
5940     VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
5941     VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
5942     VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5943     VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5944     VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
5945     VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
5946     VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
5947     VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
5948     VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5949     VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5950     VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
5951     VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
5952     VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5953     VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
5954     VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5955     VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5956     VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
5957     VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
5958     VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5959     VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
5960     VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
5961     VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5962     VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
5963     VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5964     if (HAVE_OLEAUT32_I8)
5965     {
5966         VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5967         VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
5968         VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
5969         VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
5970         VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5971     }
5972     VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5973     VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
5974     VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
5975     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5976     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
5977     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5978     VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
5979     VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
5980     VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
5981     VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
5982     VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
5983     VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
5984     VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
5985     VARAND(I1,-1,I1,-1,I4,-1);
5986     VARAND(I1,-1,I1,0,I4,0);
5987     VARAND(I1,0,I1,0,I4,0);
5988     VARAND(I1,-1,UI1,255,I4,255);
5989     VARAND(I1,-1,UI1,0,I4,0);
5990     VARAND(I1,0,UI1,0,I4,0);
5991     VARAND(I1,-1,I2,-1,I4,-1);
5992     VARAND(I1,-1,I2,0,I4,0);
5993     VARAND(I1,0,I2,0,I4,0);
5994     VARAND(I1,-1,UI2,65535,I4,65535);
5995     VARAND(I1,-1,UI2,0,I4,0);
5996     VARAND(I1,0,UI2,0,I4,0);
5997     VARAND(I1,-1,I4,-1,I4,-1);
5998     VARAND(I1,-1,I4,0,I4,0);
5999     VARAND(I1,0,I4,0,I4,0);
6000     VARAND(I1,-1,UI4,0xffffffff,I4,-1);
6001     VARAND(I1,-1,UI4,0,I4,0);
6002     VARAND(I1,0,UI4,0,I4,0);
6003     VARAND(I1,-1,R4,-1,I4,-1);
6004     VARAND(I1,-1,R4,0,I4,0);
6005     VARAND(I1,0,R4,0,I4,0);
6006     VARAND(I1,-1,R8,-1,I4,-1);
6007     VARAND(I1,-1,R8,0,I4,0);
6008     VARAND(I1,0,R8,0,I4,0);
6009     VARAND(I1,-1,DATE,-1,I4,-1);
6010     VARAND(I1,-1,DATE,0,I4,0);
6011     VARAND(I1,0,DATE,0,I4,0);
6012     if (HAVE_OLEAUT32_I8)
6013     {
6014         VARAND(I1,-1,I8,-1,I8,-1);
6015         VARAND(I1,-1,I8,0,I8,0);
6016         VARAND(I1,0,I8,0,I8,0);
6017         VARAND(I1,-1,UI8,0,I4,0);
6018         VARAND(I1,0,UI8,0,I4,0);
6019     }
6020     VARAND(I1,-1,INT,-1,I4,-1);
6021     VARAND(I1,-1,INT,0,I4,0);
6022     VARAND(I1,0,INT,0,I4,0);
6023     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
6024     VARAND(I1,-1,UINT,0,I4,0);
6025     VARAND(I1,0,UINT,0,I4,0);
6026     VARAND(I1,0,BSTR,false_str,I4,0);
6027     VARAND(I1,-1,BSTR,false_str,I4,0);
6028     VARAND(I1,0,BSTR,true_str,I4,0);
6029     VARAND(I1,-1,BSTR,true_str,I4,-1);
6030     VARANDCY(I1,-1,10000,I4,1);
6031     VARANDCY(I1,-1,0,I4,0);
6032     VARANDCY(I1,0,0,I4,0);
6033
6034     VARAND(UI1,255,UI1,255,UI1,255);
6035     VARAND(UI1,255,UI1,0,UI1,0);
6036     VARAND(UI1,0,UI1,0,UI1,0);
6037     VARAND(UI1,255,I2,-1,I2,255);
6038     VARAND(UI1,255,I2,0,I2,0);
6039     VARAND(UI1,0,I2,0,I2,0);
6040     VARAND(UI1,255,UI2,65535,I4,255);
6041     VARAND(UI1,255,UI2,0,I4,0);
6042     VARAND(UI1,0,UI2,0,I4,0);
6043     VARAND(UI1,255,I4,-1,I4,255);
6044     VARAND(UI1,255,I4,0,I4,0);
6045     VARAND(UI1,0,I4,0,I4,0);
6046     VARAND(UI1,255,UI4,0xffffffff,I4,255);
6047     VARAND(UI1,255,UI4,0,I4,0);
6048     VARAND(UI1,0,UI4,0,I4,0);
6049     VARAND(UI1,255,R4,-1,I4,255);
6050     VARAND(UI1,255,R4,0,I4,0);
6051     VARAND(UI1,0,R4,0,I4,0);
6052     VARAND(UI1,255,R8,-1,I4,255);
6053     VARAND(UI1,255,R8,0,I4,0);
6054     VARAND(UI1,0,R8,0,I4,0);
6055     VARAND(UI1,255,DATE,-1,I4,255);
6056     VARAND(UI1,255,DATE,0,I4,0);
6057     VARAND(UI1,0,DATE,0,I4,0);
6058     if (HAVE_OLEAUT32_I8)
6059     {
6060         VARAND(UI1,255,I8,-1,I8,255);
6061         VARAND(UI1,255,I8,0,I8,0);
6062         VARAND(UI1,0,I8,0,I8,0);
6063         VARAND(UI1,255,UI8,0,I4,0);
6064         VARAND(UI1,0,UI8,0,I4,0);
6065     }
6066     VARAND(UI1,255,INT,-1,I4,255);
6067     VARAND(UI1,255,INT,0,I4,0);
6068     VARAND(UI1,0,INT,0,I4,0);
6069     VARAND(UI1,255,UINT,0xffffffff,I4,255);
6070     VARAND(UI1,255,UINT,0,I4,0);
6071     VARAND(UI1,0,UINT,0,I4,0);
6072     VARAND(UI1,0,BSTR,false_str,I2,0);
6073     VARAND(UI1,255,BSTR,false_str,I2,0);
6074     VARAND(UI1,0,BSTR,true_str,I2,0);
6075     VARAND(UI1,255,BSTR,true_str,I2,255);
6076     VARANDCY(UI1,255,10000,I4,1);
6077     VARANDCY(UI1,255,0,I4,0);
6078     VARANDCY(UI1,0,0,I4,0);
6079
6080     VARAND(I2,-1,I2,-1,I2,-1);
6081     VARAND(I2,-1,I2,0,I2,0);
6082     VARAND(I2,0,I2,0,I2,0);
6083     VARAND(I2,-1,UI2,65535,I4,65535);
6084     VARAND(I2,-1,UI2,0,I4,0);
6085     VARAND(I2,0,UI2,0,I4,0);
6086     VARAND(I2,-1,I4,-1,I4,-1);
6087     VARAND(I2,-1,I4,0,I4,0);
6088     VARAND(I2,0,I4,0,I4,0);
6089     VARAND(I2,-1,UI4,0xffffffff,I4,-1);
6090     VARAND(I2,-1,UI4,0,I4,0);
6091     VARAND(I2,0,UI4,0,I4,0);
6092     VARAND(I2,-1,R4,-1,I4,-1);
6093     VARAND(I2,-1,R4,0,I4,0);
6094     VARAND(I2,0,R4,0,I4,0);
6095     VARAND(I2,-1,R8,-1,I4,-1);
6096     VARAND(I2,-1,R8,0,I4,0);
6097     VARAND(I2,0,R8,0,I4,0);
6098     VARAND(I2,-1,DATE,-1,I4,-1);
6099     VARAND(I2,-1,DATE,0,I4,0);
6100     VARAND(I2,0,DATE,0,I4,0);
6101     if (HAVE_OLEAUT32_I8)
6102     {
6103         VARAND(I2,-1,I8,-1,I8,-1);
6104         VARAND(I2,-1,I8,0,I8,0);
6105         VARAND(I2,0,I8,0,I8,0);
6106         VARAND(I2,-1,UI8,0,I4,0);
6107         VARAND(I2,0,UI8,0,I4,0);
6108     }
6109     VARAND(I2,-1,INT,-1,I4,-1);
6110     VARAND(I2,-1,INT,0,I4,0);
6111     VARAND(I2,0,INT,0,I4,0);
6112     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
6113     VARAND(I2,-1,UINT,0,I4,0);
6114     VARAND(I2,0,UINT,0,I4,0);
6115     VARAND(I2,0,BSTR,false_str,I2,0);
6116     VARAND(I2,-1,BSTR,false_str,I2,0);
6117     VARAND(I2,0,BSTR,true_str,I2,0);
6118     VARAND(I2,-1,BSTR,true_str,I2,-1);
6119     VARANDCY(I2,-1,10000,I4,1);
6120     VARANDCY(I2,-1,0,I4,0);
6121     VARANDCY(I2,0,0,I4,0);
6122
6123     VARAND(UI2,65535,UI2,65535,I4,65535);
6124     VARAND(UI2,65535,UI2,0,I4,0);
6125     VARAND(UI2,0,UI2,0,I4,0);
6126     VARAND(UI2,65535,I4,-1,I4,65535);
6127     VARAND(UI2,65535,I4,0,I4,0);
6128     VARAND(UI2,0,I4,0,I4,0);
6129     VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
6130     VARAND(UI2,65535,UI4,0,I4,0);
6131     VARAND(UI2,0,UI4,0,I4,0);
6132     VARAND(UI2,65535,R4,-1,I4,65535);
6133     VARAND(UI2,65535,R4,0,I4,0);
6134     VARAND(UI2,0,R4,0,I4,0);
6135     VARAND(UI2,65535,R8,-1,I4,65535);
6136     VARAND(UI2,65535,R8,0,I4,0);
6137     VARAND(UI2,0,R8,0,I4,0);
6138     VARAND(UI2,65535,DATE,-1,I4,65535);
6139     VARAND(UI2,65535,DATE,0,I4,0);
6140     VARAND(UI2,0,DATE,0,I4,0);
6141     if (HAVE_OLEAUT32_I8)
6142     {
6143         VARAND(UI2,65535,I8,-1,I8,65535);
6144         VARAND(UI2,65535,I8,0,I8,0);
6145         VARAND(UI2,0,I8,0,I8,0);
6146         VARAND(UI2,65535,UI8,0,I4,0);
6147         VARAND(UI2,0,UI8,0,I4,0);
6148     }
6149     VARAND(UI2,65535,INT,-1,I4,65535);
6150     VARAND(UI2,65535,INT,0,I4,0);
6151     VARAND(UI2,0,INT,0,I4,0);
6152     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
6153     VARAND(UI2,65535,UINT,0,I4,0);
6154     VARAND(UI2,0,UINT,0,I4,0);
6155     VARAND(UI2,0,BSTR,false_str,I4,0);
6156     VARAND(UI2,65535,BSTR,false_str,I4,0);
6157     VARAND(UI2,0,BSTR,true_str,I4,0);
6158     VARAND(UI2,65535,BSTR,true_str,I4,65535);
6159     VARANDCY(UI2,65535,10000,I4,1);
6160     VARANDCY(UI2,65535,0,I4,0);
6161     VARANDCY(UI2,0,0,I4,0);
6162
6163     VARAND(I4,-1,I4,-1,I4,-1);
6164     VARAND(I4,-1,I4,0,I4,0);
6165     VARAND(I4,0,I4,0,I4,0);
6166     VARAND(I4,-1,UI4,0xffffffff,I4,-1);
6167     VARAND(I4,-1,UI4,0,I4,0);
6168     VARAND(I4,0,UI4,0,I4,0);
6169     VARAND(I4,-1,R4,-1,I4,-1);
6170     VARAND(I4,-1,R4,0,I4,0);
6171     VARAND(I4,0,R4,0,I4,0);
6172     VARAND(I4,-1,R8,-1,I4,-1);
6173     VARAND(I4,-1,R8,0,I4,0);
6174     VARAND(I4,0,R8,0,I4,0);
6175     VARAND(I4,-1,DATE,-1,I4,-1);
6176     VARAND(I4,-1,DATE,0,I4,0);
6177     VARAND(I4,0,DATE,0,I4,0);
6178     if (HAVE_OLEAUT32_I8)
6179     {
6180         VARAND(I4,-1,I8,-1,I8,-1);
6181         VARAND(I4,-1,I8,0,I8,0);
6182         VARAND(I4,0,I8,0,I8,0);
6183         VARAND(I4,-1,UI8,0,I4,0);
6184         VARAND(I4,0,UI8,0,I4,0);
6185     }
6186     VARAND(I4,-1,INT,-1,I4,-1);
6187     VARAND(I4,-1,INT,0,I4,0);
6188     VARAND(I4,0,INT,0,I4,0);
6189     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
6190     VARAND(I4,-1,UINT,0,I4,0);
6191     VARAND(I4,0,UINT,0,I4,0);
6192     VARAND(I4,0,BSTR,false_str,I4,0);
6193     VARAND(I4,-1,BSTR,false_str,I4,0);
6194     VARAND(I4,0,BSTR,true_str,I4,0);
6195     VARAND(I4,-1,BSTR,true_str,I4,-1);
6196     VARANDCY(I4,-1,10000,I4,1);
6197     VARANDCY(I4,-1,0,I4,0);
6198     VARANDCY(I4,0,0,I4,0);
6199
6200     VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
6201     VARAND(UI4,0xffffffff,UI4,0,I4,0);
6202     VARAND(UI4,0,UI4,0,I4,0);
6203     VARAND(UI4,0xffffffff,R4,-1,I4,-1);
6204     VARAND(UI4,0xffffffff,R4,0,I4,0);
6205     VARAND(UI4,0,R4,0,I4,0);
6206     VARAND(UI4,0xffffffff,R8,-1,I4,-1);
6207     VARAND(UI4,0xffffffff,R8,0,I4,0);
6208     VARAND(UI4,0,R8,0,I4,0);
6209     VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
6210     VARAND(UI4,0xffffffff,DATE,0,I4,0);
6211     VARAND(UI4,0,DATE,0,I4,0);
6212     if (HAVE_OLEAUT32_I8)
6213     {
6214         VARAND(UI4,0xffffffff,I8,0,I8,0);
6215         VARAND(UI4,0,I8,0,I8,0);
6216         VARAND(UI4,0xffffffff,UI8,0,I4,0);
6217         VARAND(UI4,0,UI8,0,I4,0);
6218     }
6219     VARAND(UI4,0xffffffff,INT,-1,I4,-1);
6220     VARAND(UI4,0xffffffff,INT,0,I4,0);
6221     VARAND(UI4,0,INT,0,I4,0);
6222     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
6223     VARAND(UI4,0xffffffff,UINT,0,I4,0);
6224     VARAND(UI4,0,UINT,0,I4,0);
6225     VARAND(UI4,0,BSTR,false_str,I4,0);
6226     VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
6227     VARAND(UI4,0,BSTR,true_str,I4,0);
6228     VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
6229     VARANDCY(UI4,0xffffffff,10000,I4,1);
6230     VARANDCY(UI4,0xffffffff,0,I4,0);
6231     VARANDCY(UI4,0,0,I4,0);
6232
6233     VARAND(R4,-1,R4,-1,I4,-1);
6234     VARAND(R4,-1,R4,0,I4,0);
6235     VARAND(R4,0,R4,0,I4,0);
6236     VARAND(R4,-1,R8,-1,I4,-1);
6237     VARAND(R4,-1,R8,0,I4,0);
6238     VARAND(R4,0,R8,0,I4,0);
6239     VARAND(R4,-1,DATE,-1,I4,-1);
6240     VARAND(R4,-1,DATE,0,I4,0);
6241     VARAND(R4,0,DATE,0,I4,0);
6242     if (HAVE_OLEAUT32_I8)
6243     {
6244         VARAND(R4,-1,I8,-1,I8,-1);
6245         VARAND(R4,-1,I8,0,I8,0);
6246         VARAND(R4,0,I8,0,I8,0);
6247         VARAND(R4,-1,UI8,0,I4,0);
6248         VARAND(R4,0,UI8,0,I4,0);
6249     }
6250     VARAND(R4,-1,INT,-1,I4,-1);
6251     VARAND(R4,-1,INT,0,I4,0);
6252     VARAND(R4,0,INT,0,I4,0);
6253     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
6254     VARAND(R4,-1,UINT,0,I4,0);
6255     VARAND(R4,0,UINT,0,I4,0);
6256     VARAND(R4,0,BSTR,false_str,I4,0);
6257     VARAND(R4,-1,BSTR,false_str,I4,0);
6258     VARAND(R4,0,BSTR,true_str,I4,0);
6259     VARAND(R4,-1,BSTR,true_str,I4,-1);
6260     VARANDCY(R4,-1,10000,I4,1);
6261     VARANDCY(R4,-1,0,I4,0);
6262     VARANDCY(R4,0,0,I4,0);
6263
6264     VARAND(R8,-1,R8,-1,I4,-1);
6265     VARAND(R8,-1,R8,0,I4,0);
6266     VARAND(R8,0,R8,0,I4,0);
6267     VARAND(R8,-1,DATE,-1,I4,-1);
6268     VARAND(R8,-1,DATE,0,I4,0);
6269     VARAND(R8,0,DATE,0,I4,0);
6270     if (HAVE_OLEAUT32_I8)
6271     {
6272         VARAND(R8,-1,I8,-1,I8,-1);
6273         VARAND(R8,-1,I8,0,I8,0);
6274         VARAND(R8,0,I8,0,I8,0);
6275         VARAND(R8,-1,UI8,0,I4,0);
6276         VARAND(R8,0,UI8,0,I4,0);
6277     }
6278     VARAND(R8,-1,INT,-1,I4,-1);
6279     VARAND(R8,-1,INT,0,I4,0);
6280     VARAND(R8,0,INT,0,I4,0);
6281     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
6282     VARAND(R8,-1,UINT,0,I4,0);
6283     VARAND(R8,0,UINT,0,I4,0);
6284     VARAND(R8,0,BSTR,false_str,I4,0);
6285     VARAND(R8,-1,BSTR,false_str,I4,0);
6286     VARAND(R8,0,BSTR,true_str,I4,0);
6287     VARAND(R8,-1,BSTR,true_str,I4,-1);
6288     VARANDCY(R8,-1,10000,I4,1);
6289     VARANDCY(R8,-1,0,I4,0);
6290     VARANDCY(R8,0,0,I4,0);
6291
6292     VARAND(DATE,-1,DATE,-1,I4,-1);
6293     VARAND(DATE,-1,DATE,0,I4,0);
6294     VARAND(DATE,0,DATE,0,I4,0);
6295     if (HAVE_OLEAUT32_I8)
6296     {
6297         VARAND(DATE,-1,I8,-1,I8,-1);
6298         VARAND(DATE,-1,I8,0,I8,0);
6299         VARAND(DATE,0,I8,0,I8,0);
6300         VARAND(DATE,-1,UI8,0,I4,0);
6301         VARAND(DATE,0,UI8,0,I4,0);
6302     }
6303     VARAND(DATE,-1,INT,-1,I4,-1);
6304     VARAND(DATE,-1,INT,0,I4,0);
6305     VARAND(DATE,0,INT,0,I4,0);
6306     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
6307     VARAND(DATE,-1,UINT,0,I4,0);
6308     VARAND(DATE,0,UINT,0,I4,0);
6309     VARAND(DATE,0,BSTR,false_str,I4,0);
6310     VARAND(DATE,-1,BSTR,false_str,I4,0);
6311     VARAND(DATE,0,BSTR,true_str,I4,0);
6312     VARAND(DATE,-1,BSTR,true_str,I4,-1);
6313     VARANDCY(DATE,-1,10000,I4,1);
6314     VARANDCY(DATE,-1,0,I4,0);
6315     VARANDCY(DATE,0,0,I4,0);
6316
6317     if (HAVE_OLEAUT32_I8)
6318     {
6319         VARAND(I8,-1,I8,-1,I8,-1);
6320         VARAND(I8,-1,I8,0,I8,0);
6321         VARAND(I8,0,I8,0,I8,0);
6322         VARAND(I8,-1,UI8,0,I8,0);
6323         VARAND(I8,0,UI8,0,I8,0);
6324         VARAND(I8,-1,UINT,0,I8,0);
6325         VARAND(I8,0,UINT,0,I8,0);
6326         VARAND(I8,0,BSTR,false_str,I8,0);
6327         VARAND(I8,-1,BSTR,false_str,I8,0);
6328         VARAND(I8,0,BSTR,true_str,I8,0);
6329         VARAND(I8,-1,BSTR,true_str,I8,-1);
6330         VARANDCY(I8,-1,10000,I8,1);
6331         VARANDCY(I8,-1,0,I8,0);
6332         VARANDCY(I8,0,0,I8,0);
6333
6334         VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
6335         VARAND(UI8,0xffff,UI8,0,I4,0);
6336         VARAND(UI8,0,UI8,0,I4,0);
6337         VARAND(UI8,0xffff,INT,-1,I4,65535);
6338         VARAND(UI8,0xffff,INT,0,I4,0);
6339         VARAND(UI8,0,INT,0,I4,0);
6340         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
6341         VARAND(UI8,0xffff,UINT,0,I4,0);
6342         VARAND(UI8,0,UINT,0,I4,0);
6343         VARAND(UI8,0,BSTR,false_str,I4,0);
6344         VARAND(UI8,0xffff,BSTR,false_str,I4,0);
6345         VARAND(UI8,0,BSTR,true_str,I4,0);
6346         VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
6347         VARANDCY(UI8,0xffff,10000,I4,1);
6348         VARANDCY(UI8,0xffff,0,I4,0);
6349         VARANDCY(UI8,0,0,I4,0);
6350     }
6351
6352     VARAND(INT,-1,INT,-1,I4,-1);
6353     VARAND(INT,-1,INT,0,I4,0);
6354     VARAND(INT,0,INT,0,I4,0);
6355     VARAND(INT,-1,UINT,0xffff,I4,65535);
6356     VARAND(INT,-1,UINT,0,I4,0);
6357     VARAND(INT,0,UINT,0,I4,0);
6358     VARAND(INT,0,BSTR,false_str,I4,0);
6359     VARAND(INT,-1,BSTR,false_str,I4,0);
6360     VARAND(INT,0,BSTR,true_str,I4,0);
6361     VARAND(INT,-1,BSTR,true_str,I4,-1);
6362     VARANDCY(INT,-1,10000,I4,1);
6363     VARANDCY(INT,-1,0,I4,0);
6364     VARANDCY(INT,0,0,I4,0);
6365
6366     VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
6367     VARAND(UINT,0xffff,UINT,0,I4,0);
6368     VARAND(UINT,0,UINT,0,I4,0);
6369     VARAND(UINT,0,BSTR,false_str,I4,0);
6370     VARAND(UINT,0xffff,BSTR, false_str,I4,0);
6371     VARAND(UINT,0,BSTR,true_str,I4,0);
6372     VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
6373     VARANDCY(UINT,0xffff,10000,I4,1);
6374     VARANDCY(UINT,0xffff,0,I4,0);
6375     VARANDCY(UINT,0,0,I4,0);
6376
6377     VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
6378     VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
6379     VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
6380     VARANDCY(BSTR,true_str,10000,I4,1);
6381     VARANDCY(BSTR,false_str,10000,I4,0);
6382
6383     SysFreeString(true_str);
6384     SysFreeString(false_str);
6385 }
6386
6387 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
6388 {
6389     HRESULT hres;
6390
6391     CHECKPTR(VarCmp);
6392
6393     hres = pVarCmp(left,right,lcid,flags);
6394     ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
6395                        variantstr(left), variantstr(right), result, hres );
6396 }
6397 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
6398                         HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
6399 {
6400     test_cmp( line, lcid, 0, left, right, res1 );
6401     V_VT(left) |= VT_RESERVED;
6402     test_cmp( line, lcid, 0, left, right, res2 );
6403     V_VT(left) &= ~VT_RESERVED;
6404     V_VT(right) |= VT_RESERVED;
6405     test_cmp( line, lcid, 0, left, right, res3 );
6406     V_VT(left) |= VT_RESERVED;
6407     test_cmp( line, lcid, 0, left, right, res4 );
6408     ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
6409 }
6410
6411 /* ERROR from wingdi.h is interfering here */
6412 #undef ERROR
6413 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
6414         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
6415         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
6416         test_cmp( __LINE__, lcid, flags, &left, &right, result )
6417 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
6418         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
6419         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
6420         test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
6421 #define VARCMP(vt1,val1,vt2,val2,result) \
6422         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
6423 /* The above macros do not work for VT_NULL as NULL gets expanded first */
6424 #define V_NULL_  V_NULL
6425 #define VT_NULL_ VT_NULL
6426
6427 static void test_VarCmp(void)
6428 {
6429     VARIANT left, right;
6430     VARTYPE i;
6431     LCID lcid;
6432     HRESULT hres;
6433     DECIMAL dec;
6434     static const WCHAR szhuh[] = {'h','u','h','?','\0'};
6435     static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
6436     static const WCHAR szempty[] = {'\0'};
6437     static const WCHAR sz0[] = {'0','\0'};
6438     static const WCHAR sz1[] = {'1','\0'};
6439     static const WCHAR sz7[] = {'7','\0'};
6440     static const WCHAR sz42[] = {'4','2','\0'};
6441     static const WCHAR sz1neg[] = {'-','1','\0'};
6442     static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
6443     static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
6444     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
6445     BSTR bstr2cents, bstr1few;
6446
6447     CHECKPTR(VarCmp);
6448
6449     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
6450     bstrempty = SysAllocString(szempty);
6451     bstrhuh = SysAllocString(szhuh);
6452     bstr2cents = SysAllocString(sz2cents);
6453     bstr0 = SysAllocString(sz0);
6454     bstr1 = SysAllocString(sz1);
6455     bstr7 = SysAllocString(sz7);
6456     bstr42 = SysAllocString(sz42);
6457     bstr1neg = SysAllocString(sz1neg);
6458     bstr666neg = SysAllocString(sz666neg);
6459     bstr1few = SysAllocString(sz1few);
6460
6461     /* Test all possible flag/vt combinations & the resulting vt type */
6462     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6463     {
6464         VARTYPE leftvt, rightvt;
6465
6466         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6467         {
6468
6469             SKIPTESTS(leftvt);
6470
6471             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6472             {
6473                 BOOL bFail = FALSE;
6474                 HRESULT expect = VARCMP_EQ;
6475
6476                 SKIPTESTS(rightvt);
6477
6478                 memset(&left, 0, sizeof(left));
6479                 memset(&right, 0, sizeof(right));
6480                 V_VT(&left) = leftvt | ExtraFlags[i];
6481                 if (leftvt == VT_BSTR) {
6482                     V_BSTR(&left) = bstr1neg;
6483                     if (ExtraFlags[i] & VT_RESERVED)
6484                         expect = VARCMP_LT;
6485                     else
6486                         expect = VARCMP_GT;
6487                 }
6488                 V_VT(&right) = rightvt | ExtraFlags[i];
6489                 if (rightvt == VT_BSTR) {
6490                     V_BSTR(&right) = bstr1neg;
6491                     if (ExtraFlags[i] & VT_RESERVED)
6492                         expect = VARCMP_GT;
6493                     else
6494                         expect = VARCMP_LT;
6495                 }
6496
6497                 /* Don't ask me why but native VarCmp cannot handle:
6498                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
6499                    VT_INT is only supported as left variant. Go figure.
6500                    Tested with DCOM98, Win2k, WinXP */
6501                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6502                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
6503                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
6504                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6505                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6506                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6507                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6508                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
6509                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6510                     leftvt == VT_I1 || rightvt == VT_I1 ||
6511                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6512                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6513                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6514                     rightvt == VT_INT ||
6515                     leftvt == VT_UINT || rightvt == VT_UINT) {
6516                     bFail = TRUE;
6517                 }
6518
6519                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
6520                     !(ExtraFlags[i] & ~VT_RESERVED)) {
6521                     expect = VARCMP_EQ;
6522                     bFail = FALSE;
6523                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
6524                     expect = VARCMP_NULL;
6525                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
6526                     expect = VARCMP_EQ;
6527                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
6528                     expect = VARCMP_GT;
6529                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
6530                     expect = VARCMP_LT;
6531
6532                 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
6533                 if (bFail) {
6534                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6535                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%X\n",
6536                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
6537                 } else {
6538                     ok(hres == expect,
6539                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%X, got 0x%X\n",
6540                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
6541                        hres);
6542                 }
6543             }
6544         }
6545     }
6546
6547     /* VARCMP{,EX} run each 4 tests with a permutation of all possible
6548        input variants with (1) and without (0) VT_RESERVED set. The order
6549        of the permutations is (0,0); (1,0); (0,1); (1,1) */
6550     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
6551     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
6552     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
6553     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
6554     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
6555     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
6556     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
6557     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
6558     VARCMP(I4,1,UI1,1,VARCMP_EQ);
6559     VARCMP(I2,2,I2,2,VARCMP_EQ);
6560     VARCMP(I2,1,I2,2,VARCMP_LT);
6561     VARCMP(I2,2,I2,1,VARCMP_GT);
6562     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
6563     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
6564
6565     /* BSTR handling, especially in conjunction with VT_RESERVED */
6566     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
6567     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
6568     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
6569     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
6570     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
6571     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
6572     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
6573     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
6574     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
6575     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
6576     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
6577     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
6578     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
6579     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
6580     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6581     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6582     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6583     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6584     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6585     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
6586     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6587     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6588     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
6589     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
6590     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6591     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
6592     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6593     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6594     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6595     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6596     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
6597     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6598     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
6599     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6600     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
6601     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6602     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6603     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6604     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6605     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6606     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6607     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6608     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6609     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6610     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6611     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6612     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6613     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6614     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6615     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6616     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6617     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6618     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
6619     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
6620     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
6621
6622     /* DECIMAL handling */
6623     setdec(&dec,0,0,0,0);
6624     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6625     setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
6626     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
6627     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
6628     setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
6629     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
6630     setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001);    /* 1+1e-20 */
6631     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
6632
6633     /* Show that DATE is handled just as a R8 */
6634     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
6635     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
6636     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
6637     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
6638     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
6639     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
6640     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
6641     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
6642     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
6643
6644     /* R4 precision handling */
6645     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
6646     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
6647     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
6648     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
6649     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
6650     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
6651     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
6652     setdec(&dec,8,0,0,0x5F5E101);         /* 1+1e-8 */
6653     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
6654
6655     SysFreeString(bstrhuh);
6656     SysFreeString(bstrempty);
6657     SysFreeString(bstr0);
6658     SysFreeString(bstr1);
6659     SysFreeString(bstr7);
6660     SysFreeString(bstr42);
6661     SysFreeString(bstr1neg);
6662     SysFreeString(bstr666neg);
6663     SysFreeString(bstr2cents);
6664     SysFreeString(bstr1few);
6665 }
6666
6667 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
6668
6669 #define VARPOW(vt1,val1,vt2,val2,rvt,rval)               \
6670         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6671         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6672         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6673         test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
6674
6675 /* Skip any type that is not defined or produces an error for every case */
6676 #define SKIPTESTPOW(a)                            \
6677     if (a == VT_ERROR || a == VT_VARIANT ||       \
6678         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
6679         a == VT_RECORD || a > VT_UINT ||          \
6680         a == 15 /*not defined*/)                  \
6681         continue
6682
6683 static void test_VarPow(void)
6684 {
6685     static const WCHAR str2[] = { '2','\0' };
6686     static const WCHAR str3[] = { '3','\0' };
6687     VARIANT left, right, exp, result, cy, dec;
6688     BSTR num2_str, num3_str;
6689     VARTYPE i;
6690     HRESULT hres;
6691
6692     CHECKPTR(VarPow);
6693
6694     num2_str = SysAllocString(str2);
6695     num3_str = SysAllocString(str3);
6696
6697     /* Test all possible flag/vt combinations & the resulting vt type */
6698     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6699     {
6700         VARTYPE leftvt, rightvt, resvt;
6701
6702         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6703         {
6704             SKIPTESTPOW(leftvt);
6705
6706             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6707             {
6708                 BOOL bFail = FALSE;
6709                 SKIPTESTPOW(rightvt);
6710
6711                 /* Native crashes with VT_BYREF */
6712                 if (ExtraFlags[i] == VT_BYREF)
6713                     continue;
6714
6715                 memset(&left, 0, sizeof(left));
6716                 memset(&right, 0, sizeof(right));
6717                 V_VT(&left) = leftvt | ExtraFlags[i];
6718                 V_VT(&right) = rightvt | ExtraFlags[i];
6719                 V_VT(&result) = VT_EMPTY;
6720                 resvt = VT_EMPTY;
6721
6722                 if (leftvt == VT_BSTR)
6723                     V_BSTR(&left) = num2_str;
6724                 if (rightvt == VT_BSTR)
6725                     V_BSTR(&right) = num2_str;
6726
6727                 /* Native VarPow always returns an error when using extra flags */
6728                 if (ExtraFlags[i] != 0)
6729                     bFail = TRUE;
6730
6731                 /* Determine return type */
6732                 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
6733                          ((leftvt != VT_I8 && leftvt != VT_UI8 &&
6734                            rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
6735                     resvt = VT_NULL;
6736                 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
6737                     leftvt == VT_I4 || leftvt == VT_R4 ||
6738                     leftvt == VT_R8 || leftvt == VT_CY ||
6739                     leftvt == VT_DATE || leftvt == VT_BSTR ||
6740                     leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
6741                     (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
6742                     (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
6743                     leftvt == VT_INT || leftvt == VT_UINT) &&
6744                     (rightvt == VT_EMPTY || rightvt == VT_I2 ||
6745                     rightvt == VT_I4 || rightvt == VT_R4 ||
6746                     rightvt == VT_R8 || rightvt == VT_CY ||
6747                     rightvt == VT_DATE || rightvt == VT_BSTR ||
6748                     rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
6749                     (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
6750                     (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
6751                     rightvt == VT_INT || rightvt == VT_UINT))
6752                     resvt = VT_R8;
6753                 else
6754                     bFail = TRUE;
6755
6756                 hres = pVarPow(&left, &right, &result);
6757
6758                 /* Check expected HRESULT and if result variant type is correct */
6759                 if (bFail)
6760                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6761                         "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
6762                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
6763                         vtstr(V_VT(&result)), hres);
6764                 else
6765                     ok (hres == S_OK && resvt == V_VT(&result),
6766                         "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
6767                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
6768                         S_OK, vtstr(V_VT(&result)), hres);
6769             }
6770         }
6771     }
6772
6773     /* Check return values for valid variant type combinations */
6774     VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
6775     VARPOW(EMPTY,0,NULL,0,NULL,0);
6776     VARPOW(EMPTY,0,I2,3,R8,0.0);
6777     VARPOW(EMPTY,0,I4,3,R8,0.0);
6778     VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
6779     VARPOW(EMPTY,0,R8,3.0,R8,0.0);
6780     VARPOW(EMPTY,0,DATE,3,R8,0.0);
6781     VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
6782     VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
6783     VARPOW(EMPTY,0,I1,3,R8,0.0);
6784     VARPOW(EMPTY,0,UI1,3,R8,0.0);
6785     VARPOW(EMPTY,0,UI2,3,R8,0.0);
6786     VARPOW(EMPTY,0,UI4,3,R8,0.0);
6787     if (HAVE_OLEAUT32_I8)
6788     {
6789         VARPOW(EMPTY,0,I8,3,R8,0.0);
6790         VARPOW(EMPTY,0,UI8,3,R8,0.0);
6791     }
6792     VARPOW(EMPTY,0,INT,3,R8,0.0);
6793     VARPOW(EMPTY,0,UINT,3,R8,0.0);
6794     VARPOW(NULL,0,EMPTY,0,NULL,0);
6795     VARPOW(NULL,0,NULL,0,NULL,0);
6796     VARPOW(NULL,0,I2,3,NULL,0);
6797     VARPOW(NULL,0,I4,3,NULL,0);
6798     VARPOW(NULL,0,R4,3.0f,NULL,0);
6799     VARPOW(NULL,0,R8,3.0,NULL,0);
6800     VARPOW(NULL,0,DATE,3,NULL,0);
6801     VARPOW(NULL,0,BSTR,num3_str,NULL,0);
6802     VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
6803     VARPOW(NULL,0,I1,3,NULL,0);
6804     VARPOW(NULL,0,UI1,3,NULL,0);
6805     VARPOW(NULL,0,UI2,3,NULL,0);
6806     VARPOW(NULL,0,UI4,3,NULL,0);
6807     if (HAVE_OLEAUT32_I8)
6808     {
6809         VARPOW(NULL,0,I8,3,NULL,0);
6810         VARPOW(NULL,0,UI8,3,NULL,0);
6811     }
6812     VARPOW(NULL,0,INT,3,NULL,0);
6813     VARPOW(NULL,0,UINT,3,NULL,0);
6814     VARPOW(I2,2,EMPTY,0,R8,1.0);
6815     VARPOW(I2,2,NULL,0,NULL,0);
6816     VARPOW(I2,2,I2,3,R8,8.0);
6817     VARPOW(I2,2,I4,3,R8,8.0);
6818     VARPOW(I2,2,R4,3.0f,R8,8.0);
6819     VARPOW(I2,2,R8,3.0,R8,8.0);
6820     VARPOW(I2,2,DATE,3,R8,8.0);
6821     VARPOW(I2,2,BSTR,num3_str,R8,8.0);
6822     VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
6823     VARPOW(I2,2,I1,3,R8,8.0);
6824     VARPOW(I2,2,UI1,3,R8,8.0);
6825     VARPOW(I2,2,UI2,3,R8,8.0);
6826     VARPOW(I2,2,UI4,3,R8,8.0);
6827     if (HAVE_OLEAUT32_I8)
6828     {
6829         VARPOW(I2,2,I8,3,R8,8.0);
6830         VARPOW(I2,2,UI8,3,R8,8.0);
6831     }
6832     VARPOW(I2,2,INT,3,R8,8.0);
6833     VARPOW(I2,2,UINT,3,R8,8.0);
6834     VARPOW(I4,2,EMPTY,0,R8,1.0);
6835     VARPOW(I4,2,NULL,0,NULL,0);
6836     VARPOW(I4,2,I2,3,R8,8.0);
6837     VARPOW(I4,2,I4,3,R8,8.0);
6838     VARPOW(I4,2,R4,3.0f,R8,8.0);
6839     VARPOW(I4,2,R8,3.0,R8,8.0);
6840     VARPOW(I4,2,DATE,3,R8,8.0);
6841     VARPOW(I4,2,BSTR,num3_str,R8,8.0);
6842     VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
6843     VARPOW(I4,2,I1,3,R8,8.0);
6844     VARPOW(I4,2,UI1,3,R8,8.0);
6845     VARPOW(I4,2,UI2,3,R8,8.0);
6846     VARPOW(I4,2,UI4,3,R8,8.0);
6847     if (HAVE_OLEAUT32_I8)
6848     {
6849         VARPOW(I4,2,I8,3,R8,8.0);
6850         VARPOW(I4,2,UI8,3,R8,8.0);
6851     }
6852     VARPOW(I4,2,INT,3,R8,8.0);
6853     VARPOW(I4,2,UINT,3,R8,8.0);
6854     VARPOW(R4,2,EMPTY,0,R8,1.0);
6855     VARPOW(R4,2,NULL,0,NULL,0);
6856     VARPOW(R4,2,I2,3,R8,8.0);
6857     VARPOW(R4,2,I4,3,R8,8.0);
6858     VARPOW(R4,2,R4,3.0f,R8,8.0);
6859     VARPOW(R4,2,R8,3.0,R8,8.0);
6860     VARPOW(R4,2,DATE,3,R8,8.0);
6861     VARPOW(R4,2,BSTR,num3_str,R8,8.0);
6862     VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
6863     VARPOW(R4,2,I1,3,R8,8.0);
6864     VARPOW(R4,2,UI1,3,R8,8.0);
6865     VARPOW(R4,2,UI2,3,R8,8.0);
6866     VARPOW(R4,2,UI4,3,R8,8.0);
6867     if (HAVE_OLEAUT32_I8)
6868     {
6869         VARPOW(R4,2,I8,3,R8,8.0);
6870         VARPOW(R4,2,UI8,3,R8,8.0);
6871     }
6872     VARPOW(R4,2,INT,3,R8,8.0);
6873     VARPOW(R4,2,UINT,3,R8,8.0);
6874     VARPOW(R8,2,EMPTY,0,R8,1.0);
6875     VARPOW(R8,2,NULL,0,NULL,0);
6876     VARPOW(R8,2,I2,3,R8,8.0);
6877     VARPOW(R8,2,I4,3,R8,8.0);
6878     VARPOW(R8,2,R4,3.0f,R8,8.0);
6879     VARPOW(R8,2,R8,3.0,R8,8.0);
6880     VARPOW(R8,2,DATE,3,R8,8.0);
6881     VARPOW(R8,2,BSTR,num3_str,R8,8.0);
6882     VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
6883     VARPOW(R8,2,I1,3,R8,8.0);
6884     VARPOW(R8,2,UI1,3,R8,8.0);
6885     VARPOW(R8,2,UI2,3,R8,8.0);
6886     VARPOW(R8,2,UI4,3,R8,8.0);
6887     if (HAVE_OLEAUT32_I8)
6888     {
6889         VARPOW(R8,2,I8,3,R8,8.0);
6890         VARPOW(R8,2,UI8,3,R8,8.0);
6891     }
6892     VARPOW(R8,2,INT,3,R8,8.0);
6893     VARPOW(R8,2,UINT,3,R8,8.0);
6894     VARPOW(DATE,2,EMPTY,0,R8,1.0);
6895     VARPOW(DATE,2,NULL,0,NULL,0);
6896     VARPOW(DATE,2,I2,3,R8,8.0);
6897     VARPOW(DATE,2,I4,3,R8,8.0);
6898     VARPOW(DATE,2,R4,3.0f,R8,8.0);
6899     VARPOW(DATE,2,R8,3.0,R8,8.0);
6900     VARPOW(DATE,2,DATE,3,R8,8.0);
6901     VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
6902     VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
6903     VARPOW(DATE,2,I1,3,R8,8.0);
6904     VARPOW(DATE,2,UI1,3,R8,8.0);
6905     VARPOW(DATE,2,UI2,3,R8,8.0);
6906     VARPOW(DATE,2,UI4,3,R8,8.0);
6907     if (HAVE_OLEAUT32_I8)
6908     {
6909         VARPOW(DATE,2,I8,3,R8,8.0);
6910         VARPOW(DATE,2,UI8,3,R8,8.0);
6911     }
6912     VARPOW(DATE,2,INT,3,R8,8.0);
6913     VARPOW(DATE,2,UINT,3,R8,8.0);
6914     VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
6915     VARPOW(BSTR,num2_str,NULL,0,NULL,0);
6916     VARPOW(BSTR,num2_str,I2,3,R8,8.0);
6917     VARPOW(BSTR,num2_str,I4,3,R8,8.0);
6918     VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
6919     VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
6920     VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
6921     VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
6922     VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
6923     VARPOW(BSTR,num2_str,I1,3,R8,8.0);
6924     VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
6925     VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
6926     VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
6927     if (HAVE_OLEAUT32_I8)
6928     {
6929         VARPOW(BSTR,num2_str,I8,3,R8,8.0);
6930         VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
6931     }
6932     VARPOW(BSTR,num2_str,INT,3,R8,8.0);
6933     VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
6934     VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
6935     VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
6936     VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
6937     VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
6938     VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
6939     VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
6940     VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
6941     VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
6942     VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
6943     VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
6944     VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
6945     VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
6946     VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
6947     if (HAVE_OLEAUT32_I8)
6948     {
6949         VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
6950         VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
6951     }
6952     VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
6953     VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
6954     VARPOW(I1,2,EMPTY,0,R8,1.0);
6955     VARPOW(I1,2,NULL,0,NULL,0);
6956     VARPOW(I1,2,I2,3,R8,8.0);
6957     VARPOW(I1,2,I4,3,R8,8.0);
6958     VARPOW(I1,2,R4,3.0f,R8,8.0);
6959     VARPOW(I1,2,R8,3.0,R8,8.0);
6960     VARPOW(I1,2,DATE,3,R8,8.0);
6961     VARPOW(I1,2,BSTR,num3_str,R8,8.0);
6962     VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
6963     VARPOW(I1,2,I1,3,R8,8.0);
6964     VARPOW(I1,2,UI1,3,R8,8.0);
6965     VARPOW(I1,2,UI2,3,R8,8.0);
6966     VARPOW(I1,2,UI4,3,R8,8.0);
6967     if (HAVE_OLEAUT32_I8)
6968     {
6969         VARPOW(I1,2,I8,3,R8,8.0);
6970         VARPOW(I1,2,UI8,3,R8,8.0);
6971     }
6972     VARPOW(I1,2,INT,3,R8,8.0);
6973     VARPOW(I1,2,UINT,3,R8,8.0);
6974     VARPOW(UI1,2,EMPTY,0,R8,1.0);
6975     VARPOW(UI1,2,NULL,0,NULL,0);
6976     VARPOW(UI1,2,I2,3,R8,8.0);
6977     VARPOW(UI1,2,I4,3,R8,8.0);
6978     VARPOW(UI1,2,R4,3.0f,R8,8.0);
6979     VARPOW(UI1,2,R8,3.0,R8,8.0);
6980     VARPOW(UI1,2,DATE,3,R8,8.0);
6981     VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
6982     VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
6983     VARPOW(UI1,2,I1,3,R8,8.0);
6984     VARPOW(UI1,2,UI1,3,R8,8.0);
6985     VARPOW(UI1,2,UI2,3,R8,8.0);
6986     VARPOW(UI1,2,UI4,3,R8,8.0);
6987     if (HAVE_OLEAUT32_I8)
6988     {
6989         VARPOW(UI1,2,I8,3,R8,8.0);
6990         VARPOW(UI1,2,UI8,3,R8,8.0);
6991     }
6992     VARPOW(UI1,2,INT,3,R8,8.0);
6993     VARPOW(UI1,2,UINT,3,R8,8.0);
6994     VARPOW(UI2,2,EMPTY,0,R8,1.0);
6995     VARPOW(UI2,2,NULL,0,NULL,0);
6996     VARPOW(UI2,2,I2,3,R8,8.0);
6997     VARPOW(UI2,2,I4,3,R8,8.0);
6998     VARPOW(UI2,2,R4,3.0f,R8,8.0);
6999     VARPOW(UI2,2,R8,3.0,R8,8.0);
7000     VARPOW(UI2,2,DATE,3,R8,8.0);
7001     VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
7002     VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
7003     VARPOW(UI2,2,I1,3,R8,8.0);
7004     VARPOW(UI2,2,UI1,3,R8,8.0);
7005     VARPOW(UI2,2,UI2,3,R8,8.0);
7006     VARPOW(UI2,2,UI4,3,R8,8.0);
7007     if (HAVE_OLEAUT32_I8)
7008     {
7009         VARPOW(UI2,2,I8,3,R8,8.0);
7010         VARPOW(UI2,2,UI8,3,R8,8.0);
7011     }
7012     VARPOW(UI2,2,INT,3,R8,8.0);
7013     VARPOW(UI2,2,UINT,3,R8,8.0);
7014     VARPOW(UI4,2,EMPTY,0,R8,1.0);
7015     VARPOW(UI4,2,NULL,0,NULL,0);
7016     VARPOW(UI4,2,I2,3,R8,8.0);
7017     VARPOW(UI4,2,I4,3,R8,8.0);
7018     VARPOW(UI4,2,R4,3.0f,R8,8.0);
7019     VARPOW(UI4,2,R8,3.0,R8,8.0);
7020     VARPOW(UI4,2,DATE,3,R8,8.0);
7021     VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
7022     VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
7023     VARPOW(UI4,2,I1,3,R8,8.0);
7024     VARPOW(UI4,2,UI1,3,R8,8.0);
7025     VARPOW(UI4,2,UI2,3,R8,8.0);
7026     VARPOW(UI4,2,UI4,3,R8,8.0);
7027     if (HAVE_OLEAUT32_I8)
7028     {
7029         VARPOW(UI4,2,I8,3,R8,8.0);
7030         VARPOW(UI4,2,UI8,3,R8,8.0);
7031     }
7032     VARPOW(UI4,2,INT,3,R8,8.0);
7033     VARPOW(UI4,2,UINT,3,R8,8.0);
7034     if (HAVE_OLEAUT32_I8)
7035     {
7036         VARPOW(I8,2,EMPTY,0,R8,1.0);
7037         VARPOW(I8,2,NULL,0,NULL,0);
7038         VARPOW(I8,2,I2,3,R8,8.0);
7039         VARPOW(I8,2,I4,3,R8,8.0);
7040         VARPOW(I8,2,R4,3.0f,R8,8.0);
7041         VARPOW(I8,2,R8,3.0,R8,8.0);
7042         VARPOW(I8,2,DATE,3,R8,8.0);
7043         VARPOW(I8,2,BSTR,num3_str,R8,8.0);
7044         VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
7045         VARPOW(I8,2,I1,3,R8,8.0);
7046         VARPOW(I8,2,UI1,3,R8,8.0);
7047         VARPOW(I8,2,UI2,3,R8,8.0);
7048         VARPOW(I8,2,UI4,3,R8,8.0);
7049         VARPOW(I8,2,I8,3,R8,8.0);
7050         VARPOW(I8,2,UI8,3,R8,8.0);
7051         VARPOW(I8,2,INT,3,R8,8.0);
7052         VARPOW(I8,2,UINT,3,R8,8.0);
7053         VARPOW(UI8,2,EMPTY,0,R8,1.0);
7054         VARPOW(UI8,2,NULL,0,NULL,0);
7055         VARPOW(UI8,2,I2,3,R8,8.0);
7056         VARPOW(UI8,2,I4,3,R8,8.0);
7057         VARPOW(UI8,2,R4,3.0f,R8,8.0);
7058         VARPOW(UI8,2,R8,3.0,R8,8.0);
7059         VARPOW(UI8,2,DATE,3,R8,8.0);
7060         VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
7061         VARPOW(UI8,2,I1,3,R8,8.0);
7062         VARPOW(UI8,2,UI1,3,R8,8.0);
7063         VARPOW(UI8,2,UI2,3,R8,8.0);
7064         VARPOW(UI8,2,UI4,3,R8,8.0);
7065         VARPOW(UI8,2,I8,3,R8,8.0);
7066         VARPOW(UI8,2,UI8,3,R8,8.0);
7067         VARPOW(UI8,2,INT,3,R8,8.0);
7068         VARPOW(UI8,2,UINT,3,R8,8.0);
7069     }
7070     VARPOW(INT,2,EMPTY,0,R8,1.0);
7071     VARPOW(INT,2,NULL,0,NULL,0);
7072     VARPOW(INT,2,I2,3,R8,8.0);
7073     VARPOW(INT,2,I4,3,R8,8.0);
7074     VARPOW(INT,2,R4,3.0f,R8,8.0);
7075     VARPOW(INT,2,R8,3.0,R8,8.0);
7076     VARPOW(INT,2,DATE,3,R8,8.0);
7077     VARPOW(INT,2,BSTR,num3_str,R8,8.0);
7078     VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
7079     VARPOW(INT,2,I1,3,R8,8.0);
7080     VARPOW(INT,2,UI1,3,R8,8.0);
7081     VARPOW(INT,2,UI2,3,R8,8.0);
7082     VARPOW(INT,2,UI4,3,R8,8.0);
7083     if (HAVE_OLEAUT32_I8)
7084     {
7085         VARPOW(INT,2,I8,3,R8,8.0);
7086         VARPOW(INT,2,UI8,3,R8,8.0);
7087     }
7088     VARPOW(INT,2,INT,3,R8,8.0);
7089     VARPOW(INT,2,UINT,3,R8,8.0);
7090     VARPOW(UINT,2,EMPTY,0,R8,1.0);
7091     VARPOW(UINT,2,NULL,0,NULL,0);
7092     VARPOW(UINT,2,I2,3,R8,8.0);
7093     VARPOW(UINT,2,I4,3,R8,8.0);
7094     VARPOW(UINT,2,R4,3.0f,R8,8.0);
7095     VARPOW(UINT,2,R8,3.0,R8,8.0);
7096     VARPOW(UINT,2,DATE,3,R8,8.0);
7097     VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
7098     VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
7099     VARPOW(UINT,2,I1,3,R8,8.0);
7100     VARPOW(UINT,2,UI1,3,R8,8.0);
7101     VARPOW(UINT,2,UI2,3,R8,8.0);
7102     VARPOW(UINT,2,UI4,3,R8,8.0);
7103     if (HAVE_OLEAUT32_I8)
7104     {
7105         VARPOW(UINT,2,I8,3,R8,8.0);
7106         VARPOW(UINT,2,UI8,3,R8,8.0);
7107     }
7108     VARPOW(UINT,2,INT,3,R8,8.0);
7109     VARPOW(UINT,2,UINT,3,R8,8.0);
7110
7111     /* Manually test some VT_CY, VT_DECIMAL variants */
7112     V_VT(&cy) = VT_CY;
7113     hres = VarCyFromI4(2, &V_CY(&cy));
7114     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7115     V_VT(&dec) = VT_DECIMAL;
7116     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7117     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7118     memset(&left, 0, sizeof(left));
7119     memset(&right, 0, sizeof(right));
7120     V_VT(&left) = VT_I4;
7121     V_I4(&left) = 100;
7122     V_VT(&right) = VT_I8;
7123     V_UI1(&right) = 2;
7124
7125     hres = pVarPow(&cy, &cy, &result);
7126     ok(hres == S_OK && V_VT(&result) == VT_R8,
7127         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7128         S_OK, hres, vtstr(V_VT(&result)));
7129     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7130         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7131
7132     hres = pVarPow(&cy, &right, &result);
7133     if (hres == S_OK)
7134     {
7135         ok(hres == S_OK && V_VT(&result) == VT_R8,
7136            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7137            S_OK, hres, vtstr(V_VT(&result)));
7138         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7139            "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7140     }
7141     else
7142     {
7143         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7144            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7145            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7146     }
7147
7148     hres = pVarPow(&left, &cy, &result);
7149     ok(hres == S_OK && V_VT(&result) == VT_R8,
7150         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7151         S_OK, hres, vtstr(V_VT(&result)));
7152     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
7153         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
7154
7155     hres = pVarPow(&left, &dec, &result);
7156     ok(hres == S_OK && V_VT(&result) == VT_R8,
7157         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7158         S_OK, hres, vtstr(V_VT(&result)));
7159     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
7160         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
7161
7162     hres = pVarPow(&dec, &dec, &result);
7163     ok(hres == S_OK && V_VT(&result) == VT_R8,
7164         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7165         S_OK, hres, vtstr(V_VT(&result)));
7166     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7167         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7168
7169     hres = pVarPow(&dec, &right, &result);
7170     if (hres == S_OK)
7171     {
7172         ok(hres == S_OK && V_VT(&result) == VT_R8,
7173            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7174            S_OK, hres, vtstr(V_VT(&result)));
7175         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7176            "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7177     }
7178     else
7179     {
7180         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7181            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7182            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7183     }
7184
7185     SysFreeString(num2_str);
7186     SysFreeString(num3_str);
7187 }
7188
7189 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7190
7191 #define VARDIV(vt1,val1,vt2,val2,rvt,rval)               \
7192         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7193         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7194         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7195         test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
7196
7197 /* Skip any type that is not defined or produces an error for every case */
7198 #define SKIPTESTDIV(a)                            \
7199     if (a == VT_ERROR || a == VT_VARIANT ||       \
7200         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7201         a == VT_RECORD || a > VT_UINT ||          \
7202         a == VT_I1 || a == VT_UI8 ||              \
7203         a == VT_INT || a == VT_UINT ||            \
7204         a == VT_UI2 || a == VT_UI4 ||             \
7205         a == 15 /*not defined*/)                  \
7206         continue
7207
7208 static void test_VarDiv(void)
7209 {
7210     static const WCHAR str1[] = { '1','\0' };
7211     static const WCHAR str2[] = { '2','\0' };
7212     VARIANT left, right, exp, result, cy, dec;
7213     BSTR num1_str, num2_str;
7214     VARTYPE i;
7215     HRESULT hres;
7216     double r;
7217
7218     num1_str = SysAllocString(str1);
7219     num2_str = SysAllocString(str2);
7220
7221     CHECKPTR(VarDiv);
7222
7223     /* Test all possible flag/vt combinations & the resulting vt type */
7224     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7225     {
7226         VARTYPE leftvt, rightvt, resvt;
7227
7228         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7229         {
7230             SKIPTESTDIV(leftvt);
7231
7232             /* Check if we need/have support for I8 */
7233             if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
7234                 continue;
7235
7236             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7237             {
7238                 BOOL bFail = FALSE;
7239                 SKIPTESTDIV(rightvt);
7240
7241                 /* Check if we need/have support for I8 */
7242                 if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
7243                     continue;
7244
7245                 /* Native crashes with VT_BYREF */
7246                 if (ExtraFlags[i] == VT_BYREF)
7247                     continue;
7248
7249                 memset(&left, 0, sizeof(left));
7250                 memset(&right, 0, sizeof(right));
7251                 V_VT(&left) = leftvt | ExtraFlags[i];
7252                 V_VT(&right) = rightvt | ExtraFlags[i];
7253                 V_VT(&result) = VT_EMPTY;
7254                 resvt = VT_EMPTY;
7255
7256                 if (leftvt == VT_BSTR)
7257                     V_BSTR(&left) = num2_str;
7258                 else if (leftvt == VT_DECIMAL)
7259                 {
7260                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7261                     V_VT(&left) = leftvt | ExtraFlags[i];
7262                 }
7263
7264                 /* Division by 0 is undefined */
7265                 switch(rightvt)
7266                 {
7267                 case VT_BSTR:
7268                     V_BSTR(&right) = num2_str;
7269                     break;
7270                 case VT_DECIMAL:
7271                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7272                     V_VT(&right) = rightvt | ExtraFlags[i];
7273                     break;
7274                 case VT_BOOL:
7275                     V_BOOL(&right) = VARIANT_TRUE;
7276                     break;
7277                 case VT_I2: V_I2(&right) = 2; break;
7278                 case VT_I4: V_I4(&right) = 2; break;
7279                 case VT_R4: V_R4(&right) = 2.0f; break;
7280                 case VT_R8: V_R8(&right) = 2.0; break;
7281                 case VT_CY: V_CY(&right).int64 = 2; break;
7282                 case VT_DATE: V_DATE(&right) = 2; break;
7283                 case VT_UI1: V_UI1(&right) = 2; break;
7284                 case VT_I8: V_I8(&right) = 2; break;
7285                 default: break;
7286                 }
7287
7288                 /* Determine return type */
7289                 if (!(rightvt == VT_EMPTY))
7290                 {
7291                     if (leftvt == VT_NULL || rightvt == VT_NULL)
7292                         resvt = VT_NULL;
7293                     else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
7294                         resvt = VT_DECIMAL;
7295                     else if (leftvt == VT_I8 || rightvt == VT_I8 ||
7296                         leftvt == VT_CY || rightvt == VT_CY ||
7297                         leftvt == VT_DATE || rightvt == VT_DATE ||
7298                         leftvt == VT_I4 || rightvt == VT_I4 ||
7299                         leftvt == VT_BSTR || rightvt == VT_BSTR ||
7300                         leftvt == VT_I2 || rightvt == VT_I2 ||
7301                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
7302                         leftvt == VT_R8 || rightvt == VT_R8 ||
7303                         leftvt == VT_UI1 || rightvt == VT_UI1)
7304                     {
7305                         if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
7306                             (leftvt == VT_R4 && rightvt == VT_UI1))
7307                             resvt = VT_R4;
7308                         else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
7309                             rightvt == VT_I2)) || (rightvt == VT_R4 &&
7310                             (leftvt == VT_BOOL || leftvt == VT_I2)))
7311                             resvt = VT_R4;
7312                         else
7313                             resvt = VT_R8;
7314                     }
7315                     else if (leftvt == VT_R4 || rightvt == VT_R4)
7316                         resvt = VT_R4;
7317                 }
7318                 else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
7319                     resvt = VT_NULL;
7320                 else
7321                     bFail = TRUE;
7322
7323                 /* Native VarDiv always returns an error when using extra flags */
7324                 if (ExtraFlags[i] != 0)
7325                     bFail = TRUE;
7326
7327                 hres = pVarDiv(&left, &right, &result);
7328
7329                 /* Check expected HRESULT and if result variant type is correct */
7330                 if (bFail)
7331                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7332                         hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
7333                         "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7334                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7335                         vtstr(V_VT(&result)), hres);
7336                 else
7337                     ok (hres == S_OK && resvt == V_VT(&result),
7338                         "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7339                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7340                         S_OK, vtstr(V_VT(&result)), hres);
7341             }
7342         }
7343     }
7344
7345     /* Test return values for all the good cases */
7346     VARDIV(EMPTY,0,NULL,0,NULL,0);
7347     VARDIV(EMPTY,0,I2,2,R8,0.0);
7348     VARDIV(EMPTY,0,I4,2,R8,0.0);
7349     VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
7350     VARDIV(EMPTY,0,R8,2.0,R8,0.0);
7351     VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
7352     VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
7353     VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
7354     VARDIV(EMPTY,0,UI1,2,R8,0.0);
7355     if (HAVE_OLEAUT32_I8)
7356     {
7357         VARDIV(EMPTY,0,I8,2,R8,0.0);
7358     }
7359     VARDIV(NULL,0,EMPTY,0,NULL,0);
7360     VARDIV(NULL,0,NULL,0,NULL,0);
7361     VARDIV(NULL,0,I2,2,NULL,0);
7362     VARDIV(NULL,0,I4,2,NULL,0);
7363     VARDIV(NULL,0,R4,2.0f,NULL,0);
7364     VARDIV(NULL,0,R8,2.0,NULL,0);
7365     VARDIV(NULL,0,DATE,2,NULL,0);
7366     VARDIV(NULL,0,BSTR,num2_str,NULL,0);
7367     VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7368     VARDIV(NULL,0,UI1,2,NULL,0);
7369     if (HAVE_OLEAUT32_I8)
7370     {
7371         VARDIV(NULL,0,I8,2,NULL,0);
7372     }
7373     VARDIV(I2,2,NULL,0,NULL,0);
7374     VARDIV(I2,1,I2,2,R8,0.5);
7375     VARDIV(I2,1,I4,2,R8,0.5);
7376     VARDIV(I2,1,R4,2,R4,0.5f);
7377     VARDIV(I2,1,R8,2.0,R8,0.5);
7378     VARDIV(I2,1,DATE,2,R8,0.5);
7379     VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
7380     VARDIV(I2,1,UI1,2,R8,0.5);
7381     if (HAVE_OLEAUT32_I8)
7382     {
7383         VARDIV(I2,1,I8,2,R8,0.5);
7384     }
7385     VARDIV(I4,1,NULL,0,NULL,0);
7386     VARDIV(I4,1,I2,2,R8,0.5);
7387     VARDIV(I4,1,I4,2,R8,0.5);
7388     VARDIV(I4,1,R4,2.0f,R8,0.5);
7389     VARDIV(I4,1,R8,2.0,R8,0.5);
7390     VARDIV(I4,1,DATE,2,R8,0.5);
7391     VARDIV(I4,1,BSTR,num2_str,R8,0.5);
7392     VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
7393     VARDIV(I4,1,UI1,2,R8,0.5);
7394     if (HAVE_OLEAUT32_I8)
7395     {
7396         VARDIV(I4,1,I8,2,R8,0.5);
7397     }
7398     VARDIV(R4,1.0f,NULL,0,NULL,0);
7399     VARDIV(R4,1.0f,I2,2,R4,0.5f);
7400     VARDIV(R4,1.0f,I4,2,R8,0.5);
7401     VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
7402     VARDIV(R4,1.0f,R8,2.0,R8,0.5);
7403     VARDIV(R4,1.0f,DATE,2,R8,0.5);
7404     VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
7405     VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
7406     VARDIV(R4,1.0f,UI1,2,R4,0.5f);
7407     if (HAVE_OLEAUT32_I8)
7408     {
7409         VARDIV(R4,1.0f,I8,2,R8,0.5);
7410     }
7411     VARDIV(R8,1.0,NULL,0,NULL,0);
7412     VARDIV(R8,1.0,I2,2,R8,0.5);
7413     VARDIV(R8,1.0,I4,2,R8,0.5);
7414     VARDIV(R8,1.0,R4,2.0f,R8,0.5);
7415     VARDIV(R8,1.0,R8,2.0,R8,0.5);
7416     VARDIV(R8,1.0,DATE,2,R8,0.5);
7417     VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
7418     VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
7419     VARDIV(R8,1.0,UI1,2,R8,0.5);
7420     if (HAVE_OLEAUT32_I8)
7421     {
7422         VARDIV(R8,1.0,I8,2,R8,0.5);
7423     }
7424     VARDIV(DATE,1,NULL,0,NULL,0);
7425     VARDIV(DATE,1,I2,2,R8,0.5);
7426     VARDIV(DATE,1,I4,2,R8,0.5);
7427     VARDIV(DATE,1,R4,2.0f,R8,0.5);
7428     VARDIV(DATE,1,R8,2.0,R8,0.5);
7429     VARDIV(DATE,1,DATE,2,R8,0.5);
7430     VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
7431     VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
7432     VARDIV(DATE,1,UI1,2,R8,0.5);
7433     if (HAVE_OLEAUT32_I8)
7434     {
7435         VARDIV(DATE,1,I8,2,R8,0.5);
7436     }
7437     VARDIV(BSTR,num1_str,NULL,0,NULL,0);
7438     VARDIV(BSTR,num1_str,I2,2,R8,0.5);
7439     VARDIV(BSTR,num1_str,I4,2,R8,0.5);
7440     VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
7441     VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
7442     VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
7443     VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
7444     VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
7445     VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
7446     if (HAVE_OLEAUT32_I8)
7447     {
7448         VARDIV(BSTR,num1_str,I8,2,R8,0.5);
7449     }
7450     VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7451     VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
7452     VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
7453     VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
7454     VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
7455     VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
7456     VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
7457     VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
7458     VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
7459     VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
7460     VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
7461     VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
7462     VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
7463     VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
7464     if (HAVE_OLEAUT32_I8)
7465     {
7466         VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
7467     }
7468     VARDIV(UI1,1,NULL,0,NULL,0);
7469     VARDIV(UI1,1,I2,2,R8,0.5);
7470     VARDIV(UI1,1,I4,2,R8,0.5);
7471     VARDIV(UI1,1,R4,2.0f,R4,0.5f);
7472     VARDIV(UI1,1,R8,2.0,R8,0.5);
7473     VARDIV(UI1,1,DATE,2,R8,0.5);
7474     VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
7475     VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
7476     VARDIV(UI1,1,UI1,2,R8,0.5);
7477     if (HAVE_OLEAUT32_I8)
7478     {
7479         VARDIV(UI1,1,I8,2,R8,0.5);
7480         VARDIV(I8,1,NULL,0,NULL,0);
7481         VARDIV(I8,1,I2,2,R8,0.5);
7482         VARDIV(I8,1,I4,2,R8,0.5);
7483         VARDIV(I8,1,R4,2.0f,R8,0.5);
7484         VARDIV(I8,1,R8,2.0,R8,0.5);
7485         VARDIV(I8,1,DATE,2,R8,0.5);
7486         VARDIV(I8,1,BSTR,num2_str,R8,0.5);
7487         VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
7488         VARDIV(I8,1,UI1,2,R8,0.5);
7489         VARDIV(I8,1,I8,2,R8,0.5);
7490     }
7491
7492     /* Manually test some VT_CY, VT_DECIMAL variants */
7493     V_VT(&cy) = VT_CY;
7494     hres = VarCyFromI4(10000, &V_CY(&cy));
7495     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7496     V_VT(&dec) = VT_DECIMAL;
7497     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7498     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7499     memset(&left, 0, sizeof(left));
7500     memset(&right, 0, sizeof(right));
7501     V_VT(&left) = VT_I4;
7502     V_I4(&left) = 100;
7503     V_VT(&right) = VT_UI1;
7504     V_UI1(&right) = 2;
7505
7506     hres = pVarDiv(&cy, &cy, &result);
7507     ok(hres == S_OK && V_VT(&result) == VT_R8,
7508         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7509     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
7510         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
7511
7512     hres = pVarDiv(&cy, &right, &result);
7513     ok(hres == S_OK && V_VT(&result) == VT_R8,
7514         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7515     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
7516         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
7517
7518     hres = pVarDiv(&left, &cy, &result);
7519     ok(hres == S_OK && V_VT(&result) == VT_R8,
7520         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7521     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
7522         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
7523
7524     hres = pVarDiv(&left, &dec, &result);
7525     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7526         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7527     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7528     ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
7529         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
7530
7531     hres = pVarDiv(&dec, &dec, &result);
7532     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7533         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7534     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7535     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7536         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7537
7538     hres = pVarDiv(&dec, &right, &result);
7539     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7540         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7541     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7542     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7543         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7544
7545     /* Check for division by zero and overflow */
7546     V_VT(&left) = VT_R8;
7547     V_I4(&left) = 1;
7548     V_VT(&right) = VT_R8;
7549     V_I4(&right) = 0;
7550     hres = pVarDiv(&left, &right, &result);
7551     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7552         "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7553
7554     V_VT(&left) = VT_R8;
7555     V_I4(&left) = 0;
7556     V_VT(&right) = VT_R8;
7557     V_I4(&right) = 0;
7558     hres = pVarDiv(&left, &right, &result);
7559     ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
7560         "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%X\n", hres);
7561
7562     SysFreeString(num1_str);
7563     SysFreeString(num2_str);
7564 }
7565
7566 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7567
7568 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval)              \
7569         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7570         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7571         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7572         test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
7573
7574 /* Skip any type that is not defined or produces an error for every case */
7575 #define SKIPTESTIDIV(a)                           \
7576     if (a == VT_ERROR || a == VT_VARIANT ||       \
7577         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7578         a == VT_RECORD || a > VT_UINT ||          \
7579         a == 15 /*not defined*/)                  \
7580         continue
7581
7582 static void test_VarIdiv(void)
7583 {
7584     static const WCHAR str1[] = { '1','\0' };
7585     static const WCHAR str2[] = { '2','\0' };
7586     VARIANT left, right, exp, result, cy, dec;
7587     BSTR num1_str, num2_str;
7588     VARTYPE i;
7589     HRESULT hres;
7590
7591     CHECKPTR(VarIdiv);
7592
7593     num1_str = SysAllocString(str1);
7594     num2_str = SysAllocString(str2);
7595
7596     /* Test all possible flag/vt combinations & the resulting vt type */
7597     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7598     {
7599         VARTYPE leftvt, rightvt, resvt;
7600
7601         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7602         {
7603             SKIPTESTIDIV(leftvt);
7604
7605             /* Check if we need/have support for I8 and/or UI8 */
7606             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7607                 continue;
7608
7609             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7610             {
7611                 BOOL bFail = FALSE;
7612                 SKIPTESTIDIV(rightvt);
7613
7614                 /* Native crashes with extra flag VT_BYREF */
7615                 if (ExtraFlags[i] == VT_BYREF)
7616                     continue;
7617
7618                 /* Check if we need/have support for I8 and/or UI8 */
7619                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7620                     continue;
7621
7622                 memset(&left, 0, sizeof(left));
7623                 memset(&right, 0, sizeof(right));
7624                 V_VT(&left) = leftvt | ExtraFlags[i];
7625                 V_VT(&right) = rightvt | ExtraFlags[i];
7626                 V_VT(&result) = VT_EMPTY;
7627                 resvt = VT_EMPTY;
7628
7629                 if (leftvt == VT_BSTR)
7630                     V_BSTR(&left) = num2_str;
7631                 else if (leftvt == VT_DECIMAL)
7632                 {
7633                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7634                     V_VT(&left) = leftvt | ExtraFlags[i];
7635                 }
7636
7637                 /* Division by 0 is undefined */
7638                 switch(rightvt)
7639                 {
7640                 case VT_BSTR:
7641                     V_BSTR(&right) = num2_str;
7642                     break;
7643                 case VT_DECIMAL:
7644                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7645                     V_VT(&right) = rightvt | ExtraFlags[i];
7646                     break;
7647                 case VT_BOOL:
7648                     V_BOOL(&right) = VARIANT_TRUE;
7649                     break;
7650                 case VT_CY:
7651                     VarCyFromI4(10000, &V_CY(&right));
7652                     V_VT(&right) = rightvt | ExtraFlags[i];
7653                     break;
7654                 case VT_I2: V_I2(&right) = 2; break;
7655                 case VT_I4: V_I4(&right) = 2; break;
7656                 case VT_R4: V_R4(&right) = 2.0f; break;
7657                 case VT_R8: V_R8(&right) = 2.0; break;
7658                 case VT_DATE: V_DATE(&right) = 2; break;
7659                 case VT_I1: V_I1(&right) = 2; break;
7660                 case VT_UI1: V_UI1(&right) = 2; break;
7661                 case VT_UI2: V_UI2(&right) = 2; break;
7662                 case VT_UI4: V_UI4(&right) = 2; break;
7663                 case VT_I8: V_I8(&right) = 2; break;
7664                 case VT_UI8: V_UI8(&right) = 2; break;
7665                 case VT_INT: V_INT(&right) = 2; break;
7666                 case VT_UINT: V_UINT(&right) = 2; break;
7667                 default: break;
7668                 }
7669
7670                 /* Native VarIdiv always returns an error when using extra
7671                  * flags or if the variant combination is I8 and INT.
7672                  */
7673                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
7674                     (leftvt == VT_INT && rightvt == VT_I8) ||
7675                     (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
7676                     ExtraFlags[i] != 0)
7677                     bFail = TRUE;
7678
7679                 /* Determine variant type */
7680                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
7681                     resvt = VT_NULL;
7682                 else if (leftvt == VT_I8 || rightvt == VT_I8)
7683                     resvt = VT_I8;
7684                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
7685                     leftvt == VT_INT || rightvt == VT_INT ||
7686                     leftvt == VT_UINT || rightvt == VT_UINT ||
7687                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
7688                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
7689                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
7690                     leftvt == VT_I1 || rightvt == VT_I1 ||
7691                     leftvt == VT_BSTR || rightvt == VT_BSTR ||
7692                     leftvt == VT_DATE || rightvt == VT_DATE ||
7693                     leftvt == VT_CY || rightvt == VT_CY ||
7694                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
7695                     leftvt == VT_R8 || rightvt == VT_R8 ||
7696                     leftvt == VT_R4 || rightvt == VT_R4)
7697                     resvt = VT_I4;
7698                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
7699                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
7700                     leftvt == VT_EMPTY)
7701                     resvt = VT_I2;
7702                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
7703                     resvt = VT_UI1;
7704                 else
7705                     bFail = TRUE;
7706
7707                 hres = pVarIdiv(&left, &right, &result);
7708
7709                 /* Check expected HRESULT and if result variant type is correct */
7710                 if (bFail)
7711                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7712                         hres == DISP_E_DIVBYZERO,
7713                         "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7714                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7715                         vtstr(V_VT(&result)), hres);
7716                 else
7717                     ok (hres == S_OK && resvt == V_VT(&result),
7718                         "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7719                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7720                         S_OK, vtstr(V_VT(&result)), hres);
7721             }
7722         }
7723     }
7724
7725     /* Test return values for all the good cases */
7726     VARIDIV(EMPTY,0,NULL,0,NULL,0);
7727     VARIDIV(EMPTY,0,I2,1,I2,0);
7728     VARIDIV(EMPTY,0,I4,1,I4,0);
7729     VARIDIV(EMPTY,0,R4,1.0f,I4,0);
7730     VARIDIV(EMPTY,0,R8,1.0,I4,0);
7731     VARIDIV(EMPTY,0,DATE,1.0,I4,0);
7732     VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
7733     VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
7734     VARIDIV(EMPTY,0,I1,1,I4,0);
7735     VARIDIV(EMPTY,0,UI1,1,I2,0);
7736     VARIDIV(EMPTY,0,UI2,1,I4,0);
7737     VARIDIV(EMPTY,0,UI4,1,I4,0);
7738     if (HAVE_OLEAUT32_I8)
7739     {
7740         VARIDIV(EMPTY,0,I8,1,I8,0);
7741         VARIDIV(EMPTY,0,UI8,1,I4,0);
7742     }
7743     VARIDIV(EMPTY,0,INT,1,I4,0);
7744     VARIDIV(EMPTY,0,UINT,1,I4,0);
7745     VARIDIV(NULL,0,EMPTY,0,NULL,0);
7746     VARIDIV(NULL,0,NULL,0,NULL,0);
7747     VARIDIV(NULL,0,I2,1,NULL,0);
7748     VARIDIV(NULL,0,I4,1,NULL,0);
7749     VARIDIV(NULL,0,R4,1,NULL,0);
7750     VARIDIV(NULL,0,R8,1,NULL,0);
7751     VARIDIV(NULL,0,DATE,1,NULL,0);
7752     VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
7753     VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7754     VARIDIV(NULL,0,I1,1,NULL,0);
7755     VARIDIV(NULL,0,UI1,1,NULL,0);
7756     VARIDIV(NULL,0,UI2,1,NULL,0);
7757     VARIDIV(NULL,0,UI4,1,NULL,0);
7758     if (HAVE_OLEAUT32_I8)
7759     {
7760         VARIDIV(NULL,0,I8,1,NULL,0);
7761         VARIDIV(NULL,0,UI8,1,NULL,0);
7762     }
7763     VARIDIV(NULL,0,INT,1,NULL,0);
7764     VARIDIV(NULL,0,UINT,1,NULL,0);
7765     VARIDIV(I2,2,NULL,0,NULL,0);
7766     VARIDIV(I2,2,I2,1,I2,2);
7767     VARIDIV(I2,2,I4,1,I4,2);
7768     VARIDIV(I2,2,R4,1,I4,2);
7769     VARIDIV(I2,2,R8,1,I4,2);
7770     VARIDIV(I2,2,DATE,1,I4,2);
7771     VARIDIV(I2,2,BSTR,num1_str,I4,2);
7772     VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
7773     VARIDIV(I2,2,I1,1,I4,2);
7774     VARIDIV(I2,2,UI1,1,I2,2);
7775     VARIDIV(I2,2,UI2,1,I4,2);
7776     VARIDIV(I2,2,UI4,1,I4,2);
7777     if (HAVE_OLEAUT32_I8)
7778     {
7779         VARIDIV(I2,2,I8,1,I8,2);
7780         VARIDIV(I2,2,UI8,1,I4,2);
7781     }
7782     VARIDIV(I2,2,INT,1,I4,2);
7783     VARIDIV(I2,2,UINT,1,I4,2);
7784     VARIDIV(I4,2,NULL,0,NULL,0);
7785     VARIDIV(I4,2,I2,1,I4,2);
7786     VARIDIV(I4,2,I4,1,I4,2);
7787     VARIDIV(I4,2,R4,1,I4,2);
7788     VARIDIV(I4,2,R8,1,I4,2);
7789     VARIDIV(I4,2,DATE,1,I4,2);
7790     VARIDIV(I4,2,BSTR,num1_str,I4,2);
7791     VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
7792     VARIDIV(I4,2,I1,1,I4,2);
7793     VARIDIV(I4,2,UI1,1,I4,2);
7794     VARIDIV(I4,2,UI2,1,I4,2);
7795     VARIDIV(I4,2,UI4,1,I4,2);
7796     if (HAVE_OLEAUT32_I8)
7797     {
7798         VARIDIV(I4,2,I8,1,I8,2);
7799         VARIDIV(I4,2,UI8,1,I4,2);
7800     }
7801     VARIDIV(I4,2,INT,1,I4,2);
7802     VARIDIV(I4,2,UINT,1,I4,2);
7803     VARIDIV(R4,2.0f,NULL,0,NULL,0);
7804     VARIDIV(R4,2.0f,I2,1,I4,2);
7805     VARIDIV(R4,2.0f,I4,1,I4,2);
7806     VARIDIV(R4,2.0f,R4,1.0f,I4,2);
7807     VARIDIV(R4,2.0f,R8,1.0,I4,2);
7808     VARIDIV(R4,2.0f,DATE,1,I4,2);
7809     VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
7810     VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
7811     VARIDIV(R4,2.0f,I1,1,I4,2);
7812     VARIDIV(R4,2.0f,UI1,1,I4,2);
7813     VARIDIV(R4,2.0f,UI2,1,I4,2);
7814     VARIDIV(R4,2.0f,UI4,1,I4,2);
7815     if (HAVE_OLEAUT32_I8)
7816     {
7817         VARIDIV(R4,2.0f,I8,1,I8,2);
7818         VARIDIV(R4,2.0f,UI8,1,I4,2);
7819     }
7820     VARIDIV(R4,2.0f,INT,1,I4,2);
7821     VARIDIV(R4,2.0f,UINT,1,I4,2);
7822     VARIDIV(R8,2.0,NULL,0,NULL,0);
7823     VARIDIV(R8,2.0,I2,1,I4,2);
7824     VARIDIV(R8,2.0,I4,1,I4,2);
7825     VARIDIV(R8,2.0,R4,1,I4,2);
7826     VARIDIV(R8,2.0,R8,1,I4,2);
7827     VARIDIV(R8,2.0,DATE,1,I4,2);
7828     VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
7829     VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
7830     VARIDIV(R8,2.0,I1,1,I4,2);
7831     VARIDIV(R8,2.0,UI1,1,I4,2);
7832     VARIDIV(R8,2.0,UI2,1,I4,2);
7833     VARIDIV(R8,2.0,UI4,1,I4,2);
7834     if (HAVE_OLEAUT32_I8)
7835     {
7836         VARIDIV(R8,2.0,I8,1,I8,2);
7837         VARIDIV(R8,2.0,UI8,1,I4,2);
7838     }
7839     VARIDIV(R8,2.0,INT,1,I4,2);
7840     VARIDIV(R8,2.0,UINT,1,I4,2);
7841     VARIDIV(DATE,2,NULL,0,NULL,0);
7842     VARIDIV(DATE,2,I2,1,I4,2);
7843     VARIDIV(DATE,2,I4,1,I4,2);
7844     VARIDIV(DATE,2,R4,1,I4,2);
7845     VARIDIV(DATE,2,R8,1,I4,2);
7846     VARIDIV(DATE,2,DATE,1,I4,2);
7847     VARIDIV(DATE,2,BSTR,num1_str,I4,2);
7848     VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
7849     VARIDIV(DATE,2,I1,1,I4,2);
7850     VARIDIV(DATE,2,UI1,1,I4,2);
7851     VARIDIV(DATE,2,UI2,1,I4,2);
7852     VARIDIV(DATE,2,UI4,1,I4,2);
7853     if (HAVE_OLEAUT32_I8)
7854     {
7855         VARIDIV(DATE,2,I8,1,I8,2);
7856         VARIDIV(DATE,2,UI8,1,I4,2);
7857     }
7858     VARIDIV(DATE,2,INT,1,I4,2);
7859     VARIDIV(DATE,2,UINT,1,I4,2);
7860     VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
7861     VARIDIV(BSTR,num2_str,I2,1,I4,2);
7862     VARIDIV(BSTR,num2_str,I4,1,I4,2);
7863     VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
7864     VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
7865     VARIDIV(BSTR,num2_str,DATE,1,I4,2);
7866     VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
7867     VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
7868     VARIDIV(BSTR,num2_str,I1,1,I4,2);
7869     VARIDIV(BSTR,num2_str,UI1,1,I4,2);
7870     VARIDIV(BSTR,num2_str,UI2,1,I4,2);
7871     VARIDIV(BSTR,num2_str,UI4,1,I4,2);
7872     if (HAVE_OLEAUT32_I8)
7873     {
7874         VARIDIV(BSTR,num2_str,I8,1,I8,2);
7875         VARIDIV(BSTR,num2_str,UI8,1,I4,2);
7876     }
7877     VARIDIV(BSTR,num2_str,INT,1,I4,2);
7878     VARIDIV(BSTR,num2_str,UINT,1,I4,2);
7879     VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7880     VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
7881     VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
7882     VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
7883     VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
7884     VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
7885     VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
7886     VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
7887     VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
7888     VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
7889     VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
7890     VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
7891     if (HAVE_OLEAUT32_I8)
7892     {
7893         VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
7894         VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
7895     }
7896     VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
7897     VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
7898     VARIDIV(I1,2,NULL,0,NULL,0);
7899     VARIDIV(I1,2,I2,1,I4,2);
7900     VARIDIV(I1,2,I4,1,I4,2);
7901     VARIDIV(I1,2,R4,1.0f,I4,2);
7902     VARIDIV(I1,2,R8,1.0,I4,2);
7903     VARIDIV(I1,2,DATE,1,I4,2);
7904     VARIDIV(I1,2,BSTR,num1_str,I4,2);
7905     VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
7906     VARIDIV(I1,2,I1,1,I4,2);
7907     VARIDIV(I1,2,UI1,1,I4,2);
7908     VARIDIV(I1,2,UI2,1,I4,2);
7909     VARIDIV(I1,2,UI4,1,I4,2);
7910     if (HAVE_OLEAUT32_I8)
7911     {
7912         VARIDIV(I1,2,I8,1,I8,2);
7913         VARIDIV(I1,2,UI8,1,I4,2);
7914     }
7915     VARIDIV(I1,2,INT,1,I4,2);
7916     VARIDIV(I1,2,UINT,1,I4,2);
7917     VARIDIV(UI1,2,NULL,0,NULL,0);
7918     VARIDIV(UI1,2,I2,1,I2,2);
7919     VARIDIV(UI1,2,I4,1,I4,2);
7920     VARIDIV(UI1,2,R4,1.0f,I4,2);
7921     VARIDIV(UI1,2,R8,1.0,I4,2);
7922     VARIDIV(UI1,2,DATE,1,I4,2);
7923     VARIDIV(UI1,2,BSTR,num1_str,I4,2);
7924     VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
7925     VARIDIV(UI1,2,I1,1,I4,2);
7926     VARIDIV(UI1,2,UI1,1,UI1,2);
7927     VARIDIV(UI1,2,UI2,1,I4,2);
7928     VARIDIV(UI1,2,UI4,1,I4,2);
7929     if (HAVE_OLEAUT32_I8)
7930     {
7931         VARIDIV(UI1,2,I8,1,I8,2);
7932         VARIDIV(UI1,2,UI8,1,I4,2);
7933     }
7934     VARIDIV(UI1,2,INT,1,I4,2);
7935     VARIDIV(UI1,2,UINT,1,I4,2);
7936     VARIDIV(UI2,2,NULL,0,NULL,0);
7937     VARIDIV(UI2,2,I2,1,I4,2);
7938     VARIDIV(UI2,2,I4,1,I4,2);
7939     VARIDIV(UI2,2,R4,1.0f,I4,2);
7940     VARIDIV(UI2,2,R8,1.0,I4,2);
7941     VARIDIV(UI2,2,DATE,1,I4,2);
7942     VARIDIV(UI2,2,BSTR,num1_str,I4,2);
7943     VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
7944     VARIDIV(UI2,2,I1,1,I4,2);
7945     VARIDIV(UI2,2,UI1,1,I4,2);
7946     VARIDIV(UI2,2,UI2,1,I4,2);
7947     VARIDIV(UI2,2,UI4,1,I4,2);
7948     if (HAVE_OLEAUT32_I8)
7949     {
7950         VARIDIV(UI2,2,I8,1,I8,2);
7951         VARIDIV(UI2,2,UI8,1,I4,2);
7952     }
7953     VARIDIV(UI2,2,INT,1,I4,2);
7954     VARIDIV(UI2,2,UINT,1,I4,2);
7955     VARIDIV(UI4,2,NULL,0,NULL,0);
7956     VARIDIV(UI4,2,I2,1,I4,2);
7957     VARIDIV(UI4,2,I4,1,I4,2);
7958     VARIDIV(UI4,2,R4,1.0f,I4,2);
7959     VARIDIV(UI4,2,R8,1.0,I4,2);
7960     VARIDIV(UI4,2,DATE,1,I4,2);
7961     VARIDIV(UI4,2,BSTR,num1_str,I4,2);
7962     VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
7963     VARIDIV(UI4,2,I1,1,I4,2);
7964     VARIDIV(UI4,2,UI1,1,I4,2);
7965     VARIDIV(UI4,2,UI2,1,I4,2);
7966     VARIDIV(UI4,2,UI4,1,I4,2);
7967     if (HAVE_OLEAUT32_I8)
7968     {
7969         VARIDIV(UI4,2,I8,1,I8,2);
7970         VARIDIV(UI4,2,UI8,1,I4,2);
7971     }
7972     VARIDIV(UI4,2,INT,1,I4,2);
7973     VARIDIV(UI4,2,UINT,1,I4,2);
7974     if (HAVE_OLEAUT32_I8)
7975     {
7976         VARIDIV(I8,2,NULL,0,NULL,0);
7977         VARIDIV(I8,2,I2,1,I8,2);
7978         VARIDIV(I8,2,I4,1,I8,2);
7979         VARIDIV(I8,2,R4,1.0f,I8,2);
7980         VARIDIV(I8,2,R8,1.0,I8,2);
7981         VARIDIV(I8,2,DATE,1,I8,2);
7982         VARIDIV(I8,2,BSTR,num1_str,I8,2);
7983         VARIDIV(I8,2,BOOL,1,I8,2);
7984         VARIDIV(I8,2,I1,1,I8,2);
7985         VARIDIV(I8,2,UI1,1,I8,2);
7986         VARIDIV(I8,2,UI2,1,I8,2);
7987         VARIDIV(I8,2,UI4,1,I8,2);
7988         VARIDIV(I8,2,I8,1,I8,2);
7989         VARIDIV(I8,2,UI8,1,I8,2);
7990         VARIDIV(I8,2,UINT,1,I8,2);
7991         VARIDIV(UI8,2,NULL,0,NULL,0);
7992         VARIDIV(UI8,2,I2,1,I4,2);
7993         VARIDIV(UI8,2,I4,1,I4,2);
7994         VARIDIV(UI8,2,R4,1.0f,I4,2);
7995         VARIDIV(UI8,2,R8,1.0,I4,2);
7996         VARIDIV(UI8,2,DATE,1,I4,2);
7997         VARIDIV(UI8,2,BSTR,num1_str,I4,2);
7998         VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
7999         VARIDIV(UI8,2,I1,1,I4,2);
8000         VARIDIV(UI8,2,UI1,1,I4,2);
8001         VARIDIV(UI8,2,UI2,1,I4,2);
8002         VARIDIV(UI8,2,UI4,1,I4,2);
8003         VARIDIV(UI8,2,I8,1,I8,2);
8004         VARIDIV(UI8,2,UI8,1,I4,2);
8005         VARIDIV(UI8,2,INT,1,I4,2);
8006         VARIDIV(UI8,2,UINT,1,I4,2);
8007     }
8008     VARIDIV(INT,2,NULL,0,NULL,0);
8009     VARIDIV(INT,2,I2,1,I4,2);
8010     VARIDIV(INT,2,I4,1,I4,2);
8011     VARIDIV(INT,2,R4,1.0f,I4,2);
8012     VARIDIV(INT,2,R8,1.0,I4,2);
8013     VARIDIV(INT,2,DATE,1,I4,2);
8014     VARIDIV(INT,2,BSTR,num1_str,I4,2);
8015     VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
8016     VARIDIV(INT,2,I1,1,I4,2);
8017     VARIDIV(INT,2,UI1,1,I4,2);
8018     VARIDIV(INT,2,UI2,1,I4,2);
8019     VARIDIV(INT,2,UI4,1,I4,2);
8020     if (HAVE_OLEAUT32_I8)
8021     {
8022         VARIDIV(INT,2,UI8,1,I4,2);
8023     }
8024     VARIDIV(INT,2,INT,1,I4,2);
8025     VARIDIV(INT,2,UINT,1,I4,2);
8026     VARIDIV(UINT,2,NULL,0,NULL,0);
8027     VARIDIV(UINT,2,I2,1,I4,2);
8028     VARIDIV(UINT,2,I4,1,I4,2);
8029     VARIDIV(UINT,2,R4,1.0f,I4,2);
8030     VARIDIV(UINT,2,R8,1.0,I4,2);
8031     VARIDIV(UINT,2,DATE,1,I4,2);
8032     VARIDIV(UINT,2,BSTR,num1_str,I4,2);
8033     VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
8034     VARIDIV(UINT,2,I1,1,I4,2);
8035     VARIDIV(UINT,2,UI1,1,I4,2);
8036     VARIDIV(UINT,2,UI2,1,I4,2);
8037     VARIDIV(UINT,2,UI4,1,I4,2);
8038     if (HAVE_OLEAUT32_I8)
8039     {
8040         VARIDIV(UINT,2,I8,1,I8,2);
8041         VARIDIV(UINT,2,UI8,1,I4,2);
8042     }
8043     VARIDIV(UINT,2,INT,1,I4,2);
8044     VARIDIV(UINT,2,UINT,1,I4,2);
8045
8046     /* Manually test some VT_CY, VT_DECIMAL variants */
8047     V_VT(&cy) = VT_CY;
8048     hres = VarCyFromI4(10000, &V_CY(&cy));
8049     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8050     V_VT(&dec) = VT_DECIMAL;
8051     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8052     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8053     memset(&left, 0, sizeof(left));
8054     memset(&right, 0, sizeof(right));
8055     V_VT(&left) = VT_I4;
8056     V_I4(&left) = 100;
8057     V_VT(&right) = VT_I8;
8058     V_UI1(&right) = 2;
8059
8060     hres = pVarIdiv(&cy, &cy, &result);
8061     ok(hres == S_OK && V_VT(&result) == VT_I4,
8062         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8063         S_OK, hres, vtstr(V_VT(&result)));
8064     ok(hres == S_OK && V_I4(&result) == 1,
8065         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
8066
8067     if (HAVE_OLEAUT32_I8)
8068     {
8069         hres = pVarIdiv(&cy, &right, &result);
8070         ok(hres == S_OK && V_VT(&result) == VT_I8,
8071             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8072             S_OK, hres, vtstr(V_VT(&result)));
8073         ok(hres == S_OK && V_I8(&result) == 5000,
8074             "VARIDIV: CY value 0x%x%08x, expected 0x%x\n",
8075             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), 5000);
8076     }
8077
8078     hres = pVarIdiv(&left, &cy, &result);
8079     ok(hres == S_OK && V_VT(&result) == VT_I4,
8080         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8081         S_OK, hres, vtstr(V_VT(&result)));
8082     ok(hres == S_OK && V_I4(&result) == 0,
8083         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 0);
8084
8085     hres = pVarIdiv(&left, &dec, &result);
8086     ok(hres == S_OK && V_VT(&result) == VT_I4,
8087         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8088         S_OK, hres, vtstr(V_VT(&result)));
8089     ok(hres == S_OK && V_I4(&result) == 50,
8090         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 50);
8091
8092     hres = pVarIdiv(&dec, &dec, &result);
8093     ok(hres == S_OK && V_VT(&result) == VT_I4,
8094         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8095         S_OK, hres, vtstr(V_VT(&result)));
8096     ok(hres == S_OK && V_I4(&result) == 1,
8097         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
8098
8099     if (HAVE_OLEAUT32_I8)
8100     {
8101         hres = pVarIdiv(&dec, &right, &result);
8102         ok(hres == S_OK && V_VT(&result) == VT_I8,
8103             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8104             S_OK, hres, vtstr(V_VT(&result)));
8105         ok(hres == S_OK && V_I8(&result) == 1,
8106             "VARIDIV: DECIMAL value 0x%x%08x, expected %d\n",
8107             (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result), 1);
8108     }
8109
8110     /* Check for division by zero */
8111     V_VT(&left) = VT_INT;
8112     V_I4(&left) = 1;
8113     V_VT(&right) = VT_INT;
8114     V_I4(&right) = 0;
8115     hres = pVarIdiv(&left, &right, &result);
8116     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8117         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8118
8119     V_VT(&left) = VT_INT;
8120     V_I4(&left) = 0;
8121     V_VT(&right) = VT_INT;
8122     V_I4(&right) = 0;
8123     hres = pVarIdiv(&left, &right, &result);
8124     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8125         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8126
8127     SysFreeString(num1_str);
8128     SysFreeString(num2_str);
8129 }
8130
8131
8132 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
8133
8134 #define VARIMP(vt1,val1,vt2,val2,rvt,rval)              \
8135         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
8136         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8137         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
8138         test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
8139
8140 /* Skip any type that is not defined or produces an error for every case */
8141 #define SKIPTESTIMP(a)                            \
8142     if (a == VT_ERROR || a == VT_VARIANT ||       \
8143         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
8144         a == VT_RECORD || a > VT_UINT ||          \
8145         a == 15 /*not defined*/)                  \
8146         continue
8147
8148 static void test_VarImp(void)
8149 {
8150     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
8151     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
8152     VARIANT left, right, exp, result, cy, dec;
8153     BSTR true_str, false_str;
8154     VARTYPE i;
8155     HRESULT hres;
8156
8157     CHECKPTR(VarImp);
8158
8159     true_str = SysAllocString(szTrue);
8160     false_str = SysAllocString(szFalse);
8161
8162     /* Test all possible flag/vt combinations & the resulting vt type */
8163     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
8164     {
8165         VARTYPE leftvt, rightvt, resvt;
8166
8167         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8168         {
8169             SKIPTESTIMP(leftvt);
8170
8171             /* Check if we need/have support for I8 and/or UI8 */
8172             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8173                 continue;
8174
8175             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8176             {
8177                 BOOL bFail = FALSE;
8178                 SKIPTESTIMP(rightvt);
8179
8180                 /* Native crashes when using the extra flag VT_BYREF
8181                  * or with the following VT combinations
8182                  */
8183                 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
8184                     (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
8185                     ExtraFlags[i] == VT_BYREF)
8186                     continue;
8187
8188                 /* Check if we need/have support for I8 and/or UI8 */
8189                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8190                     continue;
8191
8192                 memset(&left, 0, sizeof(left));
8193                 memset(&right, 0, sizeof(right));
8194                 V_VT(&left) = leftvt | ExtraFlags[i];
8195                 V_VT(&right) = rightvt | ExtraFlags[i];
8196                 V_VT(&result) = VT_EMPTY;
8197                 resvt = VT_EMPTY;
8198
8199                 if (leftvt == VT_BSTR)
8200                     V_BSTR(&left) = true_str;
8201
8202                 /* This allows us to test return types that are not NULL
8203                  * (NULL Imp value = n, NULL Imp 0 = NULL)
8204                  */
8205                 switch(rightvt)
8206                 {
8207                 case VT_BSTR:
8208                     V_BSTR(&right) = true_str;
8209                     break;
8210                 case VT_DECIMAL:
8211                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8212                     V_VT(&right) = rightvt | ExtraFlags[i];
8213                     break;
8214                 case VT_BOOL:
8215                     V_BOOL(&right) = VARIANT_TRUE;
8216                     break;
8217                 case VT_I1: V_I1(&right) = 2; break;
8218                 case VT_I2: V_I2(&right) = 2; break;
8219                 case VT_I4: V_I4(&right) = 2; break;
8220                 case VT_R4: V_R4(&right) = 2.0f; break;
8221                 case VT_R8: V_R8(&right) = 2.0; break;
8222                 case VT_CY: V_CY(&right).int64 = 10000; break;
8223                 case VT_DATE: V_DATE(&right) = 2; break;
8224                 case VT_I8: V_I8(&right) = 2; break;
8225                 case VT_INT: V_INT(&right) = 2; break;
8226                 case VT_UINT: V_UINT(&right) = 2; break;
8227                 case VT_UI1: V_UI1(&right) = 2; break;
8228                 case VT_UI2: V_UI2(&right) = 2; break;
8229                 case VT_UI4: V_UI4(&right) = 2; break;
8230                 case VT_UI8: V_UI8(&right) = 2; break;
8231                 default: break;
8232                 }
8233
8234                 /* Native VarImp always returns an error when using extra
8235                  * flags or if the variants are I8 and INT.
8236                  */
8237                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8238                     ExtraFlags[i] != 0)
8239                     bFail = TRUE;
8240
8241                 /* Determine result type */
8242                 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
8243                     (leftvt == VT_NULL && rightvt == VT_NULL) ||
8244                     (leftvt == VT_NULL && rightvt == VT_EMPTY))
8245                     resvt = VT_NULL;
8246                 else if (leftvt == VT_I8 || rightvt == VT_I8)
8247                     resvt = VT_I8;
8248                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8249                     leftvt == VT_INT || rightvt == VT_INT ||
8250                     leftvt == VT_UINT || rightvt == VT_UINT ||
8251                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
8252                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
8253                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
8254                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8255                     leftvt == VT_DATE || rightvt == VT_DATE ||
8256                     leftvt == VT_CY || rightvt == VT_CY ||
8257                     leftvt == VT_R8 || rightvt == VT_R8 ||
8258                     leftvt == VT_R4 || rightvt == VT_R4 ||
8259                     leftvt == VT_I1 || rightvt == VT_I1)
8260                     resvt = VT_I4;
8261                 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
8262                     (leftvt == VT_UI1 && rightvt == VT_NULL) ||
8263                     (leftvt == VT_NULL && rightvt == VT_UI1))
8264                     resvt = VT_UI1;
8265                 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
8266                     leftvt == VT_I2 || rightvt == VT_I2 ||
8267                     leftvt == VT_UI1 || rightvt == VT_UI1)
8268                     resvt = VT_I2;
8269                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
8270                     leftvt == VT_BSTR || rightvt == VT_BSTR)
8271                     resvt = VT_BOOL;
8272
8273                 hres = pVarImp(&left, &right, &result);
8274
8275                 /* Check expected HRESULT and if result variant type is correct */
8276                 if (bFail)
8277                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
8278                         "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
8279                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
8280                         vtstr(V_VT(&result)), hres);
8281                 else
8282                     ok (hres == S_OK && resvt == V_VT(&result),
8283                         "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
8284                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
8285                         S_OK, vtstr(V_VT(&result)), hres);
8286             }
8287         }
8288     }
8289
8290     VARIMP(EMPTY,0,EMPTY,0,I2,-1);
8291     VARIMP(EMPTY,0,NULL,0,I2,-1);
8292     VARIMP(EMPTY,0,I2,-1,I2,-1);
8293     VARIMP(EMPTY,0,I4,-1,I4,-1);
8294     VARIMP(EMPTY,0,R4,0.0f,I4,-1);
8295     VARIMP(EMPTY,0,R8,-1.0,I4,-1);
8296     VARIMP(EMPTY,0,DATE,0,I4,-1);
8297     VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
8298     VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
8299     VARIMP(EMPTY,0,I1,0,I4,-1);
8300     VARIMP(EMPTY,0,UI1,1,I2,-1);
8301     VARIMP(EMPTY,0,UI2,1,I4,-1);
8302     VARIMP(EMPTY,0,UI4,1,I4,-1);
8303     if (HAVE_OLEAUT32_I8)
8304     {
8305         VARIMP(EMPTY,0,I8,1,I8,-1);
8306         VARIMP(EMPTY,0,UI8,1,I4,-1);
8307     }
8308     VARIMP(EMPTY,0,INT,-1,I4,-1);
8309     VARIMP(EMPTY,0,UINT,1,I4,-1);
8310     VARIMP(NULL,0,EMPTY,0,NULL,0);
8311     VARIMP(NULL,0,NULL,0,NULL,0);
8312     VARIMP(NULL,0,I2,-1,I2,-1);
8313     VARIMP(NULL,0,I4,-1,I4,-1);
8314     VARIMP(NULL,0,R4,0.0f,NULL,0);
8315     VARIMP(NULL,0,R8,-1.0,I4,-1);
8316     VARIMP(NULL,0,DATE,0,NULL,0);
8317     VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
8318     VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
8319     VARIMP(NULL,0,I1,0,NULL,0);
8320     VARIMP(NULL,0,UI1,1,UI1,1);
8321     VARIMP(NULL,0,UI2,1,I4,1);
8322     VARIMP(NULL,0,UI4,1,I4,1);
8323     if (HAVE_OLEAUT32_I8)
8324     {
8325         VARIMP(NULL,0,I8,1,I8,1);
8326         VARIMP(NULL,0,UI8,1,I4,1);
8327     }
8328     VARIMP(NULL,0,INT,-1,I4,-1);
8329     VARIMP(NULL,0,UINT,1,I4,1);
8330     VARIMP(I2,-1,EMPTY,0,I2,0);
8331     VARIMP(I2,-1,I2,-1,I2,-1);
8332     VARIMP(I2,-1,I4,-1,I4,-1);
8333     VARIMP(I2,-1,R4,0.0f,I4,0);
8334     VARIMP(I2,-1,R8,-1.0,I4,-1);
8335     VARIMP(I2,-1,DATE,0,I4,0);
8336     VARIMP(I2,-1,BSTR,true_str,I2,-1);
8337     VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
8338     VARIMP(I2,-1,I1,0,I4,0);
8339     VARIMP(I2,-1,UI1,1,I2,1);
8340     VARIMP(I2,-1,UI2,1,I4,1);
8341     VARIMP(I2,-1,UI4,1,I4,1);
8342     if (HAVE_OLEAUT32_I8)
8343     {
8344         VARIMP(I2,-1,I8,1,I8,1);
8345         VARIMP(I2,-1,UI8,1,I4,1);
8346     }
8347     VARIMP(I2,-1,INT,-1,I4,-1);
8348     VARIMP(I2,-1,UINT,1,I4,1);
8349     VARIMP(I4,2,EMPTY,0,I4,-3);
8350     VARIMP(I4,2,NULL,0,I4,-3);
8351     VARIMP(I4,2,I2,-1,I4,-1);
8352     VARIMP(I4,2,I4,-1,I4,-1);
8353     VARIMP(I4,2,R4,0.0f,I4,-3);
8354     VARIMP(I4,2,R8,-1.0,I4,-1);
8355     VARIMP(I4,2,DATE,0,I4,-3);
8356     VARIMP(I4,2,BSTR,true_str,I4,-1);
8357     VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
8358     VARIMP(I4,2,I1,0,I4,-3);
8359     VARIMP(I4,2,UI1,1,I4,-3);
8360     VARIMP(I4,2,UI2,1,I4,-3);
8361     VARIMP(I4,2,UI4,1,I4,-3);
8362     if (HAVE_OLEAUT32_I8)
8363     {
8364         VARIMP(I4,2,I8,1,I8,-3);
8365         VARIMP(I4,2,UI8,1,I4,-3);
8366     }
8367     VARIMP(I4,2,INT,-1,I4,-1);
8368     VARIMP(I4,2,UINT,1,I4,-3);
8369     VARIMP(R4,-1.0f,EMPTY,0,I4,0);
8370     VARIMP(R4,-1.0f,NULL,0,NULL,0);
8371     VARIMP(R4,-1.0f,I2,-1,I4,-1);
8372     VARIMP(R4,-1.0f,I4,-1,I4,-1);
8373     VARIMP(R4,-1.0f,R4,0.0f,I4,0);
8374     VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
8375     VARIMP(R4,-1.0f,DATE,1,I4,1);
8376     VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
8377     VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
8378     VARIMP(R4,-1.0f,I1,0,I4,0);
8379     VARIMP(R4,-1.0f,UI1,1,I4,1);
8380     VARIMP(R4,-1.0f,UI2,1,I4,1);
8381     VARIMP(R4,-1.0f,UI4,1,I4,1);
8382     if (HAVE_OLEAUT32_I8)
8383     {
8384         VARIMP(R4,-1.0f,I8,1,I8,1);
8385         VARIMP(R4,-1.0f,UI8,1,I4,1);
8386     }
8387     VARIMP(R4,-1.0f,INT,-1,I4,-1);
8388     VARIMP(R4,-1.0f,UINT,1,I4,1);
8389     VARIMP(R8,1.0,EMPTY,0,I4,-2);
8390     VARIMP(R8,1.0,NULL,0,I4,-2);
8391     VARIMP(R8,1.0,I2,-1,I4,-1);
8392     VARIMP(R8,1.0,I4,-1,I4,-1);
8393     VARIMP(R8,1.0,R4,0.0f,I4,-2);
8394     VARIMP(R8,1.0,R8,-1.0,I4,-1);
8395     VARIMP(R8,1.0,DATE,0,I4,-2);
8396     VARIMP(R8,1.0,BSTR,true_str,I4,-1);
8397     VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
8398     VARIMP(R8,1.0,I1,0,I4,-2);
8399     VARIMP(R8,1.0,UI1,1,I4,-1);
8400     VARIMP(R8,1.0,UI2,1,I4,-1);
8401     VARIMP(R8,1.0,UI4,1,I4,-1);
8402     if (HAVE_OLEAUT32_I8)
8403     {
8404         VARIMP(R8,1.0,I8,1,I8,-1);
8405         VARIMP(R8,1.0,UI8,1,I4,-1);
8406     }
8407     VARIMP(R8,1.0,INT,-1,I4,-1);
8408     VARIMP(R8,1.0,UINT,1,I4,-1);
8409     VARIMP(DATE,0,EMPTY,0,I4,-1);
8410     VARIMP(DATE,0,NULL,0,I4,-1);
8411     VARIMP(DATE,0,I2,-1,I4,-1);
8412     VARIMP(DATE,0,I4,-1,I4,-1);
8413     VARIMP(DATE,0,R4,0.0f,I4,-1);
8414     VARIMP(DATE,0,R8,-1.0,I4,-1);
8415     VARIMP(DATE,0,DATE,0,I4,-1);
8416     VARIMP(DATE,0,BSTR,true_str,I4,-1);
8417     VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
8418     VARIMP(DATE,0,I1,0,I4,-1);
8419     VARIMP(DATE,0,UI1,1,I4,-1);
8420     VARIMP(DATE,0,UI2,1,I4,-1);
8421     VARIMP(DATE,0,UI4,1,I4,-1);
8422     if (HAVE_OLEAUT32_I8)
8423     {
8424         VARIMP(DATE,0,I8,1,I8,-1);
8425         VARIMP(DATE,0,UI8,1,I4,-1);
8426     }
8427     VARIMP(DATE,0,INT,-1,I4,-1);
8428     VARIMP(DATE,0,UINT,1,I4,-1);
8429     VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
8430     VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
8431     VARIMP(BSTR,false_str,I2,-1,I2,-1);
8432     VARIMP(BSTR,false_str,I4,-1,I4,-1);
8433     VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
8434     VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
8435     VARIMP(BSTR,false_str,DATE,0,I4,-1);
8436     VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
8437     VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
8438     VARIMP(BSTR,false_str,I1,0,I4,-1);
8439     VARIMP(BSTR,false_str,UI1,1,I2,-1);
8440     VARIMP(BSTR,false_str,UI2,1,I4,-1);
8441     VARIMP(BSTR,false_str,UI4,1,I4,-1);
8442     if (HAVE_OLEAUT32_I8)
8443     {
8444         VARIMP(BSTR,false_str,I8,1,I8,-1);
8445         VARIMP(BSTR,false_str,UI8,1,I4,-1);
8446     }
8447     VARIMP(BSTR,false_str,INT,-1,I4,-1);
8448     VARIMP(BSTR,false_str,UINT,1,I4,-1);
8449     VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
8450     VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8451     VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
8452     VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
8453     VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
8454     VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
8455     VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
8456     VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
8457     VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
8458     VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
8459     VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
8460     VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
8461     VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
8462     if (HAVE_OLEAUT32_I8)
8463     {
8464         VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
8465         VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
8466     }
8467     VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
8468     VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
8469     VARIMP(I1,-1,EMPTY,0,I4,0);
8470     VARIMP(I1,-1,NULL,0,NULL,0);
8471     VARIMP(I1,-1,I2,-1,I4,-1);
8472     VARIMP(I1,-1,I4,-1,I4,-1);
8473     VARIMP(I1,-1,R4,0.0f,I4,0);
8474     VARIMP(I1,-1,R8,-1.0,I4,-1);
8475     VARIMP(I1,-1,DATE,0,I4,0);
8476     VARIMP(I1,-1,BSTR,true_str,I4,-1);
8477     VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
8478     VARIMP(I1,-1,I1,0,I4,0);
8479     VARIMP(I1,-1,UI1,1,I4,1);
8480     VARIMP(I1,-1,UI2,1,I4,1);
8481     VARIMP(I1,-1,UI4,1,I4,1);
8482     if (HAVE_OLEAUT32_I8)
8483     {
8484         VARIMP(I1,-1,I8,1,I8,1);
8485         VARIMP(I1,-1,UI8,1,I4,1);
8486     }
8487     VARIMP(I1,-1,INT,-1,I4,-1);
8488     VARIMP(I1,-1,UINT,1,I4,1);
8489     VARIMP(UI1,0,EMPTY,0,I2,-1);
8490     VARIMP(UI1,0,NULL,0,UI1,255);
8491     VARIMP(UI1,0,I2,-1,I2,-1);
8492     VARIMP(UI1,0,I4,-1,I4,-1);
8493     VARIMP(UI1,0,R4,0.0f,I4,-1);
8494     VARIMP(UI1,0,R8,-1.0,I4,-1);
8495     VARIMP(UI1,0,DATE,0,I4,-1);
8496     VARIMP(UI1,0,BSTR,true_str,I2,-1);
8497     VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
8498     VARIMP(UI1,0,I1,0,I4,-1);
8499     VARIMP(UI1,0,UI1,1,UI1,255);
8500     VARIMP(UI1,0,UI2,1,I4,-1);
8501     VARIMP(UI1,0,UI4,1,I4,-1);
8502     if (HAVE_OLEAUT32_I8)
8503     {
8504         VARIMP(UI1,0,I8,1,I8,-1);
8505         VARIMP(UI1,0,UI8,1,I4,-1);
8506     }
8507     VARIMP(UI1,0,INT,-1,I4,-1);
8508     VARIMP(UI1,0,UINT,1,I4,-1);
8509     VARIMP(UI2,0,EMPTY,0,I4,-1);
8510     VARIMP(UI2,0,NULL,0,I4,-1);
8511     VARIMP(UI2,0,I2,-1,I4,-1);
8512     VARIMP(UI2,0,I4,-1,I4,-1);
8513     VARIMP(UI2,0,R4,0.0f,I4,-1);
8514     VARIMP(UI2,0,R8,-1.0,I4,-1);
8515     VARIMP(UI2,0,DATE,0,I4,-1);
8516     VARIMP(UI2,0,BSTR,true_str,I4,-1);
8517     VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
8518     VARIMP(UI2,0,I1,0,I4,-1);
8519     VARIMP(UI2,0,UI1,1,I4,-1);
8520     VARIMP(UI2,0,UI2,1,I4,-1);
8521     VARIMP(UI2,0,UI4,1,I4,-1);
8522     if (HAVE_OLEAUT32_I8)
8523     {
8524         VARIMP(UI2,0,I8,1,I8,-1);
8525         VARIMP(UI2,0,UI8,1,I4,-1);
8526     }
8527     VARIMP(UI2,0,INT,-1,I4,-1);
8528     VARIMP(UI2,0,UINT,1,I4,-1);
8529     VARIMP(UI4,0,EMPTY,0,I4,-1);
8530     VARIMP(UI4,0,NULL,0,I4,-1);
8531     VARIMP(UI4,0,I2,-1,I4,-1);
8532     VARIMP(UI4,0,I4,-1,I4,-1);
8533     VARIMP(UI4,0,R4,0.0f,I4,-1);
8534     VARIMP(UI4,0,R8,-1.0,I4,-1);
8535     VARIMP(UI4,0,DATE,0,I4,-1);
8536     VARIMP(UI4,0,BSTR,true_str,I4,-1);
8537     VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
8538     VARIMP(UI4,0,I1,0,I4,-1);
8539     VARIMP(UI4,0,UI1,1,I4,-1);
8540     VARIMP(UI4,0,UI2,1,I4,-1);
8541     VARIMP(UI4,0,UI4,1,I4,-1);
8542     if (HAVE_OLEAUT32_I8)
8543     {
8544         VARIMP(UI4,0,I8,1,I8,-1);
8545         VARIMP(UI4,0,UI8,1,I4,-1);
8546     }
8547     VARIMP(UI4,0,INT,-1,I4,-1);
8548     VARIMP(UI4,0,UINT,1,I4,-1);
8549     if (HAVE_OLEAUT32_I8)
8550     {
8551         VARIMP(I8,-1,EMPTY,0,I8,0);
8552         VARIMP(I8,-1,NULL,0,NULL,0);
8553         VARIMP(I8,-1,I2,-1,I8,-1);
8554         VARIMP(I8,-1,I4,-1,I8,-1);
8555         VARIMP(I8,-1,R4,0.0f,I8,0);
8556         VARIMP(I8,-1,R8,-1.0,I8,-1);
8557         VARIMP(I8,-1,DATE,0,I8,0);
8558         VARIMP(I8,-1,BSTR,true_str,I8,-1);
8559         VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
8560         VARIMP(I8,-1,I1,0,I8,0);
8561         VARIMP(I8,-1,UI1,1,I8,1);
8562         VARIMP(I8,-1,UI2,1,I8,1);
8563         VARIMP(I8,-1,UI4,1,I8,1);
8564         VARIMP(I8,-1,I8,1,I8,1);
8565         VARIMP(I8,-1,UI8,1,I8,1);
8566         VARIMP(I8,-1,UINT,1,I8,1);
8567         VARIMP(UI8,0,EMPTY,0,I4,-1);
8568         VARIMP(UI8,0,NULL,0,I4,-1);
8569         VARIMP(UI8,0,I2,-1,I4,-1);
8570         VARIMP(UI8,0,I4,-1,I4,-1);
8571         VARIMP(UI8,0,R4,0.0f,I4,-1);
8572         VARIMP(UI8,0,R8,-1.0,I4,-1);
8573         VARIMP(UI8,0,DATE,0,I4,-1);
8574         VARIMP(UI8,0,BSTR,true_str,I4,-1);
8575         VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
8576         VARIMP(UI8,0,I1,0,I4,-1);
8577         VARIMP(UI8,0,UI1,1,I4,-1);
8578         VARIMP(UI8,0,UI2,1,I4,-1);
8579         VARIMP(UI8,0,UI4,1,I4,-1);
8580         VARIMP(UI8,0,I8,1,I8,-1);
8581         VARIMP(UI8,0,UI8,1,I4,-1);
8582         VARIMP(UI8,0,INT,-1,I4,-1);
8583         VARIMP(UI8,0,UINT,1,I4,-1);
8584     }
8585     VARIMP(INT,-1,EMPTY,0,I4,0);
8586     VARIMP(INT,-1,NULL,0,NULL,0);
8587     VARIMP(INT,-1,I2,-1,I4,-1);
8588     VARIMP(INT,-1,I4,-1,I4,-1);
8589     VARIMP(INT,-1,R4,0.0f,I4,0);
8590     VARIMP(INT,-1,R8,-1.0,I4,-1);
8591     VARIMP(INT,-1,DATE,0,I4,0);
8592     VARIMP(INT,-1,BSTR,true_str,I4,-1);
8593     VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
8594     VARIMP(INT,-1,I1,0,I4,0);
8595     VARIMP(INT,-1,UI1,1,I4,1);
8596     VARIMP(INT,-1,UI2,1,I4,1);
8597     VARIMP(INT,-1,UI4,1,I4,1);
8598     if (HAVE_OLEAUT32_I8)
8599     {
8600         VARIMP(INT,-1,I8,1,I8,1);
8601         VARIMP(INT,-1,UI8,1,I4,1);
8602     }
8603     VARIMP(INT,-1,INT,-1,I4,-1);
8604     VARIMP(INT,-1,UINT,1,I4,1);
8605     VARIMP(UINT,1,EMPTY,0,I4,-2);
8606     VARIMP(UINT,1,NULL,0,I4,-2);
8607     VARIMP(UINT,1,I2,-1,I4,-1);
8608     VARIMP(UINT,1,I4,-1,I4,-1);
8609     VARIMP(UINT,1,R4,0.0f,I4,-2);
8610     VARIMP(UINT,1,R8,-1.0,I4,-1);
8611     VARIMP(UINT,1,DATE,0,I4,-2);
8612     VARIMP(UINT,1,BSTR,true_str,I4,-1);
8613     VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
8614     VARIMP(UINT,1,I1,0,I4,-2);
8615     VARIMP(UINT,1,UI1,1,I4,-1);
8616     VARIMP(UINT,1,UI2,1,I4,-1);
8617     VARIMP(UINT,1,UI4,1,I4,-1);
8618     if (HAVE_OLEAUT32_I8)
8619     {
8620         VARIMP(UINT,1,I8,1,I8,-1);
8621         VARIMP(UINT,1,UI8,1,I4,-1);
8622     }
8623     VARIMP(UINT,1,INT,-1,I4,-1);
8624     VARIMP(UINT,1,UINT,1,I4,-1);
8625
8626     /* Manually test some VT_CY, VT_DECIMAL variants */
8627     V_VT(&cy) = VT_CY;
8628     hres = VarCyFromI4(1, &V_CY(&cy));
8629     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8630     V_VT(&dec) = VT_DECIMAL;
8631     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8632     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8633     memset(&left, 0, sizeof(left));
8634     memset(&right, 0, sizeof(right));
8635     V_VT(&left) = VT_I4;
8636     V_I4(&left) = 0;
8637     V_VT(&right) = VT_I8;
8638     V_UI1(&right) = 0;
8639
8640     hres = pVarImp(&cy, &cy, &result);
8641     ok(hres == S_OK && V_VT(&result) == VT_I4,
8642         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8643         S_OK, hres, vtstr(V_VT(&result)));
8644     ok(hres == S_OK && V_I4(&result) == -1,
8645         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8646
8647     if (HAVE_OLEAUT32_I8)
8648     {
8649         hres = pVarImp(&cy, &right, &result);
8650         ok(hres == S_OK && V_VT(&result) == VT_I8,
8651             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8652             S_OK, hres, vtstr(V_VT(&result)));
8653         ok(hres == S_OK && V_I8(&result) == -2,
8654             "VARIMP: CY value %x%08x, expected %d\n",
8655             (DWORD)((V_I8(&result)) >> 32), (DWORD)(V_I8(&result)), -2);
8656     }
8657
8658     hres = pVarImp(&left, &cy, &result);
8659     ok(hres == S_OK && V_VT(&result) == VT_I4,
8660         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8661         S_OK, hres, vtstr(V_VT(&result)));
8662     ok(hres == S_OK && V_I4(&result) == -1,
8663         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8664
8665     hres = pVarImp(&left, &dec, &result);
8666     ok(hres == S_OK && V_VT(&result) == VT_I4,
8667         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8668         S_OK, hres, vtstr(V_VT(&result)));
8669     ok(hres == S_OK && V_I4(&result) == -1,
8670         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8671
8672     hres = pVarImp(&dec, &dec, &result);
8673     ok(hres == S_OK && V_VT(&result) == VT_I4,
8674         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8675         S_OK, hres, vtstr(V_VT(&result)));
8676     ok(hres == S_OK && V_I4(&result) == -1,
8677         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8678
8679     if (HAVE_OLEAUT32_I8)
8680     {
8681         hres = pVarImp(&dec, &right, &result);
8682         ok(hres == S_OK && V_VT(&result) == VT_I8,
8683             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8684             S_OK, hres, vtstr(V_VT(&result)));
8685         ok(hres == S_OK && V_I8(&result) == -3,
8686             "VARIMP: DECIMAL value 0x%x%08x, expected %d\n",
8687             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), -3);
8688     }
8689
8690     SysFreeString(false_str);
8691     SysFreeString(true_str);
8692 }
8693
8694 START_TEST(vartest)
8695 {
8696   init();
8697
8698   test_VariantInit();
8699   test_VariantClear();
8700   test_VariantCopy();
8701   test_VariantCopyInd();
8702   test_VarParseNumFromStr();
8703   test_VarNumFromParseNum();
8704   test_VarUdateFromDate();
8705   test_VarDateFromUdate();
8706   test_SystemTimeToVariantTime();
8707   test_VariantTimeToSystemTime();
8708   test_DosDateTimeToVariantTime();
8709   test_VariantTimeToDosDateTime();
8710   test_VarAbs();
8711   test_VarNot();
8712   test_VarSub();
8713   test_VarMod();
8714   test_VarFix();
8715   test_VarInt();
8716   test_VarNeg();
8717   test_VarRound();
8718   test_VarXor();
8719   test_VarOr();
8720   test_VarPow();
8721   test_VarEqv();
8722   test_VarMul();
8723   test_VarAdd();
8724   test_VarCmp(); /* Before test_VarCat() which needs VarCmp() */
8725   test_VarCat();
8726   test_VarAnd();
8727   test_VarDiv();
8728   test_VarIdiv();
8729   test_VarImp();
8730 }