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 #include <time.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winsock.h"
  31 #include "wine/test.h"
  32 #include "winuser.h"
  33 #include "wingdi.h"
  34 #include "winnls.h"
  35 #include "winerror.h"
  36 #include "winnt.h"
  37
  38 #include "wtypes.h"
  39 #include "oleauto.h"
  40
  41 static HMODULE hOleaut32;
  42
  43 static HRESULT (WINAPI *pVarUdateFromDate)(DATE,ULONG,UDATE*);
  44 static HRESULT (WINAPI *pVarDateFromUdate)(UDATE*,ULONG,DATE*);
  45 static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
  46 static INT (WINAPI *pVariantTimeToSystemTime)(double,LPSYSTEMTIME);
  47 static INT (WINAPI *pDosDateTimeToVariantTime)(USHORT,USHORT,double*);
  48 static INT (WINAPI *pVariantTimeToDosDateTime)(double,USHORT*,USHORT *);
  49
  50 /* Get a conversion function ptr, return if function not available */
  51 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
  52   if (!p##func) { trace("function " # func " not available, not testing it\n"); return; }
  53
  54 /* Have IRecordInfo data type? */
  55 static int HAVE_OLEAUT32_RECORD = 0;
  56 /* Have I8/UI8 data type? */
  57 static int HAVE_OLEAUT32_I8 = 0;
  58 /* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
  59 static int IS_ANCIENT = 0;
  60
  61 /* When comparing floating point values we cannot expect an exact match
  62  * because the rounding errors depend on the exact algorithm.
  63  */
  64 #define EQ_DOUBLE(a,b)     (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)
  65 #define EQ_FLOAT(a,b)      (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)
  66
  67 #define SKIPTESTS(a)  if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue
  68
  69 /* Allow our test macros to work for VT_NULL and VT_EMPTY too */
  70 #define V_EMPTY(v) V_I4(v)
  71 #define V_NULL(v) V_I4(v)
  72
  73 /* Size constraints for overflow tests */
  74 #define I1_MAX   0x7f
  75 #define I1_MIN   ((-I1_MAX)-1)
  76 #define UI1_MAX  0xff
  77 #define UI1_MIN  0
  78 #define I2_MAX   0x7fff
  79 #define I2_MIN   ((-I2_MAX)-1)
  80 #define UI2_MAX  0xffff
  81 #define UI2_MIN  0
  82 #define I4_MAX   0x7fffffff
  83 #define I4_MIN   ((-I4_MAX)-1)
  84 #define UI4_MAX  0xffffffff
  85 #define UI4_MIN  0
  86 #define I8_MAX   (((LONGLONG)I4_MAX << 32) | UI4_MAX)
  87 #define I8_MIN   ((-I8_MAX)-1)
  88 #define UI8_MAX  (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
  89 #define UI8_MIN  0
  90 #define DATE_MAX 2958465
  91 #define DATE_MIN -657434
  92 #define R4_MAX FLT_MAX
  93 #define R4_MIN FLT_MIN
  94 #define R8_MAX DBL_MAX
  95 #define R8_MIN DBL_MIN
  96
  97 static void init(void)
  98 {
  99   hOleaut32 = GetModuleHandle("oleaut32.dll");
 100
 101   /* Is a given function exported from oleaut32? */
 102 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
 103
 104   HAVE_OLEAUT32_I8 = HAVE_FUNC(VarI8FromI1);
 105   if (!HAVE_OLEAUT32_I8)
 106       skip("No support for I8 and UI8 data types\n");
 107
 108   HAVE_OLEAUT32_RECORD = HAVE_FUNC(SafeArraySetRecordInfo);
 109   IS_ANCIENT = (!HAVE_FUNC(VarI1FromI2));
 110
 111 #undef HAVE_FUNC
 112 }
 113
 114 /* Functions to set a DECIMAL */
 115 static void setdec(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG64 lo64)
 116 {
 117     S(U(*dec)).scale = scl;
 118     S(U(*dec)).sign = sgn;
 119     dec->Hi32 = hi32;
 120     U1(*dec).Lo64 = lo64;
 121 }
 122
 123 static void setdec64(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG mid32, ULONG lo32)
 124 {
 125     S(U(*dec)).scale = scl;
 126     S(U(*dec)).sign = sgn;
 127     dec->Hi32 = hi32;
 128     S1(U1(*dec)).Mid32 = mid32;
 129     S1(U1(*dec)).Lo32 = lo32;
 130 }
 131
 132 static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
 133 {
 134     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 135     return *str1 - *str2;
 136 }
 137
 138 /* return the string text of a given variant type */
 139 static char vtstr_buffer[16][256];
 140 static int vtstr_current=0;
 141 static const char *vtstr(int x)
 142 {
 143     switch(x) {
 144 #define CASE(vt) case VT_##vt: return #vt
 145     CASE(EMPTY);
 146     CASE(NULL);
 147     CASE(I2);
 148     CASE(I4);
 149     CASE(R4);
 150     CASE(R8);
 151     CASE(CY);
 152     CASE(DATE);
 153     CASE(BSTR);
 154     CASE(DISPATCH);
 155     CASE(ERROR);
 156     CASE(BOOL);
 157     CASE(VARIANT);
 158     CASE(UNKNOWN);
 159     CASE(DECIMAL);
 160     CASE(I1);
 161     CASE(UI1);
 162     CASE(UI2);
 163     CASE(UI4);
 164     CASE(I8);
 165     CASE(UI8);
 166     CASE(INT);
 167     CASE(UINT);
 168     CASE(VOID);
 169     CASE(HRESULT);
 170     CASE(PTR);
 171     CASE(SAFEARRAY);
 172     CASE(CARRAY);
 173     CASE(USERDEFINED);
 174     CASE(LPSTR);
 175     CASE(LPWSTR);
 176     CASE(RECORD);
 177     CASE(INT_PTR);
 178     CASE(UINT_PTR);
 179     CASE(FILETIME);
 180     CASE(BLOB);
 181     CASE(STREAM);
 182     CASE(STORAGE);
 183     CASE(STREAMED_OBJECT);
 184     CASE(STORED_OBJECT);
 185     CASE(BLOB_OBJECT);
 186     CASE(CF);
 187     CASE(CLSID);
 188     CASE(VERSIONED_STREAM);
 189     CASE(VECTOR);
 190     CASE(ARRAY);
 191     CASE(BYREF);
 192     CASE(RESERVED);
 193     CASE(ILLEGAL);
 194 #undef CASE
 195
 196     case 0xfff:
 197         return "VT_BSTR_BLOB/VT_ILLEGALMASKED/VT_TYPEMASK";
 198
 199     default:
 200         vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
 201         sprintf(vtstr_buffer[vtstr_current], "unknown variant type %d", x);
 202         return vtstr_buffer[vtstr_current++];
 203     }
 204 }
 205
 206 static const char *variantstr( const VARIANT *var )
 207 {
 208     vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
 209     switch(V_VT(var))
 210     {
 211     case VT_I1:
 212         sprintf( vtstr_buffer[vtstr_current], "VT_I1(%d)", V_I1(var) ); break;
 213     case VT_I2:
 214         sprintf( vtstr_buffer[vtstr_current], "VT_I2(%d)", V_I2(var) ); break;
 215     case VT_I4:
 216         sprintf( vtstr_buffer[vtstr_current], "VT_I4(%d)", V_I4(var) ); break;
 217     case VT_INT:
 218         sprintf( vtstr_buffer[vtstr_current], "VT_INT(%d)", V_INT(var) ); break;
 219     case VT_I8:
 220         sprintf( vtstr_buffer[vtstr_current], "VT_I8(%x%08x)", (UINT)(V_I8(var) >> 32), (UINT)V_I8(var) ); break;
 221     case VT_UI8:
 222         sprintf( vtstr_buffer[vtstr_current], "VT_UI8(%x%08x)", (UINT)(V_UI8(var) >> 32), (UINT)V_UI8(var) ); break;
 223     case VT_R4:
 224         sprintf( vtstr_buffer[vtstr_current], "VT_R4(%g)", V_R4(var) ); break;
 225     case VT_R8:
 226         sprintf( vtstr_buffer[vtstr_current], "VT_R8(%g)", V_R8(var) ); break;
 227     case VT_UI1:
 228         sprintf( vtstr_buffer[vtstr_current], "VT_UI1(%u)", V_UI1(var) ); break;
 229     case VT_UI2:
 230         sprintf( vtstr_buffer[vtstr_current], "VT_UI2(%u)", V_UI2(var) ); break;
 231     case VT_UI4:
 232         sprintf( vtstr_buffer[vtstr_current], "VT_UI4(%u)", V_UI4(var) ); break;
 233     case VT_UINT:
 234         sprintf( vtstr_buffer[vtstr_current], "VT_UINT(%d)", V_UINT(var) ); break;
 235     case VT_CY:
 236         sprintf( vtstr_buffer[vtstr_current], "VT_CY(%x%08x)", S(V_CY(var)).Hi, S(V_CY(var)).Lo ); break;
 237     case VT_DATE:
 238         sprintf( vtstr_buffer[vtstr_current], "VT_DATE(%g)", V_DATE(var) ); break;
 239     default:
 240         return vtstr(V_VT(var));
 241     }
 242     return vtstr_buffer[vtstr_current++];
 243 }
 244
 245 static BOOL is_expected_variant( const VARIANT *result, const VARIANT *expected )
 246 {
 247     if (V_VT(result) != V_VT(expected)) return FALSE;
 248     switch(V_VT(expected))
 249     {
 250     case VT_EMPTY:
 251     case VT_NULL:
 252         return TRUE;
 253
 254 #define CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))
 255     CASE(BOOL);
 256     CASE(I1);
 257     CASE(UI1);
 258     CASE(I2);
 259     CASE(UI2);
 260     CASE(I4);
 261     CASE(UI4);
 262     CASE(I8);
 263     CASE(UI8);
 264     CASE(INT);
 265     CASE(UINT);
 266 #undef CASE
 267
 268     case VT_DATE:
 269         return EQ_FLOAT(V_DATE(result), V_DATE(expected));
 270     case VT_R4:
 271         return EQ_FLOAT(V_R4(result), V_R4(expected));
 272     case VT_R8:
 273         return EQ_FLOAT(V_R8(result), V_R8(expected));
 274     case VT_CY:
 275         return (V_CY(result).int64 == V_CY(expected).int64);
 276     case VT_BSTR:
 277         return !lstrcmpW( V_BSTR(result), V_BSTR(expected) );
 278     case VT_DECIMAL:
 279         return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
 280     default:
 281         ok(0, "unhandled variant type %s\n",vtstr(V_VT(expected)));
 282         return 0;
 283     }
 284 }
 285
 286 static void test_var_call1( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT),
 287                            VARIANT *arg, VARIANT *expected )
 288 {
 289     VARIANT old_arg = *arg;
 290     VARIANT result;
 291     HRESULT hres;
 292
 293     memset( &result, 0, sizeof(result) );
 294     hres = func( arg, &result );
 295     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
 296     if (hres == S_OK)
 297         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 298                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
 299     ok_(__FILE__,line)( is_expected_variant( arg, &old_arg ), "Modified argument %s / %s\n",
 300                         variantstr(&old_arg), variantstr(arg));
 301     VariantClear( &result );
 302 }
 303
 304 static void test_var_call2( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT,LPVARIANT),
 305                             VARIANT *left, VARIANT *right, VARIANT *expected )
 306 {
 307     VARIANT old_left = *left, old_right = *right;
 308     VARIANT result;
 309     HRESULT hres;
 310
 311     memset( &result, 0, sizeof(result) );
 312     hres = func( left, right, &result );
 313     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
 314     if (hres == S_OK)
 315         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 316                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
 317     ok_(__FILE__,line)( is_expected_variant( left, &old_left ), "Modified left argument %s / %s\n",
 318                         variantstr(&old_left), variantstr(left));
 319     ok_(__FILE__,line)( is_expected_variant( right, &old_right ), "Modified right argument %s / %s\n",
 320                         variantstr(&old_right), variantstr(right));
 321     VariantClear( &result );
 322 }
 323
 324
 325 static void test_VariantInit(void)
 326 {
 327   VARIANTARG v1, v2;
 328
 329   /* Test that VariantInit() only sets the type */
 330   memset(&v1, -1, sizeof(v1));
 331   v2 = v1;
 332   V_VT(&v2) = VT_EMPTY;
 333   VariantInit(&v1);
 334   ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
 335 }
 336
 337 /* All possible combinations of extra V_VT() flags */
 338 static const VARTYPE ExtraFlags[16] =
 339 {
 340   0,
 341   VT_VECTOR,
 342   VT_ARRAY,
 343   VT_BYREF,
 344   VT_RESERVED,
 345   VT_VECTOR|VT_ARRAY,
 346   VT_VECTOR|VT_BYREF,
 347   VT_VECTOR|VT_RESERVED,
 348   VT_VECTOR|VT_ARRAY|VT_BYREF,
 349   VT_VECTOR|VT_ARRAY|VT_RESERVED,
 350   VT_VECTOR|VT_BYREF|VT_RESERVED,
 351   VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
 352   VT_ARRAY|VT_BYREF,
 353   VT_ARRAY|VT_RESERVED,
 354   VT_ARRAY|VT_BYREF|VT_RESERVED,
 355   VT_BYREF|VT_RESERVED,
 356 };
 357
 358 /* Determine if a vt is valid for VariantClear() */
 359 static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
 360 {
 361   int ret = 0;
 362
 363   /* Only the following flags/types are valid */
 364   if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
 365       vt != (VARTYPE)15 &&
 366       (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
 367       (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
 368       (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
 369        extraFlags == (VT_ARRAY|VT_BYREF)))
 370     ret = 1; /* ok */
 371
 372   if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
 373       ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
 374     ret = 0; /* Old versions of oleaut32 */
 375   return ret;
 376 }
 377
 378 typedef struct
 379 {
 380     const IUnknownVtbl *lpVtbl;
 381     LONG               ref;
 382     LONG               events;
 383 } test_VariantClearImpl;
 384
 385 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
 386 {
 387     test_VariantClearImpl *This = (test_VariantClearImpl *)iface;
 388     This->events |= 0x1;
 389     return E_NOINTERFACE;
 390 }
 391
 392 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
 393     test_VariantClearImpl *This = (test_VariantClearImpl *)iface;
 394     This->events |= 0x2;
 395     return InterlockedIncrement(&This->ref);
 396 }
 397
 398 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
 399     test_VariantClearImpl *This = (test_VariantClearImpl *)iface;
 400     /* static class, won't be  freed */
 401     This->events |= 0x4;
 402     return InterlockedDecrement(&This->ref);
 403 }
 404
 405 static const IUnknownVtbl test_VariantClear_vtbl = {
 406     VC_QueryInterface,
 407     VC_AddRef,
 408     VC_Release,
 409 };
 410
 411 static test_VariantClearImpl test_myVariantClearImpl = {&test_VariantClear_vtbl, 1, 0};
 412
 413 static void test_VariantClear(void)
 414 {
 415   HRESULT hres;
 416   VARIANTARG v;
 417   VARIANT v2;
 418   size_t i;
 419   LONG i4;
 420   IUnknown *punk;
 421
 422   /* Crashes: Native does not test input for NULL, so neither does Wine */
 423   if (0) hres = VariantClear(NULL);
 424
 425   /* Only the type field is set, to VT_EMPTY */
 426   V_VT(&v) = VT_UI4;
 427   V_UI4(&v) = ~0u;
 428   hres = VariantClear(&v);
 429   ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
 430      (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
 431      "VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
 432   ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
 433
 434   /* Test all possible V_VT values.
 435    * Also demonstrates that null pointers in 'v' are not dereferenced.
 436    * Individual variant tests should test VariantClear() with non-NULL values.
 437    */
 438   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 439   {
 440     VARTYPE vt;
 441
 442     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 443     {
 444       HRESULT hExpected = DISP_E_BADVARTYPE;
 445
 446       SKIPTESTS(vt);
 447
 448       memset(&v, 0, sizeof(v));
 449       V_VT(&v) = vt | ExtraFlags[i];
 450
 451       hres = VariantClear(&v);
 452
 453       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 454         hExpected = S_OK;
 455
 456       ok(hres == hExpected, "VariantClear: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
 457          hExpected, hres, vt, ExtraFlags[i]);
 458     }
 459   }
 460
 461   /* Some BYREF tests with non-NULL ptrs */
 462
 463   /* VARIANT BYREF */
 464   V_VT(&v2) = VT_I4;
 465   V_I4(&v2) = 0x1234;
 466   V_VT(&v) = VT_VARIANT | VT_BYREF;
 467   V_VARIANTREF(&v) = &v2;
 468
 469   hres = VariantClear(&v);
 470   ok(hres == S_OK, "ret %08x\n", hres);
 471   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 472   ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
 473   ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
 474   ok(V_I4(&v2) == 0x1234, "i4 %04x\n", V_I4(&v2));
 475
 476   /* I4 BYREF */
 477   i4 = 0x4321;
 478   V_VT(&v) = VT_I4 | VT_BYREF;
 479   V_I4REF(&v) = &i4;
 480
 481   hres = VariantClear(&v);
 482   ok(hres == S_OK, "ret %08x\n", hres);
 483   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 484   ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
 485   ok(i4 == 0x4321, "i4 changed %08x\n", i4);
 486
 487
 488   /* UNKNOWN */
 489   V_VT(&v) = VT_UNKNOWN;
 490   V_UNKNOWN(&v) = (IUnknown*)&test_myVariantClearImpl;
 491   test_myVariantClearImpl.events = 0;
 492   hres = VariantClear(&v);
 493   ok(hres == S_OK, "ret %08x\n", hres);
 494   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 495   ok(V_UNKNOWN(&v) == (IUnknown*)&test_myVariantClearImpl, "unknown %p\n", V_UNKNOWN(&v));
 496   /* Check that Release got called, but nothing else */
 497   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 498
 499   /* UNKNOWN BYREF */
 500   punk = (IUnknown*)&test_myVariantClearImpl;
 501   V_VT(&v) = VT_UNKNOWN | VT_BYREF;
 502   V_UNKNOWNREF(&v) = &punk;
 503   test_myVariantClearImpl.events = 0;
 504   hres = VariantClear(&v);
 505   ok(hres == S_OK, "ret %08x\n", hres);
 506   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 507   ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
 508   /* Check that nothing got called */
 509   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 510
 511   /* DISPATCH */
 512   V_VT(&v) = VT_DISPATCH;
 513   V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
 514   test_myVariantClearImpl.events = 0;
 515   hres = VariantClear(&v);
 516   ok(hres == S_OK, "ret %08x\n", hres);
 517   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 518   ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
 519   /* Check that Release got called, but nothing else */
 520   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 521
 522   /* DISPATCH BYREF */
 523   punk = (IUnknown*)&test_myVariantClearImpl;
 524   V_VT(&v) = VT_DISPATCH | VT_BYREF;
 525   V_DISPATCHREF(&v) = (IDispatch**)&punk;
 526   test_myVariantClearImpl.events = 0;
 527   hres = VariantClear(&v);
 528   ok(hres == S_OK, "ret %08x\n", hres);
 529   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 530   ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
 531   /* Check that nothing got called */
 532   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
 533 }
 534
 535 static void test_VariantCopy(void)
 536 {
 537   VARIANTARG vSrc, vDst;
 538   VARTYPE vt;
 539   size_t i;
 540   HRESULT hres, hExpected;
 541
 542   /* Establish that the failure/other cases are dealt with. Individual tests
 543    * for each type should verify that data is copied correctly, references
 544    * are updated, etc.
 545    */
 546
 547   /* vSrc == vDst */
 548   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 549   {
 550     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 551     {
 552       SKIPTESTS(vt);
 553
 554       memset(&vSrc, 0, sizeof(vSrc));
 555       V_VT(&vSrc) = vt | ExtraFlags[i];
 556
 557       hExpected = DISP_E_BADVARTYPE;
 558       /* src is allowed to be a VT_CLSID */
 559       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 560         hExpected = S_OK;
 561
 562       hres = VariantCopy(&vSrc, &vSrc);
 563
 564       ok(hres == hExpected,
 565          "Copy(src==dst): expected 0x%X, got 0x%X for src==dest vt %d|0x%X\n",
 566          hExpected, hres, vt, ExtraFlags[i]);
 567     }
 568   }
 569
 570   /* Test that if VariantClear() fails on dest, the function fails. This also
 571    * shows that dest is in fact cleared and not just overwritten
 572    */
 573   memset(&vSrc, 0, sizeof(vSrc));
 574   V_VT(&vSrc) = VT_UI1;
 575
 576   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 577   {
 578     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 579     {
 580       SKIPTESTS(vt);
 581
 582       hExpected = DISP_E_BADVARTYPE;
 583
 584       memset(&vDst, 0, sizeof(vDst));
 585       V_VT(&vDst) = vt | ExtraFlags[i];
 586
 587       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 588         hExpected = S_OK;
 589
 590       hres = VariantCopy(&vDst, &vSrc);
 591
 592       ok(hres == hExpected,
 593          "Copy(bad dst): expected 0x%X, got 0x%X for dest vt %d|0x%X\n",
 594          hExpected, hres, vt, ExtraFlags[i]);
 595       if (hres == S_OK)
 596         ok(V_VT(&vDst) == VT_UI1,
 597            "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 598     }
 599   }
 600
 601   /* Test that VariantClear() checks vSrc for validity before copying */
 602   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 603   {
 604     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 605     {
 606       SKIPTESTS(vt);
 607
 608       hExpected = DISP_E_BADVARTYPE;
 609
 610       memset(&vDst, 0, sizeof(vDst));
 611       V_VT(&vDst) = VT_EMPTY;
 612
 613       memset(&vSrc, 0, sizeof(vSrc));
 614       V_VT(&vSrc) = vt | ExtraFlags[i];
 615
 616       /* src is allowed to be a VT_CLSID */
 617       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 618         hExpected = S_OK;
 619
 620       hres = VariantCopy(&vDst, &vSrc);
 621
 622       ok(hres == hExpected,
 623          "Copy(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 624          hExpected, hres, vt, ExtraFlags[i]);
 625       if (hres == S_OK)
 626       {
 627         ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
 628            "Copy(bad src): expected vt = %d, got %d\n",
 629            vt | ExtraFlags[i], V_VT(&vDst));
 630         VariantClear(&vDst);
 631       }
 632     }
 633   }
 634
 635   /* Test that copying a NULL BSTR results in an empty BSTR */
 636   memset(&vDst, 0, sizeof(vDst));
 637   V_VT(&vDst) = VT_EMPTY;
 638   memset(&vSrc, 0, sizeof(vSrc));
 639   V_VT(&vSrc) = VT_BSTR;
 640   hres = VariantCopy(&vDst, &vSrc);
 641   ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
 642   if (hres == S_OK)
 643   {
 644     ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
 645        "Copy(NULL BSTR): should have non-NULL result\n");
 646     if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
 647     {
 648       ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
 649     }
 650     VariantClear(&vDst);
 651   }
 652 }
 653
 654 /* Determine if a vt is valid for VariantCopyInd() */
 655 static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
 656 {
 657   int ret = 0;
 658
 659   if ((extraFlags & VT_ARRAY) ||
 660      (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
 661      !(extraFlags & (VT_VECTOR|VT_RESERVED))))
 662   {
 663     ret = 1; /* ok */
 664   }
 665   return ret;
 666 }
 667
 668 static void test_VariantCopyInd(void)
 669 {
 670   VARIANTARG vSrc, vDst, vRef, vRef2;
 671   VARTYPE vt;
 672   size_t i;
 673   BYTE buffer[64];
 674   HRESULT hres, hExpected;
 675
 676   memset(buffer, 0, sizeof(buffer));
 677
 678   /* vSrc == vDst */
 679   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 680   {
 681     if (ExtraFlags[i] & VT_ARRAY)
 682       continue; /* Native crashes on NULL safearray */
 683
 684     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 685     {
 686       SKIPTESTS(vt);
 687
 688       memset(&vSrc, 0, sizeof(vSrc));
 689       V_VT(&vSrc) = vt | ExtraFlags[i];
 690
 691       hExpected = DISP_E_BADVARTYPE;
 692       if (!(ExtraFlags[i] & VT_BYREF))
 693       {
 694         /* if src is not by-reference, acts as VariantCopy() */
 695         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 696           hExpected = S_OK;
 697       }
 698       else
 699       {
 700         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 701             vt == VT_DISPATCH || vt == VT_RECORD)
 702           continue; /* Need valid ptrs for deep copies */
 703
 704         V_BYREF(&vSrc) = &buffer;
 705         hExpected = E_INVALIDARG;
 706
 707         if ((vt == VT_I8 || vt == VT_UI8) &&
 708             ExtraFlags[i] == VT_BYREF)
 709         {
 710           if (HAVE_OLEAUT32_I8)
 711             hExpected = S_OK; /* Only valid if I8 is a known type */
 712         }
 713         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 714           hExpected = S_OK;
 715       }
 716
 717       hres = VariantCopyInd(&vSrc, &vSrc);
 718
 719       ok(hres == hExpected,
 720          "CopyInd(src==dst): expected 0x%X, got 0x%X for src==dst vt %d|0x%X\n",
 721          hExpected, hres, vt, ExtraFlags[i]);
 722     }
 723   }
 724
 725   /* Bad dest */
 726   memset(&vSrc, 0, sizeof(vSrc));
 727   V_VT(&vSrc) = VT_UI1|VT_BYREF;
 728   V_BYREF(&vSrc) = &buffer;
 729
 730   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 731   {
 732     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 733     {
 734       SKIPTESTS(vt);
 735
 736       memset(&vDst, 0, sizeof(vDst));
 737       V_VT(&vDst) = vt | ExtraFlags[i];
 738
 739       hExpected = DISP_E_BADVARTYPE;
 740
 741       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 742         hExpected = S_OK;
 743
 744       hres = VariantCopyInd(&vDst, &vSrc);
 745
 746       ok(hres == hExpected,
 747          "CopyInd(bad dst): expected 0x%X, got 0x%X for dst vt %d|0x%X\n",
 748          hExpected, hres, vt, ExtraFlags[i]);
 749       if (hres == S_OK)
 750         ok(V_VT(&vDst) == VT_UI1,
 751            "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 752     }
 753   }
 754
 755   /* bad src */
 756   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 757   {
 758     if (ExtraFlags[i] & VT_ARRAY)
 759       continue; /* Native crashes on NULL safearray */
 760
 761     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 762     {
 763       SKIPTESTS(vt);
 764
 765       memset(&vDst, 0, sizeof(vDst));
 766       V_VT(&vDst) = VT_EMPTY;
 767
 768       memset(&vSrc, 0, sizeof(vSrc));
 769       V_VT(&vSrc) = vt | ExtraFlags[i];
 770
 771       hExpected = DISP_E_BADVARTYPE;
 772       if (!(ExtraFlags[i] & VT_BYREF))
 773       {
 774         /* if src is not by-reference, acts as VariantCopy() */
 775         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 776           hExpected = S_OK;
 777       }
 778       else
 779       {
 780         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 781             vt == VT_DISPATCH || vt == VT_RECORD)
 782           continue; /* Need valid ptrs for deep copies, see vartype.c */
 783
 784         V_BYREF(&vSrc) = &buffer;
 785
 786         hExpected = E_INVALIDARG;
 787
 788         if ((vt == VT_I8 || vt == VT_UI8) &&
 789             ExtraFlags[i] == VT_BYREF)
 790         {
 791           if (HAVE_OLEAUT32_I8)
 792             hExpected = S_OK; /* Only valid if I8 is a known type */
 793         }
 794         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 795           hExpected = S_OK;
 796       }
 797
 798       hres = VariantCopyInd(&vDst, &vSrc);
 799
 800       ok(hres == hExpected,
 801          "CopyInd(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
 802          hExpected, hres, vt, ExtraFlags[i]);
 803       if (hres == S_OK)
 804       {
 805         if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
 806         {
 807           /* Type of vDst should be the type of the referenced variant.
 808            * Since we set the buffer to all zeros, its type should be
 809            * VT_EMPTY.
 810            */
 811           ok(V_VT(&vDst) == VT_EMPTY,
 812              "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
 813              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 814         }
 815         else
 816         {
 817           ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
 818              "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
 819              vt, ExtraFlags[i] & ~VT_BYREF,
 820              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 821         }
 822         VariantClear(&vDst);
 823       }
 824     }
 825   }
 826
 827   /* By-reference variants are dereferenced */
 828   V_VT(&vRef) = VT_UI1;
 829   V_UI1(&vRef) = 0x77;
 830   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 831   V_VARIANTREF(&vSrc) = &vRef;
 832   VariantInit(&vDst);
 833
 834   hres = VariantCopyInd(&vDst, &vSrc);
 835   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
 836      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 837       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 838
 839   /* By-reference variant to a by-reference type succeeds */
 840   V_VT(&vRef) = VT_UI1|VT_BYREF;
 841   V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
 842   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 843   V_VARIANTREF(&vSrc) = &vRef;
 844   VariantInit(&vDst);
 845
 846   hres = VariantCopyInd(&vDst, &vSrc);
 847   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
 848      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 849       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 850
 851   /* But a by-reference variant to a by-reference variant fails */
 852   V_VT(&vRef2) = VT_UI1;
 853   V_UI1(&vRef2) = 0x77;
 854   V_VT(&vRef) = VT_VARIANT|VT_BYREF;
 855   V_VARIANTREF(&vRef) = &vRef2;
 856   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 857   V_VARIANTREF(&vSrc) = &vRef;
 858   VariantInit(&vDst);
 859
 860   hres = VariantCopyInd(&vDst, &vSrc);
 861   ok(hres == E_INVALIDARG,
 862      "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08x\n", hres);
 863 }
 864
 865 static HRESULT (WINAPI *pVarParseNumFromStr)(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
 866
 867 /* Macros for converting and testing the result of VarParseNumFromStr */
 868 #define FAILDIG 255
 869
 870 static HRESULT convert_str( const char *str, INT dig, ULONG flags,
 871                             NUMPARSE *np, BYTE rgb[128], LCID lcid )
 872 {
 873     OLECHAR buff[128];
 874     MultiByteToWideChar( CP_ACP,0, str, -1, buff, sizeof(buff)/sizeof(WCHAR) );
 875     memset( rgb, FAILDIG, 128 );
 876     memset( np, 255, sizeof(*np) );
 877     np->cDig = dig;
 878     np->dwInFlags = flags;
 879     return pVarParseNumFromStr( buff, lcid, LOCALE_NOUSEROVERRIDE, np, rgb);
 880 }
 881
 882 static void expect_NumFromStr( int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c,
 883                                INT d, INT e, INT f )
 884 {
 885     if (hres == (HRESULT)S_OK)
 886     {
 887         ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
 888         ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%x, got 0x%x\n", b, np->dwInFlags);
 889         ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%x, got 0x%x\n", c, np->dwOutFlags);
 890         ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
 891         ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
 892         ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
 893     }
 894 }
 895
 896 #define CONVERTN(str,dig,flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )
 897 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
 898 #define EXPECT(a,b,c,d,e,f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )
 899 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
 900 #define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)
 901 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
 902
 903 static void test_VarParseNumFromStr(void)
 904 {
 905   HRESULT hres;
 906   /* Ensure all tests are using the same locale characters for '$', ',' etc */
 907   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 908   NUMPARSE np;
 909   BYTE rgb[128];
 910
 911   /** No flags **/
 912
 913   CHECKPTR(VarParseNumFromStr);
 914
 915   /* Consume a single digit */
 916   CONVERT("7", 0);
 917   EXPECT(1,0,0,1,0,0);
 918   EXPECT2(7,FAILDIG);
 919
 920   /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
 921   CONVERT("10", 0);
 922   EXPECT(1,0,0,2,0,1);
 923   /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
 924    * but then excludes them from the returned cDig count.
 925    * In our implementation we don't bother writing them at all.
 926    */
 927   EXPECTRGB(0, 1);
 928
 929   /* if cDig is too small and numbers follow, sets INEXACT */
 930   CONVERTN("11",1, 0);
 931   EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
 932   EXPECT2(1,FAILDIG);
 933
 934   /* Strips leading zeros */
 935   CONVERT("01", 0);
 936   EXPECT(1,0,0,2,0,0);
 937   EXPECT2(1,FAILDIG);
 938
 939   /* Strips leading zeros */
 940   CONVERTN("01",1, 0);
 941   EXPECT(1,0,0,2,0,0);
 942   EXPECT2(1,FAILDIG);
 943
 944
 945   /* Fails on non digits */
 946   CONVERT("a", 0);
 947   EXPECTFAIL;
 948   EXPECTRGB(0,FAILDIG);
 949
 950   /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
 951
 952   /* Without flag, fails on whitespace */
 953   CONVERT(" 0", 0);
 954   EXPECTFAIL;
 955   EXPECTRGB(0,FAILDIG);
 956
 957
 958   /* With flag, consumes whitespace */
 959   CONVERT(" 0", NUMPRS_LEADING_WHITE);
 960   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 961   EXPECT2(0,FAILDIG);
 962
 963   /* Test TAB once, then assume it acts as space for all cases */
 964   CONVERT("\t0", NUMPRS_LEADING_WHITE);
 965   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 966   EXPECT2(0,FAILDIG);
 967
 968
 969   /* Doesn't pick up trailing whitespace without flag */
 970   CONVERT("0 ", 0);
 971   EXPECT(1,0,0,1,0,0);
 972   EXPECT2(0,FAILDIG);
 973
 974   /* With flag, consumes trailing whitespace */
 975   CONVERT("0 ", NUMPRS_TRAILING_WHITE);
 976   EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
 977   EXPECT2(0,FAILDIG);
 978
 979   /* Leading flag only consumes leading */
 980   CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
 981   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 982   EXPECT2(0,FAILDIG);
 983
 984   /* Both flags consumes both */
 985   CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
 986   EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
 987   EXPECT2(0,FAILDIG);
 988
 989   /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
 990
 991   /* Without flag, fails on + */
 992   CONVERT("+0", 0);
 993   EXPECTFAIL;
 994   EXPECTRGB(0,FAILDIG);
 995
 996   /* With flag, consumes + */
 997   CONVERT("+0", NUMPRS_LEADING_PLUS);
 998   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
 999   EXPECT2(0,FAILDIG);
1000
1001   /* Without flag, doesn't consume trailing + */
1002   CONVERT("0+", 0);
1003   EXPECT(1,0,0,1,0,0);
1004   EXPECT2(0,FAILDIG);
1005
1006   /* With flag, consumes trailing + */
1007   CONVERT("0+", NUMPRS_TRAILING_PLUS);
1008   EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
1009   EXPECT2(0,FAILDIG);
1010
1011   /* With leading flag, doesn't consume trailing + */
1012   CONVERT("+0+", NUMPRS_LEADING_PLUS);
1013   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1014   EXPECT2(0,FAILDIG);
1015
1016   /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
1017   CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
1018   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1019   EXPECT2(0,FAILDIG);
1020
1021   /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
1022
1023   /* Without flag, fails on - */
1024   CONVERT("-0", 0);
1025   EXPECTFAIL;
1026   EXPECTRGB(0,FAILDIG);
1027
1028   /* With flag, consumes - */
1029   CONVERT("-0", NUMPRS_LEADING_MINUS);
1030   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1031   EXPECT2(0,FAILDIG);
1032
1033   /* Without flag, doesn't consume trailing - */
1034   CONVERT("0-", 0);
1035   EXPECT(1,0,0,1,0,0);
1036   EXPECT2(0,FAILDIG);
1037
1038   /* With flag, consumes trailing - */
1039   CONVERT("0-", NUMPRS_TRAILING_MINUS);
1040   EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
1041   EXPECT2(0,FAILDIG);
1042
1043   /* With leading flag, doesn't consume trailing - */
1044   CONVERT("-0-", NUMPRS_LEADING_MINUS);
1045   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1046   EXPECT2(0,FAILDIG);
1047
1048   /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
1049   CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
1050   EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1051   EXPECT2(0,FAILDIG);
1052
1053   /** NUMPRS_HEX_OCT **/
1054
1055   /* Could be hex, octal or decimal - With flag reads as decimal */
1056   CONVERT("0", NUMPRS_HEX_OCT);
1057   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1058   EXPECT2(0,FAILDIG);
1059
1060   /* Doesn't recognise hex in .asm syntax */
1061   CONVERT("0h", NUMPRS_HEX_OCT);
1062   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1063   EXPECT2(0,FAILDIG);
1064
1065   /* Doesn't fail with valid leading string but no digits */
1066   CONVERT("0x", NUMPRS_HEX_OCT);
1067   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1068   EXPECT2(0,FAILDIG);
1069
1070   /* Doesn't recognise hex format numbers at all! */
1071   CONVERT("0x0", NUMPRS_HEX_OCT);
1072   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1073   EXPECT2(0,FAILDIG);
1074
1075   /* Doesn't recognise plain hex digits either */
1076   CONVERT("FE", NUMPRS_HEX_OCT);
1077   EXPECTFAIL;
1078   EXPECTRGB(0,FAILDIG);
1079
1080   /* Octal */
1081   CONVERT("0100", NUMPRS_HEX_OCT);
1082   EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
1083   EXPECTRGB(0,1);
1084   EXPECTRGB(1,0);
1085   EXPECTRGB(2,0);
1086   EXPECTRGB(3,FAILDIG);
1087
1088   /* VB hex */
1089   CONVERT("&HF800", NUMPRS_HEX_OCT);
1090   EXPECT(4,NUMPRS_HEX_OCT,0x40,6,4,0);
1091   EXPECTRGB(0,15);
1092   EXPECTRGB(1,8);
1093   EXPECTRGB(2,0);
1094   EXPECTRGB(3,0);
1095   EXPECTRGB(4,FAILDIG);
1096
1097   /* VB hex lower case and leading zero */
1098   CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
1099   EXPECT(6,NUMPRS_HEX_OCT,0x40,9,4,0);
1100   EXPECTRGB(0,10);
1101   EXPECTRGB(1,11);
1102   EXPECTRGB(2,12);
1103   EXPECTRGB(3,13);
1104   EXPECTRGB(4,14);
1105   EXPECTRGB(5,15);
1106   EXPECTRGB(6,FAILDIG);
1107
1108   /* VB oct */
1109   CONVERT("&O300", NUMPRS_HEX_OCT);
1110   EXPECT(3,NUMPRS_HEX_OCT,0x40,5,3,0);
1111   EXPECTRGB(0,3);
1112   EXPECTRGB(1,0);
1113   EXPECTRGB(2,0);
1114   EXPECTRGB(3,FAILDIG);
1115
1116   /* VB oct lower case and leading zero */
1117   CONVERT("&o0777", NUMPRS_HEX_OCT);
1118   EXPECT(3,NUMPRS_HEX_OCT,0x40,6,3,0);
1119   EXPECTRGB(0,7);
1120   EXPECTRGB(1,7);
1121   EXPECTRGB(2,7);
1122   EXPECTRGB(3,FAILDIG);
1123
1124   /* VB oct char bigger than 7 */
1125   CONVERT("&o128", NUMPRS_HEX_OCT);
1126 /*
1127   Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
1128   EXPECTFAIL;
1129   EXPECTRGB(0,FAILDIG);
1130 */
1131   /** NUMPRS_PARENS **/
1132
1133   /* Empty parens = error */
1134   CONVERT("()", NUMPRS_PARENS);
1135   EXPECTFAIL;
1136   EXPECTRGB(0,FAILDIG);
1137
1138   /* With flag, trailing parens not consumed */
1139   CONVERT("0()", NUMPRS_PARENS);
1140   EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1141   EXPECT2(0,FAILDIG);
1142
1143   /* With flag, Number in parens made negative and parens consumed */
1144   CONVERT("(0)", NUMPRS_PARENS);
1145   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1146   EXPECT2(0,FAILDIG);
1147
1148   /** NUMPRS_THOUSANDS **/
1149
1150   /* With flag, thousands sep. not needed */
1151   CONVERT("0", NUMPRS_THOUSANDS);
1152   EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1153   EXPECT2(0,FAILDIG);
1154
1155   /* With flag, thousands sep. and following digits consumed */
1156   CONVERT("1,000", NUMPRS_THOUSANDS);
1157   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1158   EXPECTRGB(0,1);
1159
1160   /* With flag and decimal point, thousands sep. but not decimals consumed */
1161   CONVERT("1,000.0", NUMPRS_THOUSANDS);
1162   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1163   EXPECTRGB(0,1);
1164
1165   /** NUMPRS_CURRENCY **/
1166
1167   /* Without flag, chokes on currency sign */
1168   CONVERT("$11", 0);
1169   EXPECTFAIL;
1170   EXPECTRGB(0,FAILDIG);
1171
1172   /* With flag, consumes currency sign */
1173   CONVERT("$11", NUMPRS_CURRENCY);
1174   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1175   EXPECT2(1,1);
1176   EXPECTRGB(2,FAILDIG);
1177
1178   /* With flag only, doesn't consume decimal point */
1179   CONVERT("$11.1", NUMPRS_CURRENCY);
1180   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1181   EXPECT2(1,1);
1182   EXPECTRGB(2,FAILDIG);
1183
1184   /* With flag and decimal flag, consumes decimal point and following digits */
1185   CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1186   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1187   EXPECT2(1,1);
1188   EXPECTRGB(2,1);
1189   EXPECTRGB(3,FAILDIG);
1190
1191   /* Thousands flag can only be used with currency */
1192   CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1193   EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1194   EXPECT2(1,2);
1195   EXPECTRGB(2,3);
1196   EXPECTRGB(3,4);
1197   EXPECTRGB(4,FAILDIG);
1198
1199   /** NUMPRS_DECIMAL **/
1200
1201   /* With flag, consumes decimal point */
1202   CONVERT("1.1", NUMPRS_DECIMAL);
1203   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1204   EXPECT2(1,1);
1205   EXPECTRGB(2,FAILDIG);
1206
1207   /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1208   CONVERT("1.", NUMPRS_DECIMAL);
1209   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1210   EXPECT2(1,FAILDIG);
1211
1212   /* Consumes only one decimal point */
1213   CONVERT("1.1.", NUMPRS_DECIMAL);
1214   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1215   EXPECT2(1,1);
1216   EXPECTRGB(2,FAILDIG);
1217
1218   /** NUMPRS_EXPONENT **/
1219
1220   /* Without flag, doesn't consume exponent */
1221   CONVERT("1e1", 0);
1222   EXPECT(1,0,0,1,0,0);
1223   EXPECT2(1,FAILDIG);
1224
1225   /* With flag, consumes exponent */
1226   CONVERT("1e1", NUMPRS_EXPONENT);
1227   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1228   EXPECT2(1,FAILDIG);
1229
1230   /* Negative exponents are accepted without flags */
1231   CONVERT("1e-1", NUMPRS_EXPONENT);
1232   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1233   EXPECT2(1,FAILDIG);
1234
1235   /* As are positive exponents and leading exponent 0s */
1236   CONVERT("1e+01", NUMPRS_EXPONENT);
1237   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1238   EXPECT2(1,FAILDIG);
1239
1240   /* The same for zero exponents */
1241   CONVERT("1e0", NUMPRS_EXPONENT);
1242   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1243   EXPECT2(1,FAILDIG);
1244
1245   /* Sign on a zero exponent doesn't matter */
1246   CONVERT("1e+0", NUMPRS_EXPONENT);
1247   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1248   EXPECT2(1,FAILDIG);
1249
1250   CONVERT("1e-0", NUMPRS_EXPONENT);
1251   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1252   EXPECT2(1,FAILDIG);
1253
1254   /* Doesn't consume a real number exponent */
1255   CONVERT("1e1.", NUMPRS_EXPONENT);
1256   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1257   EXPECT2(1,FAILDIG);
1258
1259   /* Powers of 10 are calculated from the position of any decimal point */
1260   CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1261   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1262   EXPECT2(1,5);
1263
1264   CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1265   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1266   EXPECT2(1,5);
1267
1268   /** NUMPRS_USE_ALL **/
1269
1270   /* Flag expects all digits */
1271   CONVERT("0", NUMPRS_USE_ALL);
1272   EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1273   EXPECT2(0,FAILDIG);
1274
1275   /* Rejects anything trailing */
1276   CONVERT("0 ", NUMPRS_USE_ALL);
1277   EXPECTFAIL;
1278   EXPECT2(0,FAILDIG);
1279
1280   /* Unless consumed by trailing flag */
1281   CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1282   EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1283   EXPECT2(0,FAILDIG);
1284
1285   /** Combinations **/
1286
1287   /* Leading whitespace and plus, doesn't consume trailing whitespace */
1288   CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1289   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1290   EXPECT2(0,FAILDIG);
1291
1292   /* Order of whitespace and plus is unimportant */
1293   CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1294   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1295   EXPECT2(0,FAILDIG);
1296
1297   /* Leading whitespace can be repeated */
1298   CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1299   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1300   EXPECT2(0,FAILDIG);
1301
1302   /* But plus/minus etc. cannot */
1303   CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1304   EXPECTFAIL;
1305   EXPECTRGB(0,FAILDIG);
1306
1307   /* Inexact is not set if trailing zeros are removed */
1308   CONVERTN("10", 1, 0);
1309   EXPECT(1,0,0,2,0,1);
1310   EXPECT2(1,FAILDIG);
1311
1312   /* Make sure a leading 0 is stripped but decimals after it get read */
1313   CONVERT("-0.51", NUMPRS_STD);
1314   EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1315   EXPECT2(5,1);
1316
1317   /* Keep trailing zeros on whole number part of a decimal */
1318   CONVERT("10.1", NUMPRS_STD);
1319   EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1320   EXPECT2(1,0);
1321   EXPECTRGB(2,1);
1322
1323   /* Zeros after decimal sign */
1324   CONVERT("0.01", NUMPRS_STD);
1325   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1326   EXPECT2(1,FAILDIG);
1327
1328   /* Trailing zeros after decimal part */
1329   CONVERT("0.10", NUMPRS_STD);
1330   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1331   EXPECT2(1,0);
1332 }
1333
1334 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1335
1336 /* Macros for converting and testing the result of VarNumFromParseNum */
1337 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1338 #undef CONVERT
1339 #define CONVERT(a,b,c,d,e,f,bits) \
1340     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1341     np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1342 static const char *szFailOverflow = "Expected overflow, hres = %08x\n";
1343 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1344 static const char *szFailOk = "Call failed, hres = %08x\n";
1345 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1346   if (hres == (HRESULT)S_OK)
1347 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1348 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1349   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1350 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1351   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1352 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1353   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1354 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1355   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1356 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1357   ok(V_I4(&vOut) == val, "Expected i4 = %d, got %d\n", (LONG)val, V_I4(&vOut)); }
1358 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1359   ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
1360 #define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1361   ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
1362      (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
1363 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1364   ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
1365       (DWORD)((ULONG64)val >> 32), (DWORD)(ULONG64)val, (DWORD)(V_UI8(&vOut) >> 32), (DWORD)V_UI8(&vOut)); }
1366 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1367   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1368 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1369   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1370 #define CY_MULTIPLIER 10000
1371 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1372   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = 0x%x%08x, got 0x%x%08x\n", \
1373       (DWORD)((LONG64)val >> 23), (DWORD)(LONG64)val, (DWORD)(V_CY(&vOut).int64 >>32), (DWORD)V_CY(&vOut).int64); }
1374 #define EXPECT_DECIMAL(valHi, valMid, valLo) EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
1375       ok((V_DECIMAL(&vOut).Hi32 == valHi) && (S1(U1(V_DECIMAL(&vOut))).Mid32 == valMid) && \
1376       (S1(U1(V_DECIMAL(&vOut))).Lo32 == valLo),                      \
1377   "Expected decimal = %x/0x%x%08x, got %x/0x%x%08x\n", valHi, valMid, valLo, \
1378       V_DECIMAL(&vOut).Hi32, S1(U1(V_DECIMAL(&vOut))).Mid32, S1(U1(V_DECIMAL(&vOut))).Lo32); }
1379
1380 static void test_VarNumFromParseNum(void)
1381 {
1382   HRESULT hres;
1383   NUMPARSE np;
1384   BYTE rgb[128];
1385   VARIANT vOut;
1386
1387   CHECKPTR(VarNumFromParseNum);
1388
1389   /* Convert the number 1 to different types */
1390   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1391   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1392   /* Prefers a signed type to unsigned of the same size */
1393   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1394   /* But takes the smaller size if possible */
1395   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1396
1397   /* Try different integer sizes */
1398 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1399
1400   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1401   /* 127 */
1402   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1403   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1404   /* 128 */
1405   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1406   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1407   /* 255 */
1408   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1409   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1410   /* 256 */
1411   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1412   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1413   /* 32767 */
1414   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1415   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1416   /* 32768 */
1417   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1418   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1419
1420   /* Assume the above pattern holds for remaining positive integers; test negative */
1421
1422   /* -128 */
1423   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1424   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1425   /* -129 */
1426   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1427   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1428   /* -32768 */
1429   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1430   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1431   /* -32768 */
1432   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1433   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1434
1435   /* Assume the above pattern holds for remaining negative integers */
1436
1437   /* Test hexadecimal conversions */
1438   SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
1439   /* 0x7f */
1440   SETRGB(0, 7); SETRGB(1, 0xf);
1441   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
1442   SETRGB(0, 7); SETRGB(1, 0xf);
1443   CONVERT(2,0,0,2,4,0, VTBIT_DECIMAL); EXPECT_DECIMAL(0,0,0x7f);
1444   /* 0x7fff */
1445   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1446   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
1447   /* 0x7fffffff */
1448   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1449   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1450   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
1451   /* 0x7fffffffffffffff (64 bits) */
1452   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1453   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1454   SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
1455   SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
1456   if (HAVE_OLEAUT32_I8)
1457   {
1458     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1459        truncate the number to the smallest integer size requested:
1460        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
1461     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffff,0xffffffff);
1462   }
1463
1464   /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
1465   /* 0x82 */
1466   SETRGB(0, 8); SETRGB(1, 2);
1467   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
1468   EXPECT_I1((signed char)0x82);
1469   /* 0x8002 */
1470   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1471   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
1472   EXPECT_I2((signed short)0x8002);
1473   /* 0x80000002 */
1474   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1475   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1476   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
1477   /* 0x8000000000000002 (64 bits) */
1478   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1479   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1480   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1481   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1482   if (HAVE_OLEAUT32_I8)
1483   {
1484     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1485        truncate the number to the smallest integer size requested:
1486        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
1487        EXPECT_I2((signed short)0x0002); */
1488     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1489   }
1490
1491   /* Test (preservation of) hi-bit with STRICT type requesting */
1492   /* 0x82 */
1493   SETRGB(0, 8); SETRGB(1, 2);
1494   CONVERT(2,0,0,2,4,0, VTBIT_I1);
1495   EXPECT_I1((signed char)0x82);
1496   /* 0x8002 */
1497   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1498   CONVERT(4,0,0,4,4,0, VTBIT_I2);
1499   EXPECT_I2((signed short)0x8002);
1500   /* 0x80000002 */
1501   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1502   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1503   CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
1504   /* 0x8000000000000002 (64 bits) */
1505   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1506   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1507   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1508   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1509   if (HAVE_OLEAUT32_I8)
1510   {
1511     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1512   }
1513   /* Assume the above pattern holds for numbers with hi-bit set */
1514
1515   /* Negative numbers overflow if we have only unsigned outputs */
1516   /* -1 */
1517   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1518   /* -0.6 */
1519   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1520
1521   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1522   /* -0.5 */
1523   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1524
1525   /* Floating point zero is OK */
1526   /* 0.00000000E0 */
1527   SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
1528   EXPECT_R8(0.0);
1529
1530   /* Float is acceptable for an integer input value */
1531   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1532   /* As is double */
1533   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1534   /* As is currency */
1535   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1536
1537   /* Float is preferred over double */
1538   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1539
1540   /* Double is preferred over currency */
1541   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1542
1543   /* Currency is preferred over decimal */
1544   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1545 }
1546
1547
1548 static void test_UdateFromDate( int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y,
1549                                 WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)
1550 {
1551     UDATE ud;
1552     HRESULT res;
1553
1554     memset(&ud, 0, sizeof(ud));
1555     res = pVarUdateFromDate(dt, flags, &ud);
1556     ok_(__FILE__,line)(r == res, "Wrong result %x/%x\n", r, res);
1557     if (SUCCEEDED(res))
1558         ok_(__FILE__,line)(ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
1559                            ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
1560                            ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy,
1561                            "%.16g expected %d,%d,%d,%d,%d,%d,%d  %d %d, got %d,%d,%d,%d,%d,%d,%d  %d %d\n",
1562                            dt, d, m, y, h, mn, s, ms, dw, dy,
1563                            ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
1564                            ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
1565 }
1566 #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)
1567
1568 static void test_VarUdateFromDate(void)
1569 {
1570   CHECKPTR(VarUdateFromDate);
1571   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
1572   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
1573   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
1574   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
1575   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
1576   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1577   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
1578   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
1579
1580   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1581   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1582   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1583
1584   /* Times */
1585   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
1586   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
1587   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
1588   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1589   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1590 }
1591
1592
1593 static void test_DateFromUDate( int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms,
1594                                 WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt )
1595 {
1596     UDATE ud;
1597     double out;
1598     HRESULT res;
1599
1600     ud.st.wYear = y;
1601     ud.st.wMonth = m;
1602     ud.st.wDay = d;
1603     ud.st.wHour = h;
1604     ud.st.wMinute = mn;
1605     ud.st.wSecond = s;
1606     ud.st.wMilliseconds = ms;
1607     ud.st.wDayOfWeek = dw;
1608     ud.wDayOfYear = dy;
1609     res = pVarDateFromUdate(&ud, flags, &out);
1610     ok_(__FILE__,line)(r == res && (FAILED(r) || EQ_DOUBLE(out, dt)),
1611                        "expected %x, %.16g, got %x, %.16g\n", r, dt, res, out);
1612 }
1613 #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)
1614
1615 static void test_VarDateFromUdate(void)
1616 {
1617   CHECKPTR(VarDateFromUdate);
1618   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
1619   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
1620   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
1621   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
1622   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
1623   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
1624   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
1625   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
1626
1627   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963); /* 6:18:02 PM */
1628
1629   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);      /* Rolls back to 31 Dec 1899 */
1630   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);     /* Rolls fwd to 1/1/1981 */
1631 }
1632
1633 static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1634                        WORD s, WORD ms, INT r, double dt)
1635 {
1636     SYSTEMTIME st;
1637     double out;
1638     INT res;
1639
1640     st.wYear = y;
1641     st.wMonth = m;
1642     st.wDay = d;
1643     st.wHour = h;
1644     st.wMinute = mn;
1645     st.wSecond = s;
1646     st.wMilliseconds = ms;
1647     st.wDayOfWeek = 0;
1648     res = pSystemTimeToVariantTime(&st, &out);
1649     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1650                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1651 }
1652 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)
1653
1654 static void test_SystemTimeToVariantTime(void)
1655 {
1656   CHECKPTR(SystemTimeToVariantTime);
1657   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1658   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1659   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
1660   ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1661   ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* year < 100 is 1900+year! */
1662 }
1663
1664 static void test_dt2st(int line, double dt, INT r, WORD d, WORD m, WORD y,
1665                        WORD h, WORD mn, WORD s, WORD ms)
1666 {
1667   SYSTEMTIME st;
1668   INT res;
1669
1670   memset(&st, 0, sizeof(st));
1671   res = pVariantTimeToSystemTime(dt, &st);
1672   ok_(__FILE__,line)(r == res &&
1673                      (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
1674                              st.wHour == h && st.wMinute == mn &&
1675                              st.wSecond == s && st.wMilliseconds == ms)),
1676                      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
1677                      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
1678                      st.wYear, st.wHour, st.wMinute, st.wSecond,
1679                      st.wMilliseconds);
1680 }
1681 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)
1682
1683 static void test_VariantTimeToSystemTime(void)
1684 {
1685   CHECKPTR(VariantTimeToSystemTime);
1686   DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1687   DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1688 }
1689
1690 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1691 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1692
1693 static void test_dos2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1694                         WORD s, INT r, double dt)
1695 {
1696     unsigned short dosDate, dosTime;
1697     double out;
1698     INT res;
1699
1700     out = 0.0;
1701     dosDate = MKDOSDATE(d, m, y);
1702     dosTime = MKDOSTIME(h, mn, s);
1703     res = pDosDateTimeToVariantTime(dosDate, dosTime, &out);
1704     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1705                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1706 }
1707 #define DOS2DT(d,m,y,h,mn,s,r,dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)
1708
1709 static void test_DosDateTimeToVariantTime(void)
1710 {
1711   CHECKPTR(DosDateTimeToVariantTime);
1712
1713   /* Date */
1714   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1715   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1716   /* Dates are limited to the dos date max of 31/12/2099 */
1717   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1718   /* Days and months of 0 cause date to roll back 1 day or month */
1719   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1720   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
1721   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1722   /* Days > days in the month cause date to roll forward 1 month */
1723   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1724   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1725   /* Takes leap years into account when rolling forward */
1726   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1727   /* Months > 12 cause an error */
1728   DOS2DT(2,13,1980,0,0,0,0,0.0);
1729
1730   /* Time */
1731   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1732   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1733   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1734   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid seconds */
1735   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1736   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
1737 }
1738
1739 static void test_dt2dos(int line, double dt, INT r, WORD d, WORD m, WORD y,
1740                         WORD h, WORD mn, WORD s)
1741 {
1742     unsigned short dosDate, dosTime, expDosDate, expDosTime;
1743     INT res;
1744
1745     dosTime = dosDate = 0;
1746     expDosDate = MKDOSDATE(d,m,y);
1747     expDosTime = MKDOSTIME(h,mn,s);
1748     res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime);
1749     ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
1750                        "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
1751                        dt, r, expDosDate, expDosDate & 0x1f,
1752                        (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
1753                        expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
1754                        (expDosTime & 0x1f),
1755                        res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
1756                        1980 + (dosDate >> 9), dosTime, dosTime >> 11,
1757                        (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
1758 }
1759 #define DT2DOS(dt,r,d,m,y,h,mn,s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)
1760
1761 static void test_VariantTimeToDosDateTime(void)
1762 {
1763   CHECKPTR(VariantTimeToDosDateTime);
1764
1765   /* Date */
1766   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
1767   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1768   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
1769   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
1770
1771   /* Time */
1772   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1773   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1774   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1775   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1776 }
1777
1778 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1779
1780 #define VARABS(vt,val,rvt,rval)                  \
1781     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
1782     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1783     test_var_call1( __LINE__, pVarAbs, &v, &exp )
1784
1785 static void test_VarAbs(void)
1786 {
1787     static WCHAR szNum[] = {'-','1','.','1','\0' };
1788     char buff[8];
1789     HRESULT hres;
1790     VARIANT v, vDst, exp;
1791     size_t i;
1792
1793     CHECKPTR(VarAbs);
1794
1795     /* Test all possible V_VT values.
1796      */
1797     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1798     {
1799         VARTYPE vt;
1800
1801         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1802         {
1803             HRESULT hExpected = DISP_E_BADVARTYPE;
1804
1805             SKIPTESTS(vt);
1806
1807             memset(&v, 0, sizeof(v));
1808             V_VT(&v) = vt | ExtraFlags[i];
1809             V_VT(&vDst) = VT_EMPTY;
1810
1811             hres = pVarAbs(&v,&vDst);
1812             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1813                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1814                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1815             {
1816                 hExpected = DISP_E_TYPEMISMATCH;
1817             }
1818             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1819             {
1820                 hExpected = DISP_E_BADVARTYPE;
1821             }
1822             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1823                 hExpected = S_OK;
1824
1825             /* Native always fails on some vartypes that should be valid. don't
1826              * check that Wine does the same; these are bugs in native.
1827              */
1828             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1829                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1830                 continue;
1831             ok(hres == hExpected, "VarAbs: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
1832                hExpected, hres, vt, ExtraFlags[i]);
1833         }
1834     }
1835
1836     /* BOOL->I2, BSTR->R8, all others remain the same */
1837     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1838     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1839     VARABS(EMPTY,0,I2,0);
1840     VARABS(EMPTY,1,I2,0);
1841     VARABS(NULL,0,NULL,0);
1842     VARABS(NULL,1,NULL,0);
1843     VARABS(I2,1,I2,1);
1844     VARABS(I2,-1,I2,1);
1845     VARABS(I4,1,I4,1);
1846     VARABS(I4,-1,I4,1);
1847     VARABS(UI1,1,UI1,1);
1848     VARABS(R4,1,R4,1);
1849     VARABS(R4,-1,R4,1);
1850     VARABS(R8,1,R8,1);
1851     VARABS(R8,-1,R8,1);
1852     VARABS(DATE,1,DATE,1);
1853     VARABS(DATE,-1,DATE,1);
1854     V_VT(&v) = VT_CY;
1855     V_CY(&v).int64 = -10000;
1856     memset(&vDst,0,sizeof(vDst));
1857     hres = pVarAbs(&v,&vDst);
1858     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1859        "VarAbs(CY): expected 0x0 got 0x%X\n", hres);
1860     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1861     if (buff[1])
1862     {
1863         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1864         return;
1865     } else {
1866         szNum[2] = buff[0];
1867     }
1868     V_VT(&v) = VT_BSTR;
1869     V_BSTR(&v) = (BSTR)szNum;
1870     memset(&vDst,0,sizeof(vDst));
1871     hres = pVarAbs(&v,&vDst);
1872     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1873        "VarAbs: expected 0x0,%d,%g, got 0x%X,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1874 }
1875
1876 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
1877
1878 #define VARNOT(vt,val,rvt,rval)                  \
1879     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
1880     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1881     test_var_call1( __LINE__, pVarNot, &v, &exp )
1882
1883 static void test_VarNot(void)
1884 {
1885     static const WCHAR szNum0[] = {'0','\0' };
1886     static const WCHAR szNum1[] = {'1','\0' };
1887     HRESULT hres;
1888     VARIANT v, exp, vDst;
1889     DECIMAL *pdec = &V_DECIMAL(&v);
1890     CY *pcy = &V_CY(&v);
1891     size_t i;
1892
1893     CHECKPTR(VarNot);
1894
1895     /* Test all possible V_VT values */
1896     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1897     {
1898         VARTYPE vt;
1899
1900         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1901         {
1902             HRESULT hExpected = DISP_E_BADVARTYPE;
1903
1904             SKIPTESTS(vt);
1905
1906             memset(&v, 0, sizeof(v));
1907             V_VT(&v) = vt | ExtraFlags[i];
1908             V_VT(&vDst) = VT_EMPTY;
1909
1910             switch (V_VT(&v))
1911             {
1912             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
1913             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
1914             case VT_R4:  case VT_R8:
1915             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
1916             case VT_DATE: case VT_CY:
1917                 hExpected = S_OK;
1918                 break;
1919             case VT_I8: case VT_UI8:
1920                 if (HAVE_OLEAUT32_I8)
1921                     hExpected = S_OK;
1922                 break;
1923             case VT_RECORD:
1924                 if (HAVE_OLEAUT32_RECORD)
1925                     hExpected = DISP_E_TYPEMISMATCH;
1926                 break;
1927             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
1928                 hExpected = DISP_E_TYPEMISMATCH;
1929                 break;
1930             default:
1931                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
1932                    hExpected = DISP_E_TYPEMISMATCH;
1933                 break;
1934             }
1935
1936             hres = pVarNot(&v,&vDst);
1937             ok(hres == hExpected, "VarNot: expected 0x%X, got 0x%X vt %d|0x%X\n",
1938                hExpected, hres, vt, ExtraFlags[i]);
1939         }
1940     }
1941     /* Test the values returned by all cases that can succeed */
1942     VARNOT(EMPTY,0,I2,-1);
1943     VARNOT(EMPTY,1,I2,-1);
1944     VARNOT(NULL,0,NULL,0);
1945     VARNOT(NULL,1,NULL,0);
1946     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
1947     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
1948     VARNOT(I1,-1,I4,0);
1949     VARNOT(I1,0,I4,-1);
1950     VARNOT(I2,-1,I2,0);
1951     VARNOT(I2,0,I2,-1);
1952     VARNOT(I2,1,I2,-2);
1953     VARNOT(I4,1,I4,-2);
1954     VARNOT(I4,0,I4,-1);
1955     VARNOT(UI1,1,UI1,254);
1956     VARNOT(UI1,0,UI1,255);
1957     VARNOT(UI2,0,I4,-1);
1958     VARNOT(UI2,1,I4,-2);
1959     VARNOT(UI4,0,I4,-1);
1960     VARNOT(UI4,1,I4,-2);
1961     VARNOT(INT,0,I4,-1);
1962     VARNOT(INT,1,I4,-2);
1963     VARNOT(UINT,0,I4,-1);
1964     VARNOT(UINT,1,I4,-2);
1965     if (HAVE_OLEAUT32_I8)
1966     {
1967         VARNOT(I8,1,I8,-2);
1968         VARNOT(I8,0,I8,-1);
1969         VARNOT(UI8,0,I4,-1);
1970         VARNOT(UI8,1,I4,-2);
1971     }
1972     VARNOT(R4,1,I4,-2);
1973     VARNOT(R4,0,I4,-1);
1974     VARNOT(R8,1,I4,-2);
1975     VARNOT(R8,0,I4,-1);
1976     VARNOT(DATE,1,I4,-2);
1977     VARNOT(DATE,0,I4,-1);
1978     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
1979     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
1980     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
1981     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
1982
1983     V_VT(&v) = VT_DECIMAL;
1984     S(U(*pdec)).sign = DECIMAL_NEG;
1985     S(U(*pdec)).scale = 0;
1986     pdec->Hi32 = 0;
1987     S1(U1(*pdec)).Mid32 = 0;
1988     S1(U1(*pdec)).Lo32 = 1;
1989     VARNOT(DECIMAL,*pdec,I4,0);
1990
1991     pcy->int64 = 10000;
1992     VARNOT(CY,*pcy,I4,-2);
1993
1994     pcy->int64 = 0;
1995     VARNOT(CY,*pcy,I4,-1);
1996
1997     pcy->int64 = -1;
1998     VARNOT(CY,*pcy,I4,-1);
1999 }
2000
2001 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
2002
2003 #define VARSUB(vt1,val1,vt2,val2,rvt,rval)               \
2004         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2005         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2006         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2007         test_var_call2( __LINE__, pVarSub, &left, &right, &exp )
2008
2009 static void test_VarSub(void)
2010 {
2011     static const WCHAR sz12[] = {'1','2','\0'};
2012     VARIANT left, right, exp, result, cy, dec;
2013     VARTYPE i;
2014     BSTR lbstr, rbstr;
2015     HRESULT hres, expectedhres;
2016     double r;
2017
2018     CHECKPTR(VarSub);
2019
2020     lbstr = SysAllocString(sz12);
2021     rbstr = SysAllocString(sz12);
2022
2023     VariantInit(&left);
2024     VariantInit(&right);
2025     VariantInit(&result);
2026
2027     /* Test all possible flag/vt combinations & the resulting vt type */
2028     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2029     {
2030
2031         VARTYPE leftvt, rightvt, resvt;
2032
2033         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
2034         {
2035
2036             SKIPTESTS(leftvt);
2037
2038             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
2039             {
2040
2041                 SKIPTESTS(rightvt);
2042                 expectedhres = S_OK;
2043
2044                 memset(&left, 0, sizeof(left));
2045                 memset(&right, 0, sizeof(right));
2046                 V_VT(&left) = leftvt | ExtraFlags[i];
2047                 if (leftvt == VT_BSTR)
2048                     V_BSTR(&left) = lbstr;
2049                 V_VT(&right) = rightvt | ExtraFlags[i];
2050                 if (rightvt == VT_BSTR)
2051                     V_BSTR(&right) = rbstr;
2052                 V_VT(&result) = VT_EMPTY;
2053                 resvt = VT_ERROR;
2054
2055                 /* All extra flags produce errors */
2056                 if (ExtraFlags[i] == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
2057                     ExtraFlags[i] == (VT_VECTOR|VT_RESERVED) ||
2058                     ExtraFlags[i] == (VT_VECTOR|VT_BYREF) ||
2059                     ExtraFlags[i] == (VT_BYREF|VT_RESERVED) ||
2060                     ExtraFlags[i] == VT_VECTOR ||
2061                     ExtraFlags[i] == VT_BYREF ||
2062                     ExtraFlags[i] == VT_RESERVED)
2063                 {
2064                     expectedhres = DISP_E_BADVARTYPE;
2065                     resvt = VT_EMPTY;
2066                 }
2067                 else if (ExtraFlags[i] >= VT_ARRAY)
2068                 {
2069                     expectedhres = DISP_E_TYPEMISMATCH;
2070                     resvt = VT_EMPTY;
2071                 }
2072                 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
2073                    VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
2074                 else if (!IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
2075                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
2076                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
2077                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
2078                     leftvt == VT_I1 || rightvt == VT_I1 ||
2079                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
2080                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
2081                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
2082                     leftvt == VT_INT || rightvt == VT_INT ||
2083                     leftvt == VT_UINT || rightvt == VT_UINT ||
2084                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
2085                     leftvt == VT_RECORD || rightvt == VT_RECORD)
2086                 {
2087                     if (leftvt == VT_RECORD && rightvt == VT_I8)
2088                     {
2089                         if (HAVE_OLEAUT32_I8)
2090                             expectedhres = DISP_E_TYPEMISMATCH;
2091                         else
2092                             expectedhres = DISP_E_BADVARTYPE;
2093                     }
2094                     else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
2095                         expectedhres = DISP_E_TYPEMISMATCH;
2096                     else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
2097                         expectedhres = DISP_E_TYPEMISMATCH;
2098                     else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
2099                         expectedhres = DISP_E_TYPEMISMATCH;
2100                     else if (leftvt == VT_RECORD && rightvt > VT_UI1)
2101                         expectedhres = DISP_E_BADVARTYPE;
2102                     else
2103                         expectedhres = DISP_E_BADVARTYPE;
2104                     resvt = VT_EMPTY;
2105                 }
2106                 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
2107                     (leftvt == VT_DISPATCH && rightvt == VT_NULL))
2108                     resvt = VT_NULL;
2109                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
2110                     leftvt == VT_ERROR || rightvt == VT_ERROR)
2111                 {
2112                     resvt = VT_EMPTY;
2113                     expectedhres = DISP_E_TYPEMISMATCH;
2114                 }
2115                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
2116                     resvt = VT_NULL;
2117                 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
2118                     (leftvt == VT_DATE && rightvt == VT_DATE) ||
2119                     (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
2120                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
2121                     resvt = VT_R8;
2122                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
2123                     resvt = VT_DECIMAL;
2124                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
2125                     resvt = VT_DATE;
2126                 else if (leftvt == VT_CY || rightvt == VT_CY)
2127                     resvt = VT_CY;
2128                 else if (leftvt == VT_R8 || rightvt == VT_R8)
2129                     resvt = VT_R8;
2130                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
2131                     resvt = VT_R8;
2132                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
2133                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
2134                         leftvt == VT_I8 || rightvt == VT_I8)
2135                         resvt = VT_R8;
2136                     else
2137                         resvt = VT_R4;
2138                 }
2139                 else if (leftvt == VT_I8 || rightvt == VT_I8)
2140                     resvt = VT_I8;
2141                 else if (leftvt == VT_I4 || rightvt == VT_I4)
2142                     resvt = VT_I4;
2143                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
2144                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
2145                     (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
2146                     resvt = VT_I2;
2147                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
2148                     resvt = VT_UI1;
2149                 else
2150                 {
2151                     resvt = VT_EMPTY;
2152                     expectedhres = DISP_E_TYPEMISMATCH;
2153                 }
2154
2155                 hres = pVarSub(&left, &right, &result);
2156
2157                 ok(hres == expectedhres && V_VT(&result) == resvt,
2158                     "VarSub: %d|0x%X, %d|0x%X: Expected failure 0x%X, "
2159                     "got 0x%X, expected vt %d got vt %d\n",
2160                     leftvt, ExtraFlags[i], rightvt, ExtraFlags[i],
2161                     expectedhres, hres, resvt, V_VT(&result));
2162             }
2163         }
2164     }
2165
2166     /* Test returned values */
2167     VARSUB(I4,4,I4,2,I4,2);
2168     VARSUB(I2,4,I2,2,I2,2);
2169     VARSUB(I2,-13,I4,5,I4,-18);
2170     VARSUB(I4,-13,I4,5,I4,-18);
2171     VARSUB(I2,7,R4,0.5f,R4,6.5f);
2172     VARSUB(R4,0.5f,I4,5,R8,-4.5);
2173     VARSUB(R8,7.1,BOOL,0,R8,7.1);
2174     VARSUB(BSTR,lbstr,I2,4,R8,8);
2175     VARSUB(BSTR,lbstr,BOOL,1,R8,11);
2176     VARSUB(BSTR,lbstr,R4,0.1f,R8,11.9);
2177     VARSUB(R4,0.2f,BSTR,rbstr,R8,-11.8);
2178     VARSUB(DATE,2.25,I4,7,DATE,-4.75);
2179     VARSUB(DATE,1.25,R4,-1.7f,DATE,2.95);
2180
2181     VARSUB(UI1, UI1_MAX, UI1, UI1_MAX, UI1, 0);
2182     VARSUB(I2, I2_MAX, I2, I2_MAX, I2, 0);
2183     VARSUB(I2, I2_MIN, I2, I2_MIN, I2, 0);
2184     VARSUB(I4, I4_MAX, I4, I4_MAX, I4, 0);
2185     VARSUB(I4, I4_MIN, I4, I4_MIN, I4, 0);
2186     VARSUB(R4, R4_MAX, R4, R4_MAX, R4, 0.0f);
2187     VARSUB(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX - R4_MIN);
2188     VARSUB(R4, R4_MIN, R4, R4_MIN, R4, 0.0f);
2189     VARSUB(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX - R8_MIN);
2190     VARSUB(R8, R8_MIN, R8, R8_MIN, R8, 0.0);
2191
2192     /* Manually test BSTR + BSTR */
2193     V_VT(&left) = VT_BSTR;
2194     V_BSTR(&left) = lbstr;
2195     V_VT(&right) = VT_BSTR;
2196     V_BSTR(&right) = rbstr;
2197     hres = VarSub(&left, &right, &result);
2198     ok(hres == S_OK && V_VT(&result) == VT_R8,
2199         "VarSub: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
2200     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0),
2201         "VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
2202
2203     /* Manually test some VT_CY and VT_DECIMAL variants */
2204     V_VT(&cy) = VT_CY;
2205     hres = VarCyFromI4(4711, &V_CY(&cy));
2206     ok(hres == S_OK, "VarCyFromI4 failed!\n");
2207     V_VT(&dec) = VT_DECIMAL;
2208     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
2209     ok(hres == S_OK, "VarDecFromR4 failed!\n");
2210     memset(&left, 0, sizeof(left));
2211     memset(&right, 0, sizeof(right));
2212     V_VT(&left) = VT_I4;
2213     V_I4(&left) = -11;
2214     V_VT(&right) = VT_UI1;
2215     V_UI1(&right) = 9;
2216
2217     hres = VarSub(&cy, &right, &result);
2218     ok(hres == S_OK && V_VT(&result) == VT_CY,
2219         "VarSub: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
2220     hres = VarR8FromCy(V_CY(&result), &r);
2221     ok(hres == S_OK && EQ_DOUBLE(r, 4702),
2222         "VarSub: CY value %f, expected %f\n", r, (double)4720);
2223
2224     hres = VarSub(&left, &dec, &result);
2225     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
2226         "VarSub: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
2227     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
2228     ok(hres == S_OK && EQ_DOUBLE(r, -6.8),
2229         "VarSub: DECIMAL value %f, expected %f\n", r, (double)-15.2);
2230
2231     SysFreeString(lbstr);
2232     SysFreeString(rbstr);
2233 }
2234
2235 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2236
2237 static void test_Mod( int line, VARIANT *left, VARIANT *right, VARIANT *expected, HRESULT expres )
2238 {
2239     VARIANT result;
2240     HRESULT hres;
2241
2242     memset( &result, 0, sizeof(result) );
2243     hres = pVarMod( left, right, &result );
2244     ok_(__FILE__,line)( hres == expres, "wrong result %x/%x\n", hres, expres );
2245     if (hres == S_OK)
2246         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
2247                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
2248 }
2249
2250 #define VARMOD(vt1,vt2,val1,val2,rvt,rval)               \
2251         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
2252         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2253         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
2254         test_var_call2( __LINE__, pVarMod, &left, &right, &exp )
2255
2256 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected)         \
2257         V_VT(&left) = VT_##vt1; V_I4(&left) = val1;           \
2258         V_VT(&right) = VT_##vt2; V_I4(&right) = val2;         \
2259         V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval;             \
2260         test_Mod( __LINE__, &left, &right, &exp, hexpected )
2261
2262 static void test_VarMod(void)
2263 {
2264   VARIANT v1, v2, vDst, left, right, exp;
2265   HRESULT hres;
2266   HRESULT hexpected = 0;
2267   static const WCHAR szNum0[] = {'1','2','5','\0'};
2268   static const WCHAR szNum1[] = {'1','0','\0'};
2269   int l, r;
2270   BOOL lFound, rFound;
2271   BOOL lValid, rValid;
2272   BSTR strNum0, strNum1;
2273
2274   CHECKPTR(VarMod);
2275
2276   VARMOD(I1,BOOL,100,10,I4,0);
2277   VARMOD(I1,I1,100,10,I4,0);
2278   VARMOD(I1,UI1,100,10,I4,0);
2279   VARMOD(I1,I2,100,10,I4,0);
2280   VARMOD(I1,UI2,100,10,I4,0);
2281   VARMOD(I1,I4,100,10,I4,0);
2282   VARMOD(I1,UI4,100,10,I4,0);
2283   VARMOD(I1,R4,100,10,I4,0);
2284   VARMOD(I1,R8,100,10,I4,0);
2285
2286   VARMOD(UI1,BOOL,100,10,I2,0);
2287   VARMOD(UI1,I1,100,10,I4,0);
2288   VARMOD(UI1,UI1,100,10,UI1,0);
2289   VARMOD(UI1,I2,100,10,I2,0);
2290   VARMOD(UI1,UI2,100,10,I4,0);
2291   VARMOD(UI1,I4,100,10,I4,0);
2292   VARMOD(UI1,UI4,100,10,I4,0);
2293   VARMOD(UI1,R4,100,10,I4,0);
2294   VARMOD(UI1,R8,100,10,I4,0);
2295
2296   VARMOD(I2,BOOL,100,10,I2,0);
2297   VARMOD(I2,I1,100,10,I4,0);
2298   VARMOD(I2,UI1,100,10,I2,0);
2299   VARMOD(I2,I2,100,10,I2,0);
2300   VARMOD(I2,UI2,100,10,I4,0);
2301   VARMOD(I2,I4,100,10,I4,0);
2302   VARMOD(I2,UI4,100,10,I4,0);
2303   VARMOD(I2,R4,100,10,I4,0);
2304   VARMOD(I2,R8,100,10,I4,0);
2305
2306   VARMOD(I4,BOOL,100,10,I4,0);
2307   VARMOD(I4,I1,100,10,I4,0);
2308   VARMOD(I4,UI1,100,10,I4,0);
2309   VARMOD(I4,I2,100,10,I4,0);
2310   VARMOD(I4,UI2,100,10,I4,0);
2311   VARMOD(I4,I4,100,10,I4,0);
2312   VARMOD(I4,UI4,100,10,I4,0);
2313   VARMOD(I4,R4,100,10,I4,0);
2314   VARMOD(I4,R8,100,10,I4,0);
2315   VARMOD(UI4,BOOL,100,10,I4,0);
2316   VARMOD(UI4,I1,100,10,I4,0);
2317   VARMOD(UI4,UI1,100,10,I4,0);
2318   VARMOD(UI4,I2,100,10,I4,0);
2319   VARMOD(UI4,UI2,100,10,I4,0);
2320   VARMOD(UI4,I4,100,10,I4,0);
2321   VARMOD(UI4,UI4,100,10,I4,0);
2322   VARMOD(UI4,R4,100,10,I4,0);
2323   VARMOD(UI4,R8,100,10,I4,0);
2324   VARMOD(R4,BOOL,100,10,I4,0);
2325   VARMOD(R4,I1,100,10,I4,0);
2326   VARMOD(R4,UI1,100,10,I4,0);
2327   VARMOD(R4,I2,100,10,I4,0);
2328   VARMOD(R4,UI2,100,10,I4,0);
2329   VARMOD(R4,I4,100,10,I4,0);
2330   VARMOD(R4,UI4,100,10,I4,0);
2331   VARMOD(R4,R4,100,10,I4,0);
2332   VARMOD(R4,R8,100,10,I4,0);
2333   VARMOD(R8,BOOL,100,10,I4,0);
2334   VARMOD(R8,I1,100,10,I4,0);
2335   VARMOD(R8,UI1,100,10,I4,0);
2336   VARMOD(R8,I2,100,10,I4,0);
2337   VARMOD(R8,UI2,100,10,I4,0);
2338   VARMOD(R8,I4,100,10,I4,0);
2339   VARMOD(R8,UI4,100,10,I4,0);
2340   VARMOD(R8,R4,100,10,I4,0);
2341   VARMOD(R8,R8,100,10,I4,0);
2342
2343   VARMOD(INT,INT,100,10,I4,0);
2344   VARMOD(INT,UINT,100,10,I4,0);
2345
2346   VARMOD(BOOL,BOOL,100,10,I2,0);
2347   VARMOD(BOOL,I1,100,10,I4,0);
2348   VARMOD(BOOL,UI1,100,10,I2,0);
2349   VARMOD(BOOL,I2,100,10,I2,0);
2350   VARMOD(BOOL,UI2,100,10,I4,0);
2351   VARMOD(BOOL,I4,100,10,I4,0);
2352   VARMOD(BOOL,UI4,100,10,I4,0);
2353   VARMOD(BOOL,R4,100,10,I4,0);
2354   VARMOD(BOOL,R8,100,10,I4,0);
2355   VARMOD(BOOL,DATE,100,10,I4,0);
2356
2357   VARMOD(DATE,BOOL,100,10,I4,0);
2358   VARMOD(DATE,I1,100,10,I4,0);
2359   VARMOD(DATE,UI1,100,10,I4,0);
2360   VARMOD(DATE,I2,100,10,I4,0);
2361   VARMOD(DATE,UI2,100,10,I4,0);
2362   VARMOD(DATE,I4,100,10,I4,0);
2363   VARMOD(DATE,UI4,100,10,I4,0);
2364   VARMOD(DATE,R4,100,10,I4,0);
2365   VARMOD(DATE,R8,100,10,I4,0);
2366   VARMOD(DATE,DATE,100,10,I4,0);
2367
2368   strNum0 = SysAllocString(szNum0);
2369   strNum1 = SysAllocString(szNum1);
2370   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5);
2371   VARMOD(BSTR,I1,strNum0,10,I4,5);
2372   VARMOD(BSTR,I2,strNum0,10,I4,5);
2373   VARMOD(BSTR,I4,strNum0,10,I4,5);
2374   VARMOD(BSTR,R4,strNum0,10,I4,5);
2375   VARMOD(BSTR,R8,strNum0,10,I4,5);
2376   VARMOD(I4,BSTR,125,strNum1,I4,5);
2377
2378   if (HAVE_OLEAUT32_I8)
2379   {
2380     VARMOD(BOOL,I8,100,10,I8,0);
2381     VARMOD(I1,I8,100,10,I8,0);
2382     VARMOD(UI1,I8,100,10,I8,0);
2383     VARMOD(I2,I8,100,10,I8,0);
2384     VARMOD(I4,I8,100,10,I8,0);
2385     VARMOD(UI4,I8,100,10,I8,0);
2386     VARMOD(R4,I8,100,10,I8,0);
2387     VARMOD(R8,I8,100,10,I8,0);
2388     VARMOD(DATE,I8,100,10,I8,0);
2389
2390     VARMOD(I8,BOOL,100,10,I8,0);
2391     VARMOD(I8,I1,100,10,I8,0);
2392     VARMOD(I8,UI1,100,10,I8,0);
2393     VARMOD(I8,I2,100,10,I8,0);
2394     VARMOD(I8,UI2,100,10,I8,0);
2395     VARMOD(I8,I4,100,10,I8,0);
2396     VARMOD(I8,UI4,100,10,I8,0);
2397     VARMOD(I8,R4,100,10,I8,0);
2398     VARMOD(I8,R8,100,10,I8,0);
2399     VARMOD(I8,I8,100,10,I8,0);
2400
2401     VARMOD(BSTR,I8,strNum0,10,I8,5);
2402   }
2403
2404   /* test all combinations of types */
2405   for(l = 0; l < VT_BSTR_BLOB; l++)
2406   {
2407     SKIPTESTS(l);
2408
2409     for(r = 0; r < VT_BSTR_BLOB; r++)
2410     {
2411       SKIPTESTS(r);
2412
2413       if(l == VT_BSTR) continue;
2414       if(l == VT_DISPATCH) continue;
2415       if(r == VT_BSTR) continue;
2416       if(r == VT_DISPATCH) continue;
2417
2418       lFound = TRUE;
2419       lValid = TRUE;
2420       switch(l)
2421         {
2422         case VT_EMPTY:
2423         case VT_NULL:
2424         case VT_I1:
2425         case VT_UI1:
2426         case VT_I2:
2427         case VT_UI2:
2428         case VT_I4:
2429         case VT_I8:
2430         case VT_UI4:
2431         case VT_UI8:
2432         case VT_INT:
2433         case VT_UINT:
2434         case VT_R4:
2435         case VT_R8:
2436         case VT_BOOL:
2437         case VT_DATE:
2438         case VT_CY:
2439         case VT_DECIMAL:
2440           hexpected = S_OK;
2441           break;
2442         case VT_ERROR:
2443         case VT_VARIANT:
2444         case VT_UNKNOWN:
2445         case VT_RECORD:
2446           lValid = FALSE;
2447           break;
2448         default:
2449           lFound = FALSE;
2450           hexpected = DISP_E_BADVARTYPE;
2451           break;
2452         }
2453
2454       rFound = TRUE;
2455       rValid = TRUE;
2456       switch(r)
2457         {
2458         case VT_EMPTY:
2459         case VT_NULL:
2460         case VT_I1:
2461         case VT_UI1:
2462         case VT_I2:
2463         case VT_UI2:
2464         case VT_I4:
2465         case VT_I8:
2466         case VT_UI4:
2467         case VT_UI8:
2468         case VT_INT:
2469         case VT_UINT:
2470         case VT_R4:
2471         case VT_R8:
2472         case VT_BOOL:
2473         case VT_DATE:
2474         case VT_DECIMAL:
2475         case VT_CY:
2476           hexpected = S_OK;
2477           break;
2478         case VT_ERROR:
2479         case VT_VARIANT:
2480         case VT_UNKNOWN:
2481         case VT_RECORD:
2482           rValid = FALSE;
2483           break;
2484         default:
2485           rFound = FALSE;
2486           break;
2487         }
2488
2489       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2490       {
2491         hexpected = DISP_E_TYPEMISMATCH;
2492       } else if((l == VT_EMPTY) && (r == VT_NULL))
2493       {
2494         hexpected = S_OK;
2495       } else if((l == VT_NULL) && (r == VT_EMPTY))
2496       {
2497         hexpected = S_OK;
2498       } else if((l == VT_EMPTY) && (r == VT_CY))
2499       {
2500         hexpected = S_OK;
2501       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2502       {
2503         hexpected = DISP_E_TYPEMISMATCH;
2504       } else if((r == VT_EMPTY) && lFound && lValid)
2505       {
2506         hexpected = DISP_E_DIVBYZERO;
2507       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2508       {
2509         hexpected = DISP_E_TYPEMISMATCH;
2510       } else if((l == VT_NULL) && (r == VT_NULL))
2511       {
2512         hexpected = S_OK;
2513       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2514       {
2515         hexpected = DISP_E_TYPEMISMATCH;
2516       } else if((l == VT_NULL) && (r == VT_RECORD))
2517       {
2518         hexpected = DISP_E_TYPEMISMATCH;
2519       } else if((l == VT_I8) && (r == VT_DECIMAL))
2520       {
2521         hexpected = S_OK;
2522       } else if((l == VT_DECIMAL) && (r == VT_I8))
2523       {
2524         hexpected = S_OK;
2525       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2526       {
2527         hexpected = DISP_E_TYPEMISMATCH;
2528       } else if((l == VT_NULL) && rFound)
2529       {
2530         hexpected = S_OK;
2531       } else if(l == VT_RECORD)
2532       {
2533         hexpected = DISP_E_TYPEMISMATCH;
2534       } else if((r == VT_RECORD) && lValid && lFound)
2535       {
2536         hexpected = DISP_E_TYPEMISMATCH;
2537       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2538       {
2539         hexpected = DISP_E_DIVBYZERO;
2540       } else if((l == VT_CY) && !rFound)
2541       {
2542         hexpected = DISP_E_BADVARTYPE;
2543       } else if(lFound && !rFound)
2544       {
2545         hexpected = DISP_E_BADVARTYPE;
2546       } else if(!lFound && rFound)
2547       {
2548         hexpected = DISP_E_BADVARTYPE;
2549       } else if((r == VT_NULL) && lFound && lValid)
2550       {
2551         hexpected = S_OK;
2552       } else if((l == VT_NULL) || (r == VT_NULL))
2553       {
2554         hexpected = DISP_E_BADVARTYPE;
2555       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2556       {
2557         hexpected = DISP_E_BADVARTYPE;
2558       } else if(lFound && !rFound)
2559       {
2560         hexpected = DISP_E_BADVARTYPE;
2561       } else if(!lFound && !rFound)
2562       {
2563         hexpected = DISP_E_BADVARTYPE;
2564       }
2565
2566       V_VT(&v1) = l;
2567       V_VT(&v2) = r;
2568
2569       if(l == VT_CY)
2570         V_CY(&v1).int64 = 1000000;
2571       else if(l == VT_R4)
2572         V_R4(&v1) = 100;
2573       else if(l == VT_R8)
2574         V_R8(&v1) = 100;
2575       else if(l == VT_UI8)
2576         V_UI8(&v1) = 100;
2577       else if(l == VT_I8)
2578         V_I8(&v1) = 100;
2579       else if(l == VT_DATE)
2580         V_DATE(&v1) = 1000;
2581       else if (l == VT_DECIMAL)
2582       {
2583         V_DECIMAL(&v1).Hi32 = 0;
2584         U1(V_DECIMAL(&v1)).Lo64 = 100;
2585         U(V_DECIMAL(&v1)).signscale = 0;
2586       }
2587       else
2588         V_I4(&v1) = 10000;
2589
2590       if(r == VT_CY)
2591         V_CY(&v2).int64 = 10000;
2592       else if(r == VT_R4)
2593         V_R4(&v2) = 100;
2594       else if(r == VT_R8)
2595         V_R8(&v2) = 100;
2596       else if(r == VT_UI8)
2597         V_UI8(&v2) = 100;
2598       else if(r == VT_I8)
2599         V_I8(&v2) = 100;
2600       else if(r == VT_DATE)
2601         V_DATE(&v2) = 1000;
2602       else if (r == VT_DECIMAL)
2603       {
2604         V_DECIMAL(&v2).Hi32 = 0;
2605         U1(V_DECIMAL(&v2)).Lo64 = 100;
2606         U(V_DECIMAL(&v2)).signscale = 0;
2607       }
2608       else
2609         V_I4(&v2) = 10000;
2610
2611       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2612       {
2613         hres = pVarMod(&v1,&v2,&vDst);
2614         ok(hres == hexpected,
2615            "VarMod: expected 0x%x, got 0x%X for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2616       }
2617     }
2618   }
2619
2620
2621   /****************************/
2622   /* test some bad parameters */
2623   VARMOD(I4,I4,-1,-1,I4,0);
2624
2625   /* test modulus with zero */
2626   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2627
2628   VARMOD(I4,I4,0,10,I4,0); /* test 0 mod 10 */
2629
2630   /* right parameter is type empty */
2631   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2632
2633   /* left parameter is type empty */
2634   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2635
2636   /* mod with a null left value */
2637   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2638
2639   /* mod with a null right value */
2640   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2641
2642   /* void left value */
2643   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2644
2645   /* void right value */
2646   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2647
2648   /* null left value, void right value */
2649   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2650
2651   /* void left value, null right value */
2652   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2653
2654   /* some currencies */
2655   V_VT(&v1) = VT_CY;
2656   V_VT(&v2) = VT_CY;
2657   V_CY(&v1).int64 = 100000;
2658   V_CY(&v2).int64 = 100000;
2659   hres = pVarMod(&v1,&v2,&vDst);
2660   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2661      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2662
2663   V_VT(&v1) = VT_I4;
2664   V_VT(&v2) = VT_CY;
2665   V_I4(&v1) = 100;
2666   V_CY(&v2).int64 = 100000;
2667   hres = pVarMod(&v1,&v2,&vDst);
2668   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2669      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2670
2671   /* some decimals */
2672   V_VT(&v1) = VT_DECIMAL;
2673   V_VT(&v2) = VT_DECIMAL;
2674   VarDecFromI4(100, &V_DECIMAL(&v1));
2675   VarDecFromI4(10, &V_DECIMAL(&v2));
2676   hres = pVarMod(&v1,&v2,&vDst);
2677   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2678      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2679
2680   V_VT(&v1) = VT_I4;
2681   V_VT(&v2) = VT_DECIMAL;
2682   V_I4(&v1) = 100;
2683   VarDecFromI4(10, &V_DECIMAL(&v2));
2684   hres = pVarMod(&v1,&v2,&vDst);
2685   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2686      "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2687
2688   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2689
2690   /* test that an error results in the type of the result changing but not its value */
2691   V_VT(&v1) = VT_UNKNOWN;
2692   V_VT(&v2) = VT_EMPTY;
2693   V_I4(&v1) = 100;
2694   V_CY(&v2).int64 = 100000;
2695   V_VT(&vDst) = VT_I4;
2696   V_I4(&vDst) = 1231;
2697   hres = pVarMod(&v1,&v2,&vDst);
2698   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2699      "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));
2700
2701
2702   /* test some invalid types */
2703   /*TODO: not testing VT_DISPATCH */
2704   if (HAVE_OLEAUT32_I8)
2705   {
2706     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2707   }
2708   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2709   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2710   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2711   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2712   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2713   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2714   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2715   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2716   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2717   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2718   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2719   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2720   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2721   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2722   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2723   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2724   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2725   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2726   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2727   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2728   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2729   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2730   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2731   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2732
2733   /* test some more invalid types */
2734   V_VT(&v1) = 456;
2735   V_VT(&v2) = 234;
2736   V_I4(&v1) = 100;
2737   V_I4(&v2)=  10;
2738   hres = pVarMod(&v1,&v2,&vDst);
2739   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY,
2740      "VarMod: expected 0x%x,%d, got 0x%X,%d\n", DISP_E_BADVARTYPE, VT_EMPTY, hres, V_VT(&vDst));
2741
2742   SysFreeString(strNum0);
2743   SysFreeString(strNum1);
2744 }
2745
2746 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2747
2748 #define VARFIX(vt,val,rvt,rval)                  \
2749     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2750     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2751     test_var_call1( __LINE__, pVarFix, &v, &exp )
2752
2753 static void test_VarFix(void)
2754 {
2755     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2756     HRESULT hres;
2757     VARIANT v, exp, vDst;
2758     DECIMAL *pdec = &V_DECIMAL(&v);
2759     CY *pcy = &V_CY(&v);
2760     size_t i;
2761
2762     CHECKPTR(VarFix);
2763
2764     /* Test all possible V_VT values */
2765     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2766     {
2767         VARTYPE vt;
2768
2769         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2770         {
2771             HRESULT bFail = TRUE;
2772
2773             SKIPTESTS(vt);
2774
2775             memset(&v, 0, sizeof(v));
2776             V_VT(&v) = vt | ExtraFlags[i];
2777             V_VT(&vDst) = VT_EMPTY;
2778
2779             switch (V_VT(&v))
2780             {
2781               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2782               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2783               case VT_DATE: case VT_CY:
2784                 bFail = FALSE;
2785                 break;
2786               case VT_I8:
2787                 if (HAVE_OLEAUT32_I8)
2788                   bFail = FALSE;
2789                 break;
2790             }
2791
2792             hres = pVarFix(&v,&vDst);
2793             if (bFail)
2794               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2795                  "VarFix: expected failure, got 0x%X vt %d|0x%X\n",
2796                  hres, vt, ExtraFlags[i]);
2797             else
2798                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%X vt %d|0x%X\n",
2799                     hres, vt, ExtraFlags[i]);
2800         }
2801     }
2802
2803     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2804     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2805     VARFIX(BOOL,1,I2,1);
2806     VARFIX(UI1,1,UI1,1);
2807     VARFIX(I2,-1,I2,-1);
2808     VARFIX(I4,-1,I4,-1);
2809     if (HAVE_OLEAUT32_I8)
2810     {
2811         VARFIX(I8,-1,I8,-1);
2812     }
2813     VARFIX(R4,1.4f,R4,1);
2814     VARFIX(R4,1.5f,R4,1);
2815     VARFIX(R4,1.6f,R4,1);
2816     VARFIX(R4,-1.4f,R4,-1);
2817     VARFIX(R4,-1.5f,R4,-1);
2818     VARFIX(R4,-1.6f,R4,-1);
2819     /* DATE & R8 round as for R4 */
2820     VARFIX(DATE,-1,DATE,-1);
2821     VARFIX(R8,-1,R8,-1);
2822     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2823
2824     V_VT(&v) = VT_EMPTY;
2825     hres = pVarFix(&v,&vDst);
2826     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2827        "VarFix: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
2828        hres, V_VT(&vDst), V_I2(&vDst));
2829
2830     V_VT(&v) = VT_NULL;
2831     hres = pVarFix(&v,&vDst);
2832     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2833        "VarFix: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
2834
2835     V_VT(&v) = VT_DECIMAL;
2836     S(U(*pdec)).sign = DECIMAL_NEG;
2837     S(U(*pdec)).scale = 0;
2838     pdec->Hi32 = 0;
2839     S1(U1(*pdec)).Mid32 = 0;
2840     S1(U1(*pdec)).Lo32 = 1;
2841     hres = pVarFix(&v,&vDst);
2842     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2843        "VarFix: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
2844        hres, V_VT(&vDst));
2845
2846     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2847
2848     V_VT(&v) = VT_CY;
2849     pcy->int64 = -10000;
2850     hres = pVarFix(&v,&vDst);
2851     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2852        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2853
2854     V_VT(&v) = VT_CY;
2855     pcy->int64 = -16000;
2856     hres = pVarFix(&v,&vDst);
2857     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2858        "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2859 }
2860
2861 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2862
2863 #define VARINT(vt,val,rvt,rval)                  \
2864     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2865     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2866     test_var_call1( __LINE__, pVarInt, &v, &exp )
2867
2868 static void test_VarInt(void)
2869 {
2870     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2871     HRESULT hres;
2872     VARIANT v, exp, vDst;
2873     DECIMAL *pdec = &V_DECIMAL(&v);
2874     CY *pcy = &V_CY(&v);
2875     size_t i;
2876
2877     CHECKPTR(VarInt);
2878
2879     /* Test all possible V_VT values */
2880     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2881     {
2882         VARTYPE vt;
2883
2884         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2885         {
2886             HRESULT bFail = TRUE;
2887
2888             SKIPTESTS(vt);
2889
2890             memset(&v, 0, sizeof(v));
2891             V_VT(&v) = vt | ExtraFlags[i];
2892             V_VT(&vDst) = VT_EMPTY;
2893
2894             switch (V_VT(&v))
2895             {
2896               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2897               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2898               case VT_DATE: case VT_CY:
2899                 bFail = FALSE;
2900                 break;
2901               case VT_I8:
2902                 if (HAVE_OLEAUT32_I8)
2903                   bFail = FALSE;
2904                 break;
2905             }
2906
2907             hres = pVarInt(&v,&vDst);
2908             if (bFail)
2909               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2910                  "VarInt: expected failure, got 0x%X vt %d|0x%X\n",
2911                  hres, vt, ExtraFlags[i]);
2912             else
2913                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%X vt %d|0x%X\n",
2914                     hres, vt, ExtraFlags[i]);
2915         }
2916     }
2917
2918     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2919     VARINT(BOOL,VARIANT_FALSE,I2,0);
2920     VARINT(BOOL,1,I2,1);
2921     VARINT(UI1,1,UI1,1);
2922     VARINT(I2,-1,I2,-1);
2923     VARINT(I4,-1,I4,-1);
2924     if (HAVE_OLEAUT32_I8)
2925     {
2926         VARINT(I8,-1,I8,-1);
2927     }
2928     VARINT(R4,1.4f,R4,1);
2929     VARINT(R4,1.5f,R4,1);
2930     VARINT(R4,1.6f,R4,1);
2931     VARINT(R4,-1.4f,R4,-2); /* Note these 3 are different from VarFix */
2932     VARINT(R4,-1.5f,R4,-2);
2933     VARINT(R4,-1.6f,R4,-2);
2934     /* DATE & R8 round as for R4 */
2935     VARINT(DATE,-1,DATE,-1);
2936     VARINT(R8,-1,R8,-1);
2937     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
2938
2939     V_VT(&v) = VT_EMPTY;
2940     hres = pVarInt(&v,&vDst);
2941     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2942        "VarInt: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
2943        hres, V_VT(&vDst), V_I2(&vDst));
2944
2945     V_VT(&v) = VT_NULL;
2946     hres = pVarInt(&v,&vDst);
2947     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2948        "VarInt: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
2949
2950     V_VT(&v) = VT_DECIMAL;
2951     S(U(*pdec)).sign = DECIMAL_NEG;
2952     S(U(*pdec)).scale = 0;
2953     pdec->Hi32 = 0;
2954     S1(U1(*pdec)).Mid32 = 0;
2955     S1(U1(*pdec)).Lo32 = 1;
2956     hres = pVarInt(&v,&vDst);
2957     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2958        "VarInt: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
2959        hres, V_VT(&vDst));
2960
2961     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
2962
2963     V_VT(&v) = VT_CY;
2964     pcy->int64 = -10000;
2965     hres = pVarInt(&v,&vDst);
2966     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2967        "VarInt: VT_CY wrong, hres=0x%X\n", hres);
2968
2969     V_VT(&v) = VT_CY;
2970     pcy->int64 = -11000;
2971     hres = pVarInt(&v,&vDst);
2972     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
2973        "VarInt: VT_CY wrong, hres=0x%X 0x%x%08x\n",
2974        hres, (DWORD)(V_CY(&vDst).int64 >> 32), (DWORD)V_CY(&vDst).int64);
2975 }
2976
2977 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
2978
2979 #define VARNEG(vt,val,rvt,rval)                  \
2980     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2981     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2982     test_var_call1( __LINE__, pVarNeg, &v, &exp )
2983
2984 static void test_VarNeg(void)
2985 {
2986     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2987     static const WCHAR szNum1[] = {'1','\0' };
2988     HRESULT hres;
2989     VARIANT v, exp, vDst;
2990     DECIMAL *pdec = &V_DECIMAL(&v);
2991     CY *pcy = &V_CY(&v);
2992     size_t i;
2993
2994     CHECKPTR(VarNeg);
2995
2996     /* Test all possible V_VT values. But don't test the exact return values
2997      * except for success/failure, since M$ made a hash of them in the
2998      * native version. This at least ensures (as with all tests here) that
2999      * we will notice if/when new vtypes/flags are added in native.
3000      */
3001     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3002     {
3003         VARTYPE vt;
3004
3005         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3006         {
3007             HRESULT bFail = TRUE;
3008
3009             SKIPTESTS(vt);
3010
3011             memset(&v, 0, sizeof(v));
3012             V_VT(&v) = vt | ExtraFlags[i];
3013             V_VT(&vDst) = VT_EMPTY;
3014
3015             switch (V_VT(&v))
3016             {
3017             case VT_UI1: case VT_I2: case VT_I4:
3018             case VT_R4:  case VT_R8:
3019             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3020             case VT_DATE: case VT_CY:
3021                 bFail = FALSE;
3022                 break;
3023             case VT_I8:
3024                 if (HAVE_OLEAUT32_I8)
3025                     bFail = FALSE;
3026             }
3027
3028             hres = pVarNeg(&v,&vDst);
3029             if (bFail)
3030                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3031                    "VarNeg: expected failure, got 0x%X vt %d|0x%X\n",
3032                    hres, vt, ExtraFlags[i]);
3033             else
3034                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%X vt %d|0x%X\n",
3035                     hres, vt, ExtraFlags[i]);
3036         }
3037     }
3038
3039     VARNEG(BOOL,VARIANT_TRUE,I2,1);
3040     VARNEG(BOOL,VARIANT_FALSE,I2,0);
3041     VARNEG(BOOL,1,I2,-1);
3042     VARNEG(UI1,1,I2,-1);
3043     VARNEG(UI1,254,I2,-254);
3044     VARNEG(I2,-32768,I4,32768);
3045     VARNEG(I2,-1,I2,1);
3046     VARNEG(I2,1,I2,-1);
3047     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
3048     VARNEG(I4,-1,I4,1);
3049     VARNEG(I4,1,I4,-1);
3050     if (HAVE_OLEAUT32_I8)
3051     {
3052         VARNEG(I8,1,I8,-1);
3053         VARNEG(I8,-1,I8,1);
3054     }
3055     VARNEG(R4,1,R4,-1);
3056     VARNEG(R4,-1,R4,1);
3057     VARNEG(DATE,1,DATE,-1);
3058     VARNEG(DATE,-1,DATE,1);
3059     VARNEG(R8,1,R8,-1);
3060     VARNEG(R8,-1,R8,1);
3061     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
3062     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
3063
3064     V_VT(&v) = VT_EMPTY;
3065     hres = pVarNeg(&v,&vDst);
3066     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3067        "VarNeg: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3068        hres, V_VT(&vDst), V_I2(&vDst));
3069
3070     V_VT(&v) = VT_NULL;
3071     hres = pVarNeg(&v,&vDst);
3072     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3073        "VarNeg: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3074
3075     V_VT(&v) = VT_DECIMAL;
3076     S(U(*pdec)).sign = DECIMAL_NEG;
3077     S(U(*pdec)).scale = 0;
3078     pdec->Hi32 = 0;
3079     S1(U1(*pdec)).Mid32 = 0;
3080     S1(U1(*pdec)).Lo32 = 1;
3081     hres = pVarNeg(&v,&vDst);
3082     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3083        S(U(V_DECIMAL(&vDst))).sign == 0,
3084        "VarNeg: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3085        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3086
3087     S(U(*pdec)).sign = 0;
3088     hres = pVarNeg(&v,&vDst);
3089     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3090        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3091        "VarNeg: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3092        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3093
3094     V_VT(&v) = VT_CY;
3095     pcy->int64 = -10000;
3096     hres = pVarNeg(&v,&vDst);
3097     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3098        "VarNeg: VT_CY wrong, hres=0x%X\n", hres);
3099 }
3100
3101 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
3102
3103 static void test_Round( int line, VARIANT *arg, int deci, VARIANT *expected )
3104 {
3105     VARIANT result;
3106     HRESULT hres;
3107
3108     memset( &result, 0, sizeof(result) );
3109     hres = pVarRound( arg, deci, &result );
3110     ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
3111     if (hres == S_OK)
3112         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
3113                             "got %s expected %s\n", variantstr(&result), variantstr(expected) );
3114 }
3115 #define VARROUND(vt,val,deci,rvt,rval)           \
3116     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3117     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3118     test_Round( __LINE__, &v, deci, &exp )
3119
3120 static void test_VarRound(void)
3121 {
3122     static WCHAR szNumMin[] = {'-','1','.','4','4','9','\0' };
3123     static WCHAR szNum[] = {'1','.','4','5','1','\0' };
3124     HRESULT hres;
3125     VARIANT v, exp, vDst;
3126     CY *pcy = &V_CY(&v);
3127     char buff[8];
3128
3129     CHECKPTR(VarRound);
3130
3131     /* first check valid integer types */
3132     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
3133     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
3134     VARROUND(BOOL,1,0,I2,1);
3135     VARROUND(UI1,1,0,UI1,1);
3136     VARROUND(UI1,254,0,UI1,254);
3137     VARROUND(I2,-32768,0,I2,-32768);
3138     VARROUND(I2,-1,0,I2,-1);
3139     VARROUND(I2,1,0,I2,1);
3140     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
3141     VARROUND(I4,-1,0,I4,-1);
3142     VARROUND(I4,1,0,I4,1);
3143
3144
3145     /* MSDN states that rounding of R4/R8 is dependent on the underlying
3146      * bit pattern of the number and so is architecture dependent. In this
3147      * case Wine returns .2 (which is more correct) and Native returns .3
3148      */
3149
3150     VARROUND(R4,1.0f,0,R4,1.0f);
3151     VARROUND(R4,-1.0f,0,R4,-1.0f);
3152     VARROUND(R8,1.0,0,R8,1.0);
3153     VARROUND(R8,-1.0,0,R8,-1.0);
3154
3155     /* floating point numbers aren't exactly equal and we can't just
3156      * compare the first few digits. */
3157     VARROUND(DATE,1.451,1,DATE,1.5);
3158     VARROUND(DATE,-1.449,1,DATE,-1.4);
3159
3160     /* replace the decimal separator */
3161     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
3162     if (!buff[1]) {
3163         szNumMin[2] = buff[0];
3164         szNum[1] = buff[0];
3165         VARROUND(BSTR,(BSTR)szNumMin,1,R8,-1.40);
3166         VARROUND(BSTR,(BSTR)szNum,1,R8,1.50);
3167     } else {
3168         skip("Skipping VarRound(BSTR) as decimal separator is '%s'\n", buff);
3169     }
3170
3171     VARROUND(R4,1.23456f,0,R4,1.0f);
3172     VARROUND(R4,1.23456f,1,R4,1.2f);
3173     VARROUND(R4,1.23456f,2,R4,1.23f);
3174     VARROUND(R4,1.23456f,3,R4,1.235f);
3175     VARROUND(R4,1.23456f,4,R4,1.2346f);
3176     VARROUND(R4,-1.23456f,0,R4,-1.0f);
3177     VARROUND(R4,-1.23456f,1,R4,-1.2f);
3178     VARROUND(R4,-1.23456f,2,R4,-1.23f);
3179     VARROUND(R4,-1.23456f,3,R4,-1.235f);
3180     VARROUND(R4,-1.23456f,4,R4,-1.2346f);
3181
3182     VARROUND(R8,1.23456,0,R8,1.0);
3183     VARROUND(R8,1.23456,1,R8,1.2);
3184     VARROUND(R8,1.23456,2,R8,1.23);
3185     VARROUND(R8,1.23456,3,R8,1.235);
3186     VARROUND(R8,1.23456,4,R8,1.2346);
3187     VARROUND(R8,-1.23456,0,R8,-1.0);
3188     VARROUND(R8,-1.23456,1,R8,-1.2);
3189     VARROUND(R8,-1.23456,2,R8,-1.23);
3190     VARROUND(R8,-1.23456,3,R8,-1.235);
3191     VARROUND(R8,-1.23456,4,R8,-1.2346);
3192
3193     V_VT(&v) = VT_EMPTY;
3194     hres = pVarRound(&v,0,&vDst);
3195     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3196         "VarRound: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3197         hres, V_VT(&vDst), V_I2(&vDst));
3198
3199     V_VT(&v) = VT_NULL;
3200     hres = pVarRound(&v,0,&vDst);
3201     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3202         "VarRound: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3203
3204     /* not yet implemented so no use testing yet
3205     todo_wine {
3206         DECIMAL *pdec = &V_DECIMAL(&v);
3207         V_VT(&v) = VT_DECIMAL;
3208         S(U(*pdec)).sign = DECIMAL_NEG;
3209         S(U(*pdec)).scale = 0;
3210         pdec->Hi32 = 0;
3211         S1(U1(*pdec)).Mid32 = 0;
3212         S1(U1(*pdec)).Lo32 = 1;
3213         hres = pVarRound(&v,0,&vDst);
3214         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3215             S(U(V_DECIMAL(&vDst))).sign == 0,
3216             "VarRound: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3217             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3218
3219         S(U(*pdec)).sign = 0;
3220         hres = pVarRound(&v,0,&vDst);
3221         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3222             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3223             "VarRound: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3224             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3225     }
3226     */
3227
3228     V_VT(&v) = VT_CY;
3229     pcy->int64 = 10000;
3230     hres = pVarRound(&v,0,&vDst);
3231     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3232         "VarRound: VT_CY wrong, hres=0x%X\n", hres);
3233
3234 }
3235
3236 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
3237
3238 #define VARXOR(vt1,val1,vt2,val2,rvt,rval)               \
3239         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3240         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3241         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3242         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3243
3244 #define VARXORCY(vt1,val1,val2,rvt,rval)                 \
3245         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3246         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3247         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3248         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3249
3250 static void test_VarXor(void)
3251 {
3252     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3253     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3254     VARIANT left, right, exp, result;
3255     BSTR lbstr, rbstr;
3256     VARTYPE i;
3257     HRESULT hres;
3258
3259     CHECKPTR(VarXor);
3260
3261     /* Test all possible flag/vt combinations & the resulting vt type */
3262     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3263     {
3264         VARTYPE leftvt, rightvt, resvt;
3265
3266         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3267         {
3268
3269             SKIPTESTS(leftvt);
3270
3271             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3272             {
3273                 BOOL bFail = FALSE;
3274
3275                 SKIPTESTS(rightvt);
3276
3277                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3278                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3279                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3280                     continue;
3281
3282                 memset(&left, 0, sizeof(left));
3283                 memset(&right, 0, sizeof(right));
3284                 V_VT(&left) = leftvt | ExtraFlags[i];
3285                 V_VT(&right) = rightvt | ExtraFlags[i];
3286                 V_VT(&result) = VT_EMPTY;
3287                 resvt = VT_I4;
3288
3289                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3290                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3291                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3292                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3293                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3294                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3295                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3296                 {
3297                     bFail = TRUE;
3298                 }
3299                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3300                 {
3301                     if (leftvt == rightvt ||
3302                         leftvt == VT_I2 || rightvt == VT_I2 ||
3303                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3304                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3305                         resvt = VT_I2;
3306                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3307                         resvt = VT_NULL;
3308                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3309                         resvt = VT_I8;
3310                 }
3311                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3312                 {
3313                     resvt = VT_NULL;
3314                 }
3315                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3316                 {
3317                     if (leftvt == rightvt)
3318                         resvt = VT_UI1;
3319                     else if (leftvt == rightvt ||
3320                         leftvt == VT_I2 || rightvt == VT_I2 ||
3321                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3322                     {
3323                         resvt = VT_I2;
3324                     }
3325                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3326                         resvt = VT_I8;
3327                 }
3328                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3329                 {
3330                     if (leftvt == rightvt ||
3331                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3332                         resvt = VT_I2;
3333                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3334                         resvt = VT_I8;
3335                 }
3336                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3337                 {
3338                     resvt = VT_BOOL;
3339                 }
3340                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3341                 {
3342                     if (leftvt == VT_INT || rightvt == VT_INT)
3343                         bFail = TRUE;
3344                     else
3345                         resvt = VT_I8;
3346                 }
3347                 hres = pVarXor(&left, &right, &result);
3348                 if (bFail)
3349                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3350                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
3351                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3352                        V_VT(&result));
3353                 else
3354                     ok(hres == S_OK && V_VT(&result) == resvt,
3355                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
3356                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3357                        V_VT(&result));
3358             }
3359         }
3360     }
3361
3362     /* Test returned values
3363      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3364      */
3365     VARXOR(EMPTY,0,EMPTY,0,I2,0);
3366     VARXOR(EMPTY,1,EMPTY,0,I2,0);
3367     VARXOR(EMPTY,0,NULL,0,NULL,0);
3368     VARXOR(EMPTY,0,I1,0,I4,0);
3369     VARXOR(EMPTY,0,I1,1,I4,1);
3370     VARXOR(EMPTY,0,UI1,0,I2,0);
3371     VARXOR(EMPTY,0,UI1,1,I2,1);
3372     VARXOR(EMPTY,0,I2,0,I2,0);
3373     VARXOR(EMPTY,0,I2,1,I2,1);
3374     VARXOR(EMPTY,0,UI2,0,I4,0);
3375     VARXOR(EMPTY,0,UI2,1,I4,1);
3376     VARXOR(EMPTY,0,I4,0,I4,0);
3377     VARXOR(EMPTY,0,I4,1,I4,1);
3378     VARXOR(EMPTY,0,UI4,0,I4,0);
3379     VARXOR(EMPTY,0,UI4,1,I4,1);
3380     if (HAVE_OLEAUT32_I8)
3381     {
3382         VARXOR(EMPTY,0,I8,0,I8,0);
3383         VARXOR(EMPTY,0,I8,1,I8,1);
3384         VARXOR(EMPTY,0,UI8,0,I4,0);
3385         VARXOR(EMPTY,0,UI8,1,I4,1);
3386     }
3387     VARXOR(EMPTY,0,INT,0,I4,0);
3388     VARXOR(EMPTY,0,INT,1,I4,1);
3389     VARXOR(EMPTY,0,UINT,0,I4,0);
3390     VARXOR(EMPTY,0,UINT,1,I4,1);
3391     VARXOR(EMPTY,0,BOOL,0,I2,0);
3392     VARXOR(EMPTY,0,BOOL,1,I2,1);
3393     VARXOR(EMPTY,0,R4,0,I4,0);
3394     VARXOR(EMPTY,0,R4,1,I4,1);
3395     VARXOR(EMPTY,0,R8,0,I4,0);
3396     VARXOR(EMPTY,0,R8,1,I4,1);
3397     rbstr = SysAllocString(szFalse);
3398     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3399     SysFreeString(rbstr);
3400     rbstr = SysAllocString(szTrue);
3401     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3402     VARXORCY(EMPTY,0,10000,I4,1);
3403     SysFreeString(rbstr);
3404
3405     /* NULL OR 0 = NULL. NULL OR n = n */
3406     VARXOR(NULL,0,NULL,0,NULL,0);
3407     VARXOR(NULL,1,NULL,0,NULL,0);
3408     VARXOR(NULL,0,I1,0,NULL,0);
3409     VARXOR(NULL,0,I1,1,NULL,0);
3410     VARXOR(NULL,0,UI1,0,NULL,0);
3411     VARXOR(NULL,0,UI1,1,NULL,0);
3412     VARXOR(NULL,0,I2,0,NULL,0);
3413     VARXOR(NULL,0,I2,1,NULL,0);
3414     VARXOR(NULL,0,UI2,0,NULL,0);
3415     VARXOR(NULL,0,UI2,1,NULL,0);
3416     VARXOR(NULL,0,I4,0,NULL,0);
3417     VARXOR(NULL,0,I4,1,NULL,0);
3418     VARXOR(NULL,0,UI4,0,NULL,0);
3419     VARXOR(NULL,0,UI4,1,NULL,0);
3420     if (HAVE_OLEAUT32_I8)
3421     {
3422         VARXOR(NULL,0,I8,0,NULL,0);
3423         VARXOR(NULL,0,I8,1,NULL,0);
3424         VARXOR(NULL,0,UI8,0,NULL,0);
3425         VARXOR(NULL,0,UI8,1,NULL,0);
3426     }
3427     VARXOR(NULL,0,INT,0,NULL,0);
3428     VARXOR(NULL,0,INT,1,NULL,0);
3429     VARXOR(NULL,0,UINT,0,NULL,0);
3430     VARXOR(NULL,0,UINT,1,NULL,0);
3431     VARXOR(NULL,0,BOOL,0,NULL,0);
3432     VARXOR(NULL,0,BOOL,1,NULL,0);
3433     VARXOR(NULL,0,R4,0,NULL,0);
3434     VARXOR(NULL,0,R4,1,NULL,0);
3435     VARXOR(NULL,0,R8,0,NULL,0);
3436     VARXOR(NULL,0,R8,1,NULL,0);
3437     rbstr = SysAllocString(szFalse);
3438     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3439     SysFreeString(rbstr);
3440     rbstr = SysAllocString(szTrue);
3441     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3442     SysFreeString(rbstr);
3443     VARXORCY(NULL,0,10000,NULL,0);
3444     VARXORCY(NULL,0,0,NULL,0);
3445
3446     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3447     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3448     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3449     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3450     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3451     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3452     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3453     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3454     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3455     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3456     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3457     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3458     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3459     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3460     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3461     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3462     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3463     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3464     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3465     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3466     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3467     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3468     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3469     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3470     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3471     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3472     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3473     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3474     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3475     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3476     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3477     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3478     if (HAVE_OLEAUT32_I8)
3479     {
3480         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3481         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3482         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3483         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3484          * to I4 is performed.
3485          */
3486         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3487         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3488         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3489     }
3490     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3491     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3492     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3493     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3494     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3495     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3496     rbstr = SysAllocString(szFalse);
3497     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3498     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3499     SysFreeString(rbstr);
3500     rbstr = SysAllocString(szTrue);
3501     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3502     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3503     SysFreeString(rbstr);
3504     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3505     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3506     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3507
3508     VARXOR(I1,-1,I1,-1,I4,0);
3509     VARXOR(I1,-1,I1,0,I4,-1);
3510     VARXOR(I1,0,I1,0,I4,0);
3511     VARXOR(I1,-1,UI1,255,I4,-256);
3512     VARXOR(I1,-1,UI1,0,I4,-1);
3513     VARXOR(I1,0,UI1,0,I4,0);
3514     VARXOR(I1,-1,I2,-1,I4,0);
3515     VARXOR(I1,-1,I2,0,I4,-1);
3516     VARXOR(I1,0,I2,0,I4,0);
3517     VARXOR(I1,-1,UI2,65535,I4,-65536);
3518     VARXOR(I1,-1,UI2,0,I4,-1);
3519     VARXOR(I1,0,UI2,0,I4,0);
3520     VARXOR(I1,-1,I4,-1,I4,0);
3521     VARXOR(I1,-1,I4,0,I4,-1);
3522     VARXOR(I1,0,I4,0,I4,0);
3523     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3524     VARXOR(I1,-1,UI4,0,I4,-1);
3525     VARXOR(I1,0,UI4,0,I4,0);
3526     VARXOR(I1,-1,R4,-1,I4,0);
3527     VARXOR(I1,-1,R4,0,I4,-1);
3528     VARXOR(I1,0,R4,0,I4,0);
3529     VARXOR(I1,-1,R8,-1,I4,0);
3530     VARXOR(I1,-1,R8,0,I4,-1);
3531     VARXOR(I1,0,R8,0,I4,0);
3532     VARXOR(I1,-1,DATE,-1,I4,0);
3533     VARXOR(I1,-1,DATE,0,I4,-1);
3534     VARXOR(I1,0,DATE,0,I4,0);
3535     if (HAVE_OLEAUT32_I8)
3536     {
3537         VARXOR(I1,-1,I8,-1,I8,0);
3538         VARXOR(I1,-1,I8,0,I8,-1);
3539         VARXOR(I1,0,I8,0,I8,0);
3540         VARXOR(I1,-1,UI8,0,I4,-1);
3541         VARXOR(I1,0,UI8,0,I4,0);
3542     }
3543     VARXOR(I1,-1,INT,-1,I4,0);
3544     VARXOR(I1,-1,INT,0,I4,-1);
3545     VARXOR(I1,0,INT,0,I4,0);
3546     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3547     VARXOR(I1,-1,UINT,0,I4,-1);
3548     VARXOR(I1,0,UINT,0,I4,0);
3549     rbstr = SysAllocString(szFalse);
3550     VARXOR(I1,0,BSTR,rbstr,I4,0);
3551     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3552     SysFreeString(rbstr);
3553     rbstr = SysAllocString(szTrue);
3554     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3555     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3556     SysFreeString(rbstr);
3557     VARXORCY(I1,-1,10000,I4,-2);
3558     VARXORCY(I1,-1,0,I4,-1);
3559     VARXORCY(I1,0,0,I4,0);
3560
3561     VARXOR(UI1,255,UI1,255,UI1,0);
3562     VARXOR(UI1,255,UI1,0,UI1,255);
3563     VARXOR(UI1,0,UI1,0,UI1,0);
3564     VARXOR(UI1,255,I2,-1,I2,-256);
3565     VARXOR(UI1,255,I2,0,I2,255);
3566     VARXOR(UI1,0,I2,0,I2,0);
3567     VARXOR(UI1,255,UI2,65535,I4,65280);
3568     VARXOR(UI1,255,UI2,0,I4,255);
3569     VARXOR(UI1,0,UI2,0,I4,0);
3570     VARXOR(UI1,255,I4,-1,I4,-256);
3571     VARXOR(UI1,255,I4,0,I4,255);
3572     VARXOR(UI1,0,I4,0,I4,0);
3573     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3574     VARXOR(UI1,255,UI4,0,I4,255);
3575     VARXOR(UI1,0,UI4,0,I4,0);
3576     VARXOR(UI1,255,R4,-1,I4,-256);
3577     VARXOR(UI1,255,R4,0,I4,255);
3578     VARXOR(UI1,0,R4,0,I4,0);
3579     VARXOR(UI1,255,R8,-1,I4,-256);
3580     VARXOR(UI1,255,R8,0,I4,255);
3581     VARXOR(UI1,0,R8,0,I4,0);
3582     VARXOR(UI1,255,DATE,-1,I4,-256);
3583     VARXOR(UI1,255,DATE,0,I4,255);
3584     VARXOR(UI1,0,DATE,0,I4,0);
3585     if (HAVE_OLEAUT32_I8)
3586     {
3587         VARXOR(UI1,255,I8,-1,I8,-256);
3588         VARXOR(UI1,255,I8,0,I8,255);
3589         VARXOR(UI1,0,I8,0,I8,0);
3590         VARXOR(UI1,255,UI8,0,I4,255);
3591         VARXOR(UI1,0,UI8,0,I4,0);
3592     }
3593     VARXOR(UI1,255,INT,-1,I4,-256);
3594     VARXOR(UI1,255,INT,0,I4,255);
3595     VARXOR(UI1,0,INT,0,I4,0);
3596     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3597     VARXOR(UI1,255,UINT,0,I4,255);
3598     VARXOR(UI1,0,UINT,0,I4,0);
3599     rbstr = SysAllocString(szFalse);
3600     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3601     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3602     SysFreeString(rbstr);
3603     rbstr = SysAllocString(szTrue);
3604     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3605     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3606     SysFreeString(rbstr);
3607     VARXORCY(UI1,255,10000,I4,254);
3608     VARXORCY(UI1,255,0,I4,255);
3609     VARXORCY(UI1,0,0,I4,0);
3610
3611     VARXOR(I2,-1,I2,-1,I2,0);
3612     VARXOR(I2,-1,I2,0,I2,-1);
3613     VARXOR(I2,0,I2,0,I2,0);
3614     VARXOR(I2,-1,UI2,65535,I4,-65536);
3615     VARXOR(I2,-1,UI2,0,I4,-1);
3616     VARXOR(I2,0,UI2,0,I4,0);
3617     VARXOR(I2,-1,I4,-1,I4,0);
3618     VARXOR(I2,-1,I4,0,I4,-1);
3619     VARXOR(I2,0,I4,0,I4,0);
3620     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3621     VARXOR(I2,-1,UI4,0,I4,-1);
3622     VARXOR(I2,0,UI4,0,I4,0);
3623     VARXOR(I2,-1,R4,-1,I4,0);
3624     VARXOR(I2,-1,R4,0,I4,-1);
3625     VARXOR(I2,0,R4,0,I4,0);
3626     VARXOR(I2,-1,R8,-1,I4,0);
3627     VARXOR(I2,-1,R8,0,I4,-1);
3628     VARXOR(I2,0,R8,0,I4,0);
3629     VARXOR(I2,-1,DATE,-1,I4,0);
3630     VARXOR(I2,-1,DATE,0,I4,-1);
3631     VARXOR(I2,0,DATE,0,I4,0);
3632     if (HAVE_OLEAUT32_I8)
3633     {
3634         VARXOR(I2,-1,I8,-1,I8,0);
3635         VARXOR(I2,-1,I8,0,I8,-1);
3636         VARXOR(I2,0,I8,0,I8,0);
3637         VARXOR(I2,-1,UI8,0,I4,-1);
3638         VARXOR(I2,0,UI8,0,I4,0);
3639     }
3640     VARXOR(I2,-1,INT,-1,I4,0);
3641     VARXOR(I2,-1,INT,0,I4,-1);
3642     VARXOR(I2,0,INT,0,I4,0);
3643     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3644     VARXOR(I2,-1,UINT,0,I4,-1);
3645     VARXOR(I2,0,UINT,0,I4,0);
3646     rbstr = SysAllocString(szFalse);
3647     VARXOR(I2,0,BSTR,rbstr,I2,0);
3648     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3649     SysFreeString(rbstr);
3650     rbstr = SysAllocString(szTrue);
3651     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3652     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3653     SysFreeString(rbstr);
3654     VARXORCY(I2,-1,10000,I4,-2);
3655     VARXORCY(I2,-1,0,I4,-1);
3656     VARXORCY(I2,0,0,I4,0);
3657
3658     VARXOR(UI2,65535,UI2,65535,I4,0);
3659     VARXOR(UI2,65535,UI2,0,I4,65535);
3660     VARXOR(UI2,0,UI2,0,I4,0);
3661     VARXOR(UI2,65535,I4,-1,I4,-65536);
3662     VARXOR(UI2,65535,I4,0,I4,65535);
3663     VARXOR(UI2,0,I4,0,I4,0);
3664     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3665     VARXOR(UI2,65535,UI4,0,I4,65535);
3666     VARXOR(UI2,0,UI4,0,I4,0);
3667     VARXOR(UI2,65535,R4,-1,I4,-65536);
3668     VARXOR(UI2,65535,R4,0,I4,65535);
3669     VARXOR(UI2,0,R4,0,I4,0);
3670     VARXOR(UI2,65535,R8,-1,I4,-65536);
3671     VARXOR(UI2,65535,R8,0,I4,65535);
3672     VARXOR(UI2,0,R8,0,I4,0);
3673     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3674     VARXOR(UI2,65535,DATE,0,I4,65535);
3675     VARXOR(UI2,0,DATE,0,I4,0);
3676     if (HAVE_OLEAUT32_I8)
3677     {
3678         VARXOR(UI2,65535,I8,-1,I8,-65536);
3679         VARXOR(UI2,65535,I8,0,I8,65535);
3680         VARXOR(UI2,0,I8,0,I8,0);
3681         VARXOR(UI2,65535,UI8,0,I4,65535);
3682         VARXOR(UI2,0,UI8,0,I4,0);
3683     }
3684     VARXOR(UI2,65535,INT,-1,I4,-65536);
3685     VARXOR(UI2,65535,INT,0,I4,65535);
3686     VARXOR(UI2,0,INT,0,I4,0);
3687     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3688     VARXOR(UI2,65535,UINT,0,I4,65535);
3689     VARXOR(UI2,0,UINT,0,I4,0);
3690     rbstr = SysAllocString(szFalse);
3691     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3692     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3693     SysFreeString(rbstr);
3694     rbstr = SysAllocString(szTrue);
3695     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3696     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3697     SysFreeString(rbstr);
3698     VARXORCY(UI2,65535,10000,I4,65534);
3699     VARXORCY(UI2,65535,0,I4,65535);
3700     VARXORCY(UI2,0,0,I4,0);
3701
3702     VARXOR(I4,-1,I4,-1,I4,0);
3703     VARXOR(I4,-1,I4,0,I4,-1);
3704     VARXOR(I4,0,I4,0,I4,0);
3705     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3706     VARXOR(I4,-1,UI4,0,I4,-1);
3707     VARXOR(I4,0,UI4,0,I4,0);
3708     VARXOR(I4,-1,R4,-1,I4,0);
3709     VARXOR(I4,-1,R4,0,I4,-1);
3710     VARXOR(I4,0,R4,0,I4,0);
3711     VARXOR(I4,-1,R8,-1,I4,0);
3712     VARXOR(I4,-1,R8,0,I4,-1);
3713     VARXOR(I4,0,R8,0,I4,0);
3714     VARXOR(I4,-1,DATE,-1,I4,0);
3715     VARXOR(I4,-1,DATE,0,I4,-1);
3716     VARXOR(I4,0,DATE,0,I4,0);
3717     if (HAVE_OLEAUT32_I8)
3718     {
3719         VARXOR(I4,-1,I8,-1,I8,0);
3720         VARXOR(I4,-1,I8,0,I8,-1);
3721         VARXOR(I4,0,I8,0,I8,0);
3722         VARXOR(I4,-1,UI8,0,I4,-1);
3723         VARXOR(I4,0,UI8,0,I4,0);
3724     }
3725     VARXOR(I4,-1,INT,-1,I4,0);
3726     VARXOR(I4,-1,INT,0,I4,-1);
3727     VARXOR(I4,0,INT,0,I4,0);
3728     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3729     VARXOR(I4,-1,UINT,0,I4,-1);
3730     VARXOR(I4,0,UINT,0,I4,0);
3731     rbstr = SysAllocString(szFalse);
3732     VARXOR(I4,0,BSTR,rbstr,I4,0);
3733     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3734     SysFreeString(rbstr);
3735     rbstr = SysAllocString(szTrue);
3736     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3737     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3738     SysFreeString(rbstr);
3739     VARXORCY(I4,-1,10000,I4,-2);
3740     VARXORCY(I4,-1,0,I4,-1);
3741     VARXORCY(I4,0,0,I4,0);
3742
3743     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3744     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3745     VARXOR(UI4,0,UI4,0,I4,0);
3746     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3747     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3748     VARXOR(UI4,0,R4,0,I4,0);
3749     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3750     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3751     VARXOR(UI4,0,R8,0,I4,0);
3752     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3753     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3754     VARXOR(UI4,0,DATE,0,I4,0);
3755     if (HAVE_OLEAUT32_I8)
3756     {
3757         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3758         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3759         VARXOR(UI4,0,I8,0,I8,0);
3760         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3761         VARXOR(UI4,0,UI8,0,I4,0);
3762     }
3763     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3764     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3765     VARXOR(UI4,0,INT,0,I4,0);
3766     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3767     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3768     VARXOR(UI4,0,UINT,0,I4,0);
3769     rbstr = SysAllocString(szFalse);
3770     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3771     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3772     SysFreeString(rbstr);
3773     rbstr = SysAllocString(szTrue);
3774     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3775     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3776     SysFreeString(rbstr);
3777     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3778     VARXORCY(UI4,0xffffffff,0,I4,-1);
3779     VARXORCY(UI4,0,0,I4,0);
3780
3781     VARXOR(R4,-1,R4,-1,I4,0);
3782     VARXOR(R4,-1,R4,0,I4,-1);
3783     VARXOR(R4,0,R4,0,I4,0);
3784     VARXOR(R4,-1,R8,-1,I4,0);
3785     VARXOR(R4,-1,R8,0,I4,-1);
3786     VARXOR(R4,0,R8,0,I4,0);
3787     VARXOR(R4,-1,DATE,-1,I4,0);
3788     VARXOR(R4,-1,DATE,0,I4,-1);
3789     VARXOR(R4,0,DATE,0,I4,0);
3790     if (HAVE_OLEAUT32_I8)
3791     {
3792         VARXOR(R4,-1,I8,-1,I8,0);
3793         VARXOR(R4,-1,I8,0,I8,-1);
3794         VARXOR(R4,0,I8,0,I8,0);
3795         VARXOR(R4,-1,UI8,0,I4,-1);
3796         VARXOR(R4,0,UI8,0,I4,0);
3797     }
3798     VARXOR(R4,-1,INT,-1,I4,0);
3799     VARXOR(R4,-1,INT,0,I4,-1);
3800     VARXOR(R4,0,INT,0,I4,0);
3801     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3802     VARXOR(R4,-1,UINT,0,I4,-1);
3803     VARXOR(R4,0,UINT,0,I4,0);
3804     rbstr = SysAllocString(szFalse);
3805     VARXOR(R4,0,BSTR,rbstr,I4,0);
3806     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3807     SysFreeString(rbstr);
3808     rbstr = SysAllocString(szTrue);
3809     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3810     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3811     SysFreeString(rbstr);
3812     VARXORCY(R4,-1,10000,I4,-2);
3813     VARXORCY(R4,-1,0,I4,-1);
3814     VARXORCY(R4,0,0,I4,0);
3815
3816     VARXOR(R8,-1,R8,-1,I4,0);
3817     VARXOR(R8,-1,R8,0,I4,-1);
3818     VARXOR(R8,0,R8,0,I4,0);
3819     VARXOR(R8,-1,DATE,-1,I4,0);
3820     VARXOR(R8,-1,DATE,0,I4,-1);
3821     VARXOR(R8,0,DATE,0,I4,0);
3822     if (HAVE_OLEAUT32_I8)
3823     {
3824         VARXOR(R8,-1,I8,-1,I8,0);
3825         VARXOR(R8,-1,I8,0,I8,-1);
3826         VARXOR(R8,0,I8,0,I8,0);
3827         VARXOR(R8,-1,UI8,0,I4,-1);
3828         VARXOR(R8,0,UI8,0,I4,0);
3829     }
3830     VARXOR(R8,-1,INT,-1,I4,0);
3831     VARXOR(R8,-1,INT,0,I4,-1);
3832     VARXOR(R8,0,INT,0,I4,0);
3833     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3834     VARXOR(R8,-1,UINT,0,I4,-1);
3835     VARXOR(R8,0,UINT,0,I4,0);
3836     rbstr = SysAllocString(szFalse);
3837     VARXOR(R8,0,BSTR,rbstr,I4,0);
3838     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3839     SysFreeString(rbstr);
3840     rbstr = SysAllocString(szTrue);
3841     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3842     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3843     SysFreeString(rbstr);
3844     VARXORCY(R8,-1,10000,I4,-2);
3845     VARXORCY(R8,-1,0,I4,-1);
3846     VARXORCY(R8,0,0,I4,0);
3847
3848     VARXOR(DATE,-1,DATE,-1,I4,0);
3849     VARXOR(DATE,-1,DATE,0,I4,-1);
3850     VARXOR(DATE,0,DATE,0,I4,0);
3851     if (HAVE_OLEAUT32_I8)
3852     {
3853         VARXOR(DATE,-1,I8,-1,I8,0);
3854         VARXOR(DATE,-1,I8,0,I8,-1);
3855         VARXOR(DATE,0,I8,0,I8,0);
3856         VARXOR(DATE,-1,UI8,0,I4,-1);
3857         VARXOR(DATE,0,UI8,0,I4,0);
3858     }
3859     VARXOR(DATE,-1,INT,-1,I4,0);
3860     VARXOR(DATE,-1,INT,0,I4,-1);
3861     VARXOR(DATE,0,INT,0,I4,0);
3862     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3863     VARXOR(DATE,-1,UINT,0,I4,-1);
3864     VARXOR(DATE,0,UINT,0,I4,0);
3865     rbstr = SysAllocString(szFalse);
3866     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3867     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3868     SysFreeString(rbstr);
3869     rbstr = SysAllocString(szTrue);
3870     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3871     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3872     SysFreeString(rbstr);
3873     VARXORCY(DATE,-1,10000,I4,-2);
3874     VARXORCY(DATE,-1,0,I4,-1);
3875     VARXORCY(DATE,0,0,I4,0);
3876
3877     if (HAVE_OLEAUT32_I8)
3878     {
3879         VARXOR(I8,-1,I8,-1,I8,0);
3880         VARXOR(I8,-1,I8,0,I8,-1);
3881         VARXOR(I8,0,I8,0,I8,0);
3882         VARXOR(I8,-1,UI8,0,I8,-1);
3883         VARXOR(I8,0,UI8,0,I8,0);
3884         VARXOR(I8,-1,UINT,0,I8,-1);
3885         VARXOR(I8,0,UINT,0,I8,0);
3886         rbstr = SysAllocString(szFalse);
3887         VARXOR(I8,0,BSTR,rbstr,I8,0);
3888         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
3889         SysFreeString(rbstr);
3890         rbstr = SysAllocString(szTrue);
3891         VARXOR(I8,0,BSTR,rbstr,I8,-1);
3892         VARXOR(I8,-1,BSTR,rbstr,I8,0);
3893         SysFreeString(rbstr);
3894         VARXORCY(I8,-1,10000,I8,-2);
3895         VARXORCY(I8,-1,0,I8,-1);
3896         VARXORCY(I8,0,0,I8,0);
3897
3898         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
3899         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
3900         VARXOR(UI8,0,UI8,0,I4,0);
3901         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
3902         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
3903         VARXOR(UI8,0,INT,0,I4,0);
3904         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
3905         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
3906         VARXOR(UI8,0,UINT,0,I4,0);
3907         rbstr = SysAllocString(szFalse);
3908         VARXOR(UI8,0,BSTR,rbstr,I4,0);
3909         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
3910         SysFreeString(rbstr);
3911         rbstr = SysAllocString(szTrue);
3912         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
3913         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
3914         SysFreeString(rbstr);
3915         VARXORCY(UI8,0xffff,10000,I4,65534);
3916         VARXORCY(UI8,0xffff,0,I4,0xffff);
3917         VARXORCY(UI8,0,0,I4,0);
3918     }
3919
3920     VARXOR(INT,-1,INT,-1,I4,0);
3921     VARXOR(INT,-1,INT,0,I4,-1);
3922     VARXOR(INT,0,INT,0,I4,0);
3923     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
3924     VARXOR(INT,-1,UINT,0,I4,-1);
3925     VARXOR(INT,0,UINT,0,I4,0);
3926     rbstr = SysAllocString(szFalse);
3927     VARXOR(INT,0,BSTR,rbstr,I4,0);
3928     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
3929     SysFreeString(rbstr);
3930     rbstr = SysAllocString(szTrue);
3931     VARXOR(INT,0,BSTR,rbstr,I4,-1);
3932     VARXOR(INT,-1,BSTR,rbstr,I4,0);
3933     SysFreeString(rbstr);
3934     VARXORCY(INT,-1,10000,I4,-2);
3935     VARXORCY(INT,-1,0,I4,-1);
3936     VARXORCY(INT,0,0,I4,0);
3937
3938     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
3939     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
3940     VARXOR(UINT,0,UINT,0,I4,0);
3941     rbstr = SysAllocString(szFalse);
3942     VARXOR(UINT,0,BSTR,rbstr,I4,0);
3943     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
3944     SysFreeString(rbstr);
3945     rbstr = SysAllocString(szTrue);
3946     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
3947     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
3948     SysFreeString(rbstr);
3949     VARXORCY(UINT,0xffff,10000,I4,65534);
3950     VARXORCY(UINT,0xffff,0,I4,0xffff);
3951     VARXORCY(UINT,0,0,I4,0);
3952
3953     lbstr = SysAllocString(szFalse);
3954     rbstr = SysAllocString(szFalse);
3955     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
3956     SysFreeString(rbstr);
3957     rbstr = SysAllocString(szTrue);
3958     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
3959     SysFreeString(lbstr);
3960     lbstr = SysAllocString(szTrue);
3961     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
3962     VARXORCY(BSTR,lbstr,10000,I4,-2);
3963     SysFreeString(lbstr);
3964     lbstr = SysAllocString(szFalse);
3965     VARXORCY(BSTR,lbstr,10000,I4,1);
3966     SysFreeString(lbstr);
3967     SysFreeString(rbstr);
3968 }
3969
3970 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
3971
3972 #define VAROR(vt1,val1,vt2,val2,rvt,rval)                \
3973         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3974         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3975         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3976         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
3977
3978 #define VARORCY(vt1,val1,val2,rvt,rval)                  \
3979         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3980         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3981         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3982         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
3983
3984 static void test_VarOr(void)
3985 {
3986     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3987     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3988     VARIANT left, right, exp, result;
3989     BSTR lbstr, rbstr;
3990     VARTYPE i;
3991     HRESULT hres;
3992
3993     CHECKPTR(VarOr);
3994
3995     /* Test all possible flag/vt combinations & the resulting vt type */
3996     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3997     {
3998         VARTYPE leftvt, rightvt, resvt;
3999
4000         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4001         {
4002
4003             SKIPTESTS(leftvt);
4004
4005             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4006             {
4007                 BOOL bFail = FALSE;
4008
4009                 SKIPTESTS(rightvt);
4010
4011                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4012                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4013                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4014                     continue;
4015
4016                 memset(&left, 0, sizeof(left));
4017                 memset(&right, 0, sizeof(right));
4018                 V_VT(&left) = leftvt | ExtraFlags[i];
4019                 V_VT(&right) = rightvt | ExtraFlags[i];
4020                 V_VT(&result) = VT_EMPTY;
4021                 resvt = VT_I4;
4022
4023                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4024                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4025                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4026                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4027                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4028                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4029                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4030                 {
4031                     bFail = TRUE;
4032                 }
4033                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4034                 {
4035                     if (leftvt == rightvt ||
4036                         leftvt == VT_I2 || rightvt == VT_I2 ||
4037                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4038                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4039                         resvt = VT_I2;
4040                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4041                         resvt = VT_NULL;
4042                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4043                         resvt = VT_I8;
4044                 }
4045                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4046                 {
4047                     resvt = VT_NULL;
4048                 }
4049                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4050                 {
4051                     if (leftvt == rightvt)
4052                         resvt = VT_UI1;
4053                     else if (leftvt == rightvt ||
4054                         leftvt == VT_I2 || rightvt == VT_I2 ||
4055                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4056                     {
4057                         resvt = VT_I2;
4058                     }
4059                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4060                         resvt = VT_I8;
4061                 }
4062                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4063                 {
4064                     if (leftvt == rightvt ||
4065                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4066                         resvt = VT_I2;
4067                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4068                         resvt = VT_I8;
4069                 }
4070                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4071                 {
4072                     resvt = VT_BOOL;
4073                 }
4074                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4075                 {
4076                     if (leftvt == VT_INT || rightvt == VT_INT)
4077                         bFail = TRUE;
4078                     else
4079                         resvt = VT_I8;
4080                 }
4081                 hres = pVarOr(&left, &right, &result);
4082                 if (bFail)
4083                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4084                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4085                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4086                        V_VT(&result));
4087                 else
4088                     ok(hres == S_OK && V_VT(&result) == resvt,
4089                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4090                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4091                        V_VT(&result));
4092             }
4093         }
4094     }
4095
4096     /* Test returned values. Since we know the returned type is correct
4097      * and that we handle all combinations of invalid types, just check
4098      * that good type combinations produce the desired value.
4099      * FIXME: Test VT_DECIMAL/VT_DISPATCH
4100      */
4101     VAROR(EMPTY,0,EMPTY,0,I2,0);
4102     VAROR(EMPTY,1,EMPTY,0,I2,0);
4103     VAROR(EMPTY,0,NULL,0,NULL,0);
4104     VAROR(EMPTY,0,I1,0,I4,0);
4105     VAROR(EMPTY,0,I1,1,I4,1);
4106     VAROR(EMPTY,0,UI1,0,I2,0);
4107     VAROR(EMPTY,0,UI1,1,I2,1);
4108     VAROR(EMPTY,0,I2,0,I2,0);
4109     VAROR(EMPTY,0,I2,1,I2,1);
4110     VAROR(EMPTY,0,UI2,0,I4,0);
4111     VAROR(EMPTY,0,UI2,1,I4,1);
4112     VAROR(EMPTY,0,I4,0,I4,0);
4113     VAROR(EMPTY,0,I4,1,I4,1);
4114     VAROR(EMPTY,0,UI4,0,I4,0);
4115     VAROR(EMPTY,0,UI4,1,I4,1);
4116     if (HAVE_OLEAUT32_I8)
4117     {
4118         VAROR(EMPTY,0,I8,0,I8,0);
4119         VAROR(EMPTY,0,I8,1,I8,1);
4120         VAROR(EMPTY,0,UI8,0,I4,0);
4121         VAROR(EMPTY,0,UI8,1,I4,1);
4122     }
4123     VAROR(EMPTY,0,INT,0,I4,0);
4124     VAROR(EMPTY,0,INT,1,I4,1);
4125     VAROR(EMPTY,0,UINT,0,I4,0);
4126     VAROR(EMPTY,0,UINT,1,I4,1);
4127     VAROR(EMPTY,0,BOOL,0,I2,0);
4128     VAROR(EMPTY,0,BOOL,1,I2,1);
4129     VAROR(EMPTY,0,R4,0,I4,0);
4130     VAROR(EMPTY,0,R4,1,I4,1);
4131     VAROR(EMPTY,0,R8,0,I4,0);
4132     VAROR(EMPTY,0,R8,1,I4,1);
4133     rbstr = SysAllocString(szFalse);
4134     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
4135     SysFreeString(rbstr);
4136     rbstr = SysAllocString(szTrue);
4137     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
4138     SysFreeString(rbstr);
4139     VARORCY(EMPTY,0,10000,I4,1);
4140
4141     /* NULL OR 0 = NULL. NULL OR n = n */
4142     VAROR(NULL,0,NULL,0,NULL,0);
4143     VAROR(NULL,1,NULL,0,NULL,0);
4144     VAROR(NULL,0,I1,0,NULL,0);
4145     VAROR(NULL,0,I1,1,I4,1);
4146     VAROR(NULL,0,UI1,0,NULL,0);
4147     VAROR(NULL,0,UI1,1,UI1,1);
4148     VAROR(NULL,0,I2,0,NULL,0);
4149     VAROR(NULL,0,I2,1,I2,1);
4150     VAROR(NULL,0,UI2,0,NULL,0);
4151     VAROR(NULL,0,UI2,1,I4,1);
4152     VAROR(NULL,0,I4,0,NULL,0);
4153     VAROR(NULL,0,I4,1,I4,1);
4154     VAROR(NULL,0,UI4,0,NULL,0);
4155     VAROR(NULL,0,UI4,1,I4,1);
4156     if (HAVE_OLEAUT32_I8)
4157     {
4158         VAROR(NULL,0,I8,0,NULL,0);
4159         VAROR(NULL,0,I8,1,I8,1);
4160         VAROR(NULL,0,UI8,0,NULL,0);
4161         VAROR(NULL,0,UI8,1,I4,1);
4162     }
4163     VAROR(NULL,0,INT,0,NULL,0);
4164     VAROR(NULL,0,INT,1,I4,1);
4165     VAROR(NULL,0,UINT,0,NULL,0);
4166     VAROR(NULL,0,UINT,1,I4,1);
4167     VAROR(NULL,0,BOOL,0,NULL,0);
4168     VAROR(NULL,0,BOOL,1,BOOL,1);
4169     VAROR(NULL,0,R4,0,NULL,0);
4170     VAROR(NULL,0,R4,1,I4,1);
4171     VAROR(NULL,0,R8,0,NULL,0);
4172     VAROR(NULL,0,R8,1,I4,1);
4173     rbstr = SysAllocString(szFalse);
4174     VAROR(NULL,0,BSTR,rbstr,NULL,0);
4175     SysFreeString(rbstr);
4176     rbstr = SysAllocString(szTrue);
4177     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
4178     SysFreeString(rbstr);
4179     VARORCY(NULL,0,10000,I4,1);
4180     VARORCY(NULL,0,0,NULL,0);
4181
4182     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4183     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4184     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4185     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4186     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4187     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
4188     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4189     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4190     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
4191     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4192     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4193     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
4194     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4195     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4196     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
4197     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4198     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4199     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
4200     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4201     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4202     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
4203     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4204     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4205     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
4206     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4207     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4208     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
4209     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4210     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4211     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
4212     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4213     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4214     if (HAVE_OLEAUT32_I8)
4215     {
4216         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
4217         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4218         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4219         /* This returns DISP_E_OVERFLOW which indicates that a conversion
4220          * to I4 is performed.
4221          */
4222         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4223         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4224         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4225     }
4226     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
4227     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4228     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4229     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
4230     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4231     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4232     rbstr = SysAllocString(szFalse);
4233     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4234     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4235     SysFreeString(rbstr);
4236     rbstr = SysAllocString(szTrue);
4237     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4238     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4239     SysFreeString(rbstr);
4240     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
4241     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4242     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
4243
4244     VAROR(I1,-1,I1,-1,I4,-1);
4245     VAROR(I1,-1,I1,0,I4,-1);
4246     VAROR(I1,0,I1,0,I4,0);
4247     VAROR(I1,-1,UI1,255,I4,-1);
4248     VAROR(I1,-1,UI1,0,I4,-1);
4249     VAROR(I1,0,UI1,0,I4,0);
4250     VAROR(I1,-1,I2,-1,I4,-1);
4251     VAROR(I1,-1,I2,0,I4,-1);
4252     VAROR(I1,0,I2,0,I4,0);
4253     VAROR(I1,-1,UI2,65535,I4,-1);
4254     VAROR(I1,-1,UI2,0,I4,-1);
4255     VAROR(I1,0,UI2,0,I4,0);
4256     VAROR(I1,-1,I4,-1,I4,-1);
4257     VAROR(I1,-1,I4,0,I4,-1);
4258     VAROR(I1,0,I4,0,I4,0);
4259     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
4260     VAROR(I1,-1,UI4,0,I4,-1);
4261     VAROR(I1,0,UI4,0,I4,0);
4262     VAROR(I1,-1,R4,-1,I4,-1);
4263     VAROR(I1,-1,R4,0,I4,-1);
4264     VAROR(I1,0,R4,0,I4,0);
4265     VAROR(I1,-1,R8,-1,I4,-1);
4266     VAROR(I1,-1,R8,0,I4,-1);
4267     VAROR(I1,0,R8,0,I4,0);
4268     VAROR(I1,-1,DATE,-1,I4,-1);
4269     VAROR(I1,-1,DATE,0,I4,-1);
4270     VAROR(I1,0,DATE,0,I4,0);
4271     if (HAVE_OLEAUT32_I8)
4272     {
4273         VAROR(I1,-1,I8,-1,I8,-1);
4274         VAROR(I1,-1,I8,0,I8,-1);
4275         VAROR(I1,0,I8,0,I8,0);
4276         VAROR(I1,-1,UI8,0,I4,-1);
4277         VAROR(I1,0,UI8,0,I4,0);
4278     }
4279     VAROR(I1,-1,INT,-1,I4,-1);
4280     VAROR(I1,-1,INT,0,I4,-1);
4281     VAROR(I1,0,INT,0,I4,0);
4282     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
4283     VAROR(I1,-1,UINT,0,I4,-1);
4284     VAROR(I1,0,UINT,0,I4,0);
4285     rbstr = SysAllocString(szFalse);
4286     VAROR(I1,0,BSTR,rbstr,I4,0);
4287     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4288     SysFreeString(rbstr);
4289     rbstr = SysAllocString(szTrue);
4290     VAROR(I1,0,BSTR,rbstr,I4,-1);
4291     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4292     SysFreeString(rbstr);
4293     VARORCY(I1,-1,10000,I4,-1);
4294     VARORCY(I1,-1,0,I4,-1);
4295     VARORCY(I1,0,0,I4,0);
4296
4297     VAROR(UI1,255,UI1,255,UI1,255);
4298     VAROR(UI1,255,UI1,0,UI1,255);
4299     VAROR(UI1,0,UI1,0,UI1,0);
4300     VAROR(UI1,255,I2,-1,I2,-1);
4301     VAROR(UI1,255,I2,0,I2,255);
4302     VAROR(UI1,0,I2,0,I2,0);
4303     VAROR(UI1,255,UI2,65535,I4,65535);
4304     VAROR(UI1,255,UI2,0,I4,255);
4305     VAROR(UI1,0,UI2,0,I4,0);
4306     VAROR(UI1,255,I4,-1,I4,-1);
4307     VAROR(UI1,255,I4,0,I4,255);
4308     VAROR(UI1,0,I4,0,I4,0);
4309     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4310     VAROR(UI1,255,UI4,0,I4,255);
4311     VAROR(UI1,0,UI4,0,I4,0);
4312     VAROR(UI1,255,R4,-1,I4,-1);
4313     VAROR(UI1,255,R4,0,I4,255);
4314     VAROR(UI1,0,R4,0,I4,0);
4315     VAROR(UI1,255,R8,-1,I4,-1);
4316     VAROR(UI1,255,R8,0,I4,255);
4317     VAROR(UI1,0,R8,0,I4,0);
4318     VAROR(UI1,255,DATE,-1,I4,-1);
4319     VAROR(UI1,255,DATE,0,I4,255);
4320     VAROR(UI1,0,DATE,0,I4,0);
4321     if (HAVE_OLEAUT32_I8)
4322     {
4323         VAROR(UI1,255,I8,-1,I8,-1);
4324         VAROR(UI1,255,I8,0,I8,255);
4325         VAROR(UI1,0,I8,0,I8,0);
4326         VAROR(UI1,255,UI8,0,I4,255);
4327         VAROR(UI1,0,UI8,0,I4,0);
4328     }
4329     VAROR(UI1,255,INT,-1,I4,-1);
4330     VAROR(UI1,255,INT,0,I4,255);
4331     VAROR(UI1,0,INT,0,I4,0);
4332     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4333     VAROR(UI1,255,UINT,0,I4,255);
4334     VAROR(UI1,0,UINT,0,I4,0);
4335     rbstr = SysAllocString(szFalse);
4336     VAROR(UI1,0,BSTR,rbstr,I2,0);
4337     VAROR(UI1,255,BSTR,rbstr,I2,255);
4338     SysFreeString(rbstr);
4339     rbstr = SysAllocString(szTrue);
4340     VAROR(UI1,0,BSTR,rbstr,I2,-1);
4341     VAROR(UI1,255,BSTR,rbstr,I2,-1);
4342     SysFreeString(rbstr);
4343     VARORCY(UI1,255,10000,I4,255);
4344     VARORCY(UI1,255,0,I4,255);
4345     VARORCY(UI1,0,0,I4,0);
4346
4347     VAROR(I2,-1,I2,-1,I2,-1);
4348     VAROR(I2,-1,I2,0,I2,-1);
4349     VAROR(I2,0,I2,0,I2,0);
4350     VAROR(I2,-1,UI2,65535,I4,-1);
4351     VAROR(I2,-1,UI2,0,I4,-1);
4352     VAROR(I2,0,UI2,0,I4,0);
4353     VAROR(I2,-1,I4,-1,I4,-1);
4354     VAROR(I2,-1,I4,0,I4,-1);
4355     VAROR(I2,0,I4,0,I4,0);
4356     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4357     VAROR(I2,-1,UI4,0,I4,-1);
4358     VAROR(I2,0,UI4,0,I4,0);
4359     VAROR(I2,-1,R4,-1,I4,-1);
4360     VAROR(I2,-1,R4,0,I4,-1);
4361     VAROR(I2,0,R4,0,I4,0);
4362     VAROR(I2,-1,R8,-1,I4,-1);
4363     VAROR(I2,-1,R8,0,I4,-1);
4364     VAROR(I2,0,R8,0,I4,0);
4365     VAROR(I2,-1,DATE,-1,I4,-1);
4366     VAROR(I2,-1,DATE,0,I4,-1);
4367     VAROR(I2,0,DATE,0,I4,0);
4368     if (HAVE_OLEAUT32_I8)
4369     {
4370         VAROR(I2,-1,I8,-1,I8,-1);
4371         VAROR(I2,-1,I8,0,I8,-1);
4372         VAROR(I2,0,I8,0,I8,0);
4373         VAROR(I2,-1,UI8,0,I4,-1);
4374         VAROR(I2,0,UI8,0,I4,0);
4375     }
4376     VAROR(I2,-1,INT,-1,I4,-1);
4377     VAROR(I2,-1,INT,0,I4,-1);
4378     VAROR(I2,0,INT,0,I4,0);
4379     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4380     VAROR(I2,-1,UINT,0,I4,-1);
4381     VAROR(I2,0,UINT,0,I4,0);
4382     rbstr = SysAllocString(szFalse);
4383     VAROR(I2,0,BSTR,rbstr,I2,0);
4384     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4385     SysFreeString(rbstr);
4386     rbstr = SysAllocString(szTrue);
4387     VAROR(I2,0,BSTR,rbstr,I2,-1);
4388     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4389     SysFreeString(rbstr);
4390     VARORCY(I2,-1,10000,I4,-1);
4391     VARORCY(I2,-1,0,I4,-1);
4392     VARORCY(I2,0,0,I4,0);
4393
4394     VAROR(UI2,65535,UI2,65535,I4,65535);
4395     VAROR(UI2,65535,UI2,0,I4,65535);
4396     VAROR(UI2,0,UI2,0,I4,0);
4397     VAROR(UI2,65535,I4,-1,I4,-1);
4398     VAROR(UI2,65535,I4,0,I4,65535);
4399     VAROR(UI2,0,I4,0,I4,0);
4400     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4401     VAROR(UI2,65535,UI4,0,I4,65535);
4402     VAROR(UI2,0,UI4,0,I4,0);
4403     VAROR(UI2,65535,R4,-1,I4,-1);
4404     VAROR(UI2,65535,R4,0,I4,65535);
4405     VAROR(UI2,0,R4,0,I4,0);
4406     VAROR(UI2,65535,R8,-1,I4,-1);
4407     VAROR(UI2,65535,R8,0,I4,65535);
4408     VAROR(UI2,0,R8,0,I4,0);
4409     VAROR(UI2,65535,DATE,-1,I4,-1);
4410     VAROR(UI2,65535,DATE,0,I4,65535);
4411     VAROR(UI2,0,DATE,0,I4,0);
4412     if (HAVE_OLEAUT32_I8)
4413     {
4414         VAROR(UI2,65535,I8,-1,I8,-1);
4415         VAROR(UI2,65535,I8,0,I8,65535);
4416         VAROR(UI2,0,I8,0,I8,0);
4417         VAROR(UI2,65535,UI8,0,I4,65535);
4418         VAROR(UI2,0,UI8,0,I4,0);
4419     }
4420     VAROR(UI2,65535,INT,-1,I4,-1);
4421     VAROR(UI2,65535,INT,0,I4,65535);
4422     VAROR(UI2,0,INT,0,I4,0);
4423     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4424     VAROR(UI2,65535,UINT,0,I4,65535);
4425     VAROR(UI2,0,UINT,0,I4,0);
4426     rbstr = SysAllocString(szFalse);
4427     VAROR(UI2,0,BSTR,rbstr,I4,0);
4428     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4429     SysFreeString(rbstr);
4430     rbstr = SysAllocString(szTrue);
4431     VAROR(UI2,0,BSTR,rbstr,I4,-1);
4432     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4433     SysFreeString(rbstr);
4434     VARORCY(UI2,65535,10000,I4,65535);
4435     VARORCY(UI2,65535,0,I4,65535);
4436     VARORCY(UI2,0,0,I4,0);
4437
4438     VAROR(I4,-1,I4,-1,I4,-1);
4439     VAROR(I4,-1,I4,0,I4,-1);
4440     VAROR(I4,0,I4,0,I4,0);
4441     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4442     VAROR(I4,-1,UI4,0,I4,-1);
4443     VAROR(I4,0,UI4,0,I4,0);
4444     VAROR(I4,-1,R4,-1,I4,-1);
4445     VAROR(I4,-1,R4,0,I4,-1);
4446     VAROR(I4,0,R4,0,I4,0);
4447     VAROR(I4,-1,R8,-1,I4,-1);
4448     VAROR(I4,-1,R8,0,I4,-1);
4449     VAROR(I4,0,R8,0,I4,0);
4450     VAROR(I4,-1,DATE,-1,I4,-1);
4451     VAROR(I4,-1,DATE,0,I4,-1);
4452     VAROR(I4,0,DATE,0,I4,0);
4453     if (HAVE_OLEAUT32_I8)
4454     {
4455         VAROR(I4,-1,I8,-1,I8,-1);
4456         VAROR(I4,-1,I8,0,I8,-1);
4457         VAROR(I4,0,I8,0,I8,0);
4458         VAROR(I4,-1,UI8,0,I4,-1);
4459         VAROR(I4,0,UI8,0,I4,0);
4460     }
4461     VAROR(I4,-1,INT,-1,I4,-1);
4462     VAROR(I4,-1,INT,0,I4,-1);
4463     VAROR(I4,0,INT,0,I4,0);
4464     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4465     VAROR(I4,-1,UINT,0,I4,-1);
4466     VAROR(I4,0,UINT,0,I4,0);
4467     rbstr = SysAllocString(szFalse);
4468     VAROR(I4,0,BSTR,rbstr,I4,0);
4469     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4470     SysFreeString(rbstr);
4471     rbstr = SysAllocString(szTrue);
4472     VAROR(I4,0,BSTR,rbstr,I4,-1);
4473     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4474     SysFreeString(rbstr);
4475     VARORCY(I4,-1,10000,I4,-1);
4476     VARORCY(I4,-1,0,I4,-1);
4477     VARORCY(I4,0,0,I4,0);
4478
4479     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4480     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4481     VAROR(UI4,0,UI4,0,I4,0);
4482     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4483     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4484     VAROR(UI4,0,R4,0,I4,0);
4485     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4486     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4487     VAROR(UI4,0,R8,0,I4,0);
4488     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4489     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4490     VAROR(UI4,0,DATE,0,I4,0);
4491     if (HAVE_OLEAUT32_I8)
4492     {
4493         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4494         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4495         VAROR(UI4,0,I8,0,I8,0);
4496         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4497         VAROR(UI4,0,UI8,0,I4,0);
4498     }
4499     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4500     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4501     VAROR(UI4,0,INT,0,I4,0);
4502     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4503     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4504     VAROR(UI4,0,UINT,0,I4,0);
4505     rbstr = SysAllocString(szFalse);
4506     VAROR(UI4,0,BSTR,rbstr,I4,0);
4507     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4508     SysFreeString(rbstr);
4509     rbstr = SysAllocString(szTrue);
4510     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4511     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4512     SysFreeString(rbstr);
4513     VARORCY(UI4,0xffffffff,10000,I4,-1);
4514     VARORCY(UI4,0xffffffff,0,I4,-1);
4515     VARORCY(UI4,0,0,I4,0);
4516
4517     VAROR(R4,-1,R4,-1,I4,-1);
4518     VAROR(R4,-1,R4,0,I4,-1);
4519     VAROR(R4,0,R4,0,I4,0);
4520     VAROR(R4,-1,R8,-1,I4,-1);
4521     VAROR(R4,-1,R8,0,I4,-1);
4522     VAROR(R4,0,R8,0,I4,0);
4523     VAROR(R4,-1,DATE,-1,I4,-1);
4524     VAROR(R4,-1,DATE,0,I4,-1);
4525     VAROR(R4,0,DATE,0,I4,0);
4526     if (HAVE_OLEAUT32_I8)
4527     {
4528         VAROR(R4,-1,I8,-1,I8,-1);
4529         VAROR(R4,-1,I8,0,I8,-1);
4530         VAROR(R4,0,I8,0,I8,0);
4531         VAROR(R4,-1,UI8,0,I4,-1);
4532         VAROR(R4,0,UI8,0,I4,0);
4533     }
4534     VAROR(R4,-1,INT,-1,I4,-1);
4535     VAROR(R4,-1,INT,0,I4,-1);
4536     VAROR(R4,0,INT,0,I4,0);
4537     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4538     VAROR(R4,-1,UINT,0,I4,-1);
4539     VAROR(R4,0,UINT,0,I4,0);
4540     rbstr = SysAllocString(szFalse);
4541     VAROR(R4,0,BSTR,rbstr,I4,0);
4542     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4543     SysFreeString(rbstr);
4544     rbstr = SysAllocString(szTrue);
4545     VAROR(R4,0,BSTR,rbstr,I4,-1);
4546     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4547     SysFreeString(rbstr);
4548     VARORCY(R4,-1,10000,I4,-1);
4549     VARORCY(R4,-1,0,I4,-1);
4550     VARORCY(R4,0,0,I4,0);
4551
4552     VAROR(R8,-1,R8,-1,I4,-1);
4553     VAROR(R8,-1,R8,0,I4,-1);
4554     VAROR(R8,0,R8,0,I4,0);
4555     VAROR(R8,-1,DATE,-1,I4,-1);
4556     VAROR(R8,-1,DATE,0,I4,-1);
4557     VAROR(R8,0,DATE,0,I4,0);
4558     if (HAVE_OLEAUT32_I8)
4559     {
4560         VAROR(R8,-1,I8,-1,I8,-1);
4561         VAROR(R8,-1,I8,0,I8,-1);
4562         VAROR(R8,0,I8,0,I8,0);
4563         VAROR(R8,-1,UI8,0,I4,-1);
4564         VAROR(R8,0,UI8,0,I4,0);
4565     }
4566     VAROR(R8,-1,INT,-1,I4,-1);
4567     VAROR(R8,-1,INT,0,I4,-1);
4568     VAROR(R8,0,INT,0,I4,0);
4569     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4570     VAROR(R8,-1,UINT,0,I4,-1);
4571     VAROR(R8,0,UINT,0,I4,0);
4572     rbstr = SysAllocString(szFalse);
4573     VAROR(R8,0,BSTR,rbstr,I4,0);
4574     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4575     SysFreeString(rbstr);
4576     rbstr = SysAllocString(szTrue);
4577     VAROR(R8,0,BSTR,rbstr,I4,-1);
4578     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4579     SysFreeString(rbstr);
4580     VARORCY(R8,-1,10000,I4,-1);
4581     VARORCY(R8,-1,0,I4,-1);
4582     VARORCY(R8,0,0,I4,0);
4583
4584     VAROR(DATE,-1,DATE,-1,I4,-1);
4585     VAROR(DATE,-1,DATE,0,I4,-1);
4586     VAROR(DATE,0,DATE,0,I4,0);
4587     if (HAVE_OLEAUT32_I8)
4588     {
4589         VAROR(DATE,-1,I8,-1,I8,-1);
4590         VAROR(DATE,-1,I8,0,I8,-1);
4591         VAROR(DATE,0,I8,0,I8,0);
4592         VAROR(DATE,-1,UI8,0,I4,-1);
4593         VAROR(DATE,0,UI8,0,I4,0);
4594     }
4595     VAROR(DATE,-1,INT,-1,I4,-1);
4596     VAROR(DATE,-1,INT,0,I4,-1);
4597     VAROR(DATE,0,INT,0,I4,0);
4598     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4599     VAROR(DATE,-1,UINT,0,I4,-1);
4600     VAROR(DATE,0,UINT,0,I4,0);
4601     rbstr = SysAllocString(szFalse);
4602     VAROR(DATE,0,BSTR,rbstr,I4,0);
4603     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4604     SysFreeString(rbstr);
4605     rbstr = SysAllocString(szTrue);
4606     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4607     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4608     SysFreeString(rbstr);
4609     VARORCY(DATE,-1,10000,I4,-1);
4610     VARORCY(DATE,-1,0,I4,-1);
4611     VARORCY(DATE,0,0,I4,0);
4612
4613     if (HAVE_OLEAUT32_I8)
4614     {
4615         VAROR(I8,-1,I8,-1,I8,-1);
4616         VAROR(I8,-1,I8,0,I8,-1);
4617         VAROR(I8,0,I8,0,I8,0);
4618         VAROR(I8,-1,UI8,0,I8,-1);
4619         VAROR(I8,0,UI8,0,I8,0);
4620         /* These overflow under native and Wine
4621         VAROR(I8,-1,INT,-1,I4,-1);
4622         VAROR(I8,-1,INT,0,I4,-1);
4623         VAROR(I8,0,INT,0,I4,0); */
4624         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4625         VAROR(I8,-1,UINT,0,I8,-1);
4626         VAROR(I8,0,UINT,0,I8,0);
4627         rbstr = SysAllocString(szFalse);
4628         VAROR(I8,0,BSTR,rbstr,I8,0);
4629         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4630         SysFreeString(rbstr);
4631         rbstr = SysAllocString(szTrue);
4632         VAROR(I8,0,BSTR,rbstr,I8,-1);
4633         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4634         SysFreeString(rbstr);
4635         VARORCY(I8,-1,10000,I8,-1);
4636         VARORCY(I8,-1,0,I8,-1);
4637         VARORCY(I8,0,0,I8,0);
4638
4639         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4640         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4641         VAROR(UI8,0,UI8,0,I4,0);
4642         VAROR(UI8,0xffff,INT,-1,I4,-1);
4643         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4644         VAROR(UI8,0,INT,0,I4,0);
4645         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4646         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4647         VAROR(UI8,0,UINT,0,I4,0);
4648         rbstr = SysAllocString(szFalse);
4649         VAROR(UI8,0,BSTR,rbstr,I4,0);
4650         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4651         SysFreeString(rbstr);
4652         rbstr = SysAllocString(szTrue);
4653         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4654         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4655         SysFreeString(rbstr);
4656         VARORCY(UI8,0xffff,10000,I4,0xffff);
4657         VARORCY(UI8,0xffff,0,I4,0xffff);
4658         VARORCY(UI8,0,0,I4,0);
4659     }
4660
4661     VAROR(INT,-1,INT,-1,I4,-1);
4662     VAROR(INT,-1,INT,0,I4,-1);
4663     VAROR(INT,0,INT,0,I4,0);
4664     VAROR(INT,-1,UINT,0xffff,I4,-1);
4665     VAROR(INT,-1,UINT,0,I4,-1);
4666     VAROR(INT,0,UINT,0,I4,0);
4667     rbstr = SysAllocString(szFalse);
4668     VAROR(INT,0,BSTR,rbstr,I4,0);
4669     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4670     SysFreeString(rbstr);
4671     rbstr = SysAllocString(szTrue);
4672     VAROR(INT,0,BSTR,rbstr,I4,-1);
4673     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4674     SysFreeString(rbstr);
4675     VARORCY(INT,-1,10000,I4,-1);
4676     VARORCY(INT,-1,0,I4,-1);
4677     VARORCY(INT,0,0,I4,0);
4678
4679     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4680     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4681     VAROR(UINT,0,UINT,0,I4,0);
4682     rbstr = SysAllocString(szFalse);
4683     VAROR(UINT,0,BSTR,rbstr,I4,0);
4684     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4685     SysFreeString(rbstr);
4686     rbstr = SysAllocString(szTrue);
4687     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4688     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4689     SysFreeString(rbstr);
4690     VARORCY(UINT,0xffff,10000,I4,0xffff);
4691     VARORCY(UINT,0xffff,0,I4,0xffff);
4692     VARORCY(UINT,0,0,I4,0);
4693
4694     lbstr = SysAllocString(szFalse);
4695     rbstr = SysAllocString(szFalse);
4696     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4697     SysFreeString(rbstr);
4698     rbstr = SysAllocString(szTrue);
4699     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4700     SysFreeString(lbstr);
4701     lbstr = SysAllocString(szTrue);
4702     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4703     VARORCY(BSTR,lbstr,10000,I4,-1);
4704     SysFreeString(lbstr);
4705     lbstr = SysAllocString(szFalse);
4706     VARORCY(BSTR,lbstr,10000,I4,1);
4707     SysFreeString(lbstr);
4708     SysFreeString(rbstr);
4709 }
4710
4711 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4712
4713 #define VAREQV(vt1,val1,vt2,val2,rvt,rval)           \
4714     V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4715     V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4716     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4717     test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )
4718
4719 static void test_VarEqv(void)
4720 {
4721     VARIANT left, right, exp, result;
4722     VARTYPE i;
4723     HRESULT hres;
4724
4725     CHECKPTR(VarEqv);
4726
4727     /* Test all possible flag/vt combinations & the resulting vt type */
4728     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4729     {
4730         VARTYPE leftvt, rightvt, resvt;
4731
4732         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4733         {
4734             SKIPTESTS(leftvt);
4735
4736             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4737             {
4738                 BOOL bFail = FALSE;
4739
4740                 SKIPTESTS(rightvt);
4741
4742                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4743                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4744                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4745                     continue;
4746
4747                 memset(&left, 0, sizeof(left));
4748                 memset(&right, 0, sizeof(right));
4749                 V_VT(&left) = leftvt | ExtraFlags[i];
4750                 V_VT(&right) = rightvt | ExtraFlags[i];
4751                 V_VT(&result) = VT_EMPTY;
4752                 resvt = VT_I4;
4753
4754                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4755                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4756                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4757                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4758                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4759                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4760                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4761                 {
4762                     bFail = TRUE;
4763                 }
4764                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4765                 {
4766                     if (leftvt == rightvt ||
4767                         leftvt == VT_I2 || rightvt == VT_I2 ||
4768                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4769                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4770                         resvt = VT_I2;
4771                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4772                         resvt = VT_NULL;
4773                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4774                         resvt = VT_I8;
4775                 }
4776                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4777                 {
4778                     resvt = VT_NULL;
4779                 }
4780                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4781                 {
4782                     if (leftvt == rightvt)
4783                         resvt = VT_UI1;
4784                     else if (leftvt == rightvt ||
4785                         leftvt == VT_I2 || rightvt == VT_I2 ||
4786                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4787                     {
4788                         resvt = VT_I2;
4789                     }
4790                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4791                         resvt = VT_I8;
4792                 }
4793                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4794                 {
4795                     if (leftvt == rightvt ||
4796                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4797                         resvt = VT_I2;
4798                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4799                         resvt = VT_I8;
4800                 }
4801                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4802                 {
4803                     resvt = VT_BOOL;
4804                 }
4805                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4806                 {
4807                     if (leftvt == VT_INT || rightvt == VT_INT)
4808                         bFail = TRUE;
4809                     else
4810                         resvt = VT_I8;
4811                 }
4812                 hres = pVarEqv(&left, &right, &result);
4813                 if (bFail)
4814                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4815                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4816                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4817                        V_VT(&result));
4818                 else
4819                     ok(hres == S_OK && V_VT(&result) == resvt,
4820                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4821                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4822                        V_VT(&result));
4823             }
4824         }
4825     }
4826
4827     /* Test returned values */
4828     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4829     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4830     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4831     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4832     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4833     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4834     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4835     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4836     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4837     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4838     VAREQV(BOOL,6,I2,7,I2,-2);
4839     VAREQV(UI1,1,UI1,1,UI1,255);
4840     VAREQV(UI1,1,UI1,0,UI1,254);
4841     VAREQV(UI1,0,UI1,1,UI1,254);
4842     if (HAVE_OLEAUT32_I8)
4843     {
4844         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4845         VAREQV(UI4,5,I8,19,I8,-23);
4846         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4847     }
4848 }
4849
4850 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4851
4852 #define VARMUL(vt1,val1,vt2,val2,rvt,rval)               \
4853         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4854         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4855         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4856         test_var_call2( __LINE__, pVarMul, &left, &right, &exp )
4857
4858 static void test_VarMul(void)
4859 {
4860     static const WCHAR sz12[] = {'1','2','\0'};
4861     VARIANT left, right, exp, result, cy, dec;
4862     VARTYPE i;
4863     BSTR lbstr, rbstr;
4864     HRESULT hres;
4865     double r;
4866
4867     CHECKPTR(VarMul);
4868
4869     lbstr = SysAllocString(sz12);
4870     rbstr = SysAllocString(sz12);
4871
4872     /* Test all possible flag/vt combinations & the resulting vt type */
4873     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4874     {
4875         VARTYPE leftvt, rightvt, resvt;
4876
4877         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4878         {
4879
4880             SKIPTESTS(leftvt);
4881
4882             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4883             {
4884                 BOOL bFail = FALSE;
4885
4886                 SKIPTESTS(rightvt);
4887
4888                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4889                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4890                     continue;
4891
4892                 memset(&left, 0, sizeof(left));
4893                 memset(&right, 0, sizeof(right));
4894                 V_VT(&left) = leftvt | ExtraFlags[i];
4895                 if (leftvt == VT_BSTR)
4896                     V_BSTR(&left) = lbstr;
4897                 V_VT(&right) = rightvt | ExtraFlags[i];
4898                 if (rightvt == VT_BSTR)
4899                     V_BSTR(&right) = rbstr;
4900                 V_VT(&result) = VT_EMPTY;
4901                 resvt = VT_UNKNOWN;
4902
4903                 /* Don't ask me why but native VarMul cannot handle:
4904                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
4905                    Tested with DCOM98, Win2k, WinXP */
4906                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4907                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4908                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4909                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4910                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4911                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4912                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
4913                     leftvt == VT_I1 || rightvt == VT_I1 ||
4914                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
4915                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
4916                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
4917                     leftvt == VT_INT || rightvt == VT_INT ||
4918                     leftvt == VT_UINT || rightvt == VT_UINT) {
4919                     bFail = TRUE;
4920                 }
4921
4922                 if (leftvt == VT_NULL || rightvt == VT_NULL)
4923                     resvt = VT_NULL;
4924                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
4925                     resvt = VT_DECIMAL;
4926                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
4927                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
4928                          leftvt == VT_DATE || rightvt == VT_DATE)
4929                     resvt = VT_R8;
4930                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
4931                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
4932                         leftvt == VT_I8 || rightvt == VT_I8 ||
4933                         leftvt == VT_CY || rightvt == VT_CY)
4934                         resvt = VT_R8;
4935                     else
4936                         resvt = VT_R4;
4937                 } else if (leftvt == VT_CY || rightvt == VT_CY)
4938                     resvt = VT_CY;
4939                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4940                     resvt = VT_I8;
4941                 else if (leftvt == VT_I4 || rightvt == VT_I4)
4942                     resvt = VT_I4;
4943                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
4944                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
4945                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
4946                     resvt = VT_I2;
4947                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4948                     resvt = VT_UI1;
4949
4950                 hres = pVarMul(&left, &right, &result);
4951                 if (bFail) {
4952                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4953                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4954                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4955                        V_VT(&result));
4956                 } else {
4957                     ok(hres == S_OK && V_VT(&result) == resvt,
4958                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4959                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4960                        V_VT(&result));
4961                 }
4962             }
4963         }
4964     }
4965
4966     /* Test returned values */
4967     VARMUL(I4,4,I4,2,I4,8);
4968     VARMUL(I2,4,I2,2,I2,8);
4969     VARMUL(I2,-13,I4,5,I4,-65);
4970     VARMUL(I4,-13,I4,5,I4,-65);
4971     VARMUL(I2,7,R4,0.5f,R4,3.5f);
4972     VARMUL(R4,0.5f,I4,5,R8,2.5);
4973     VARMUL(R8,7.1,BOOL,0,R8,0);
4974     VARMUL(BSTR,lbstr,I2,4,R8,48);
4975     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
4976     VARMUL(BSTR,lbstr,R4,0.1f,R8,1.2);
4977     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
4978     VARMUL(R4,0.2f,BSTR,rbstr,R8,2.4);
4979     VARMUL(DATE,2.25,I4,7,R8,15.75);
4980
4981     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
4982     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
4983     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
4984     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
4985     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
4986     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
4987     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
4988     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
4989     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
4990     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
4991     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
4992     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
4993
4994     /* Manuly test some VT_CY and VT_DECIMAL variants */
4995     V_VT(&cy) = VT_CY;
4996     hres = VarCyFromI4(4711, &V_CY(&cy));
4997     ok(hres == S_OK, "VarCyFromI4 failed!\n");
4998     V_VT(&dec) = VT_DECIMAL;
4999     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5000     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5001     memset(&left, 0, sizeof(left));
5002     memset(&right, 0, sizeof(right));
5003     V_VT(&left) = VT_I4;
5004     V_I4(&left) = -11;
5005     V_VT(&right) = VT_UI1;
5006     V_UI1(&right) = 9;
5007
5008     hres = VarMul(&cy, &right, &result);
5009     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5010     hres = VarR8FromCy(V_CY(&result), &r);
5011     ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
5012
5013     hres = VarMul(&left, &dec, &result);
5014     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5015     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5016     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
5017
5018     SysFreeString(lbstr);
5019     SysFreeString(rbstr);
5020 }
5021
5022 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
5023
5024 #define VARADD(vt1,val1,vt2,val2,rvt,rval)               \
5025         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5026         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5027         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5028         test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )
5029
5030 static void test_VarAdd(void)
5031 {
5032     static const WCHAR sz12[] = {'1','2','\0'};
5033     VARIANT left, right, exp, result, cy, dec;
5034     VARTYPE i;
5035     BSTR lbstr, rbstr;
5036     HRESULT hres;
5037     double r;
5038
5039     CHECKPTR(VarAdd);
5040
5041     lbstr = SysAllocString(sz12);
5042     rbstr = SysAllocString(sz12);
5043
5044     /* Test all possible flag/vt combinations & the resulting vt type */
5045     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5046     {
5047         VARTYPE leftvt, rightvt, resvt;
5048
5049         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5050         {
5051
5052             SKIPTESTS(leftvt);
5053
5054             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5055             {
5056                 BOOL bFail = FALSE;
5057
5058                 SKIPTESTS(rightvt);
5059
5060                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5061                     continue;
5062
5063                 memset(&left, 0, sizeof(left));
5064                 memset(&right, 0, sizeof(right));
5065                 V_VT(&left) = leftvt | ExtraFlags[i];
5066                 if (leftvt == VT_BSTR)
5067                     V_BSTR(&left) = lbstr;
5068                 V_VT(&right) = rightvt | ExtraFlags[i];
5069                 if (rightvt == VT_BSTR)
5070                     V_BSTR(&right) = rbstr;
5071                 V_VT(&result) = VT_EMPTY;
5072                 resvt = VT_ERROR;
5073
5074                 /* Don't ask me why but native VarAdd cannot handle:
5075                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5076                    Tested with DCOM98, Win2k, WinXP */
5077                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5078                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5079                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5080                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5081                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5082                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5083                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5084                     leftvt == VT_I1 || rightvt == VT_I1 ||
5085                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5086                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5087                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5088                     leftvt == VT_INT || rightvt == VT_INT ||
5089                     leftvt == VT_UINT || rightvt == VT_UINT) {
5090                     bFail = TRUE;
5091                 }
5092
5093                 if (leftvt == VT_NULL || rightvt == VT_NULL)
5094                     resvt = VT_NULL;
5095                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
5096                     bFail = TRUE;
5097                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5098                     resvt = VT_DECIMAL;
5099                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
5100                     resvt = VT_DATE;
5101                 else if (leftvt == VT_CY || rightvt == VT_CY)
5102                     resvt = VT_CY;
5103                 else if (leftvt == VT_R8 || rightvt == VT_R8)
5104                     resvt = VT_R8;
5105                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
5106                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
5107                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5108                         resvt = VT_BSTR;
5109                     else
5110                         resvt = VT_R8;
5111                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
5112                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
5113                         leftvt == VT_I8 || rightvt == VT_I8)
5114                         resvt = VT_R8;
5115                     else
5116                         resvt = VT_R4;
5117                 }
5118                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5119                     resvt = VT_I8;
5120                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5121                     resvt = VT_I4;
5122                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5123                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5124                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5125                     resvt = VT_I2;
5126                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5127                     resvt = VT_UI1;
5128
5129                 hres = pVarAdd(&left, &right, &result);
5130                 if (bFail) {
5131                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5132                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5133                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5134                        V_VT(&result));
5135                 } else {
5136                     ok(hres == S_OK && V_VT(&result) == resvt,
5137                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5138                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5139                        V_VT(&result));
5140                 }
5141                 /* Note, we don't clear left/right deliberately here */
5142                 VariantClear(&result);
5143             }
5144         }
5145     }
5146
5147     /* Test returned values */
5148     VARADD(I4,4,I4,2,I4,6);
5149     VARADD(I2,4,I2,2,I2,6);
5150     VARADD(I2,-13,I4,5,I4,-8);
5151     VARADD(I4,-13,I4,5,I4,-8);
5152     VARADD(I2,7,R4,0.5f,R4,7.5f);
5153     VARADD(R4,0.5f,I4,5,R8,5.5);
5154     VARADD(R8,7.1,BOOL,0,R8,7.1);
5155     VARADD(BSTR,lbstr,I2,4,R8,16);
5156     VARADD(BSTR,lbstr,BOOL,1,R8,13);
5157     VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
5158     VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
5159     VARADD(DATE,2.25,I4,7,DATE,9.25);
5160     VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
5161
5162     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
5163     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
5164     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
5165     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
5166     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
5167     VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
5168     VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
5169     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
5170     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
5171     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
5172     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
5173     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
5174
5175     /* Manually test BSTR + BSTR */
5176     V_VT(&left) = VT_BSTR;
5177     V_BSTR(&left) = lbstr;
5178     V_VT(&right) = VT_BSTR;
5179     V_BSTR(&right) = rbstr;
5180     hres = VarAdd(&left, &right, &result);
5181     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
5182     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
5183     ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
5184     VariantClear(&result);
5185
5186     /* Manuly test some VT_CY and VT_DECIMAL variants */
5187     V_VT(&cy) = VT_CY;
5188     hres = VarCyFromI4(4711, &V_CY(&cy));
5189     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5190     V_VT(&dec) = VT_DECIMAL;
5191     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5192     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5193     memset(&left, 0, sizeof(left));
5194     memset(&right, 0, sizeof(right));
5195     V_VT(&left) = VT_I4;
5196     V_I4(&left) = -11;
5197     V_VT(&right) = VT_UI1;
5198     V_UI1(&right) = 9;
5199
5200     hres = VarAdd(&cy, &right, &result);
5201     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5202     hres = VarR8FromCy(V_CY(&result), &r);
5203     ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
5204
5205     hres = VarAdd(&left, &dec, &result);
5206     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5207     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5208     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
5209     VariantClear(&result);
5210
5211     SysFreeString(lbstr);
5212     SysFreeString(rbstr);
5213 }
5214
5215 static void test_VarCat(void)
5216 {
5217     LCID lcid;
5218     VARIANT left, right, result, expected;
5219     static const WCHAR sz12[] = {'1','2','\0'};
5220     static const WCHAR sz34[] = {'3','4','\0'};
5221     static const WCHAR sz1234[] = {'1','2','3','4','\0'};
5222     static const WCHAR date_sz12[] = {'9','/','3','0','/','1','9','8','0','1','2','\0'};
5223     static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
5224     static const WCHAR sz_empty[] = {'\0'};
5225     static const WCHAR sz12_true[] = {'1','2','T','r','u','e','\0'};
5226     static const WCHAR sz12_false[] = {'1','2','F','a','l','s','e','\0'};
5227     TCHAR orig_date_format[128];
5228     VARTYPE leftvt, rightvt, resultvt;
5229     HRESULT hres;
5230     HRESULT expected_error_num;
5231
5232     /* Set date format for testing */
5233     lcid = LOCALE_USER_DEFAULT;
5234     GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
5235     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
5236
5237     VariantInit(&left);
5238     VariantInit(&right);
5239     VariantInit(&result);
5240     VariantInit(&expected);
5241
5242     /* Check expected types for all combinations */
5243     for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5244     {
5245
5246         SKIPTESTS(leftvt);
5247
5248         /* Check if we need/have support for I8 and/or UI8 */
5249         if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5250             continue;
5251
5252         for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5253         {
5254
5255             SKIPTESTS(rightvt);
5256             expected_error_num = S_OK;
5257             resultvt = VT_EMPTY;
5258
5259             if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5260                 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN  ||
5261                 leftvt == VT_RECORD || rightvt == VT_RECORD  ||
5262                 leftvt == 15 || rightvt == 15 /* Undefined type */)
5263                 continue;
5264
5265             /* Check if we need/have support for I8 and/or UI8 */
5266             if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5267                 continue;
5268
5269             if (leftvt == VT_NULL && rightvt == VT_NULL)
5270                 resultvt = VT_NULL;
5271             else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
5272                 rightvt == VT_DATE || rightvt == VT_DECIMAL))
5273                 expected_error_num = DISP_E_TYPEMISMATCH;
5274             else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
5275                 leftvt == VT_R4 || leftvt == VT_R8 ||
5276                 leftvt == VT_CY || leftvt == VT_BOOL ||
5277                 leftvt == VT_BSTR || leftvt == VT_I1 ||
5278                 leftvt == VT_UI1 || leftvt == VT_UI2 ||
5279                 leftvt == VT_UI4 || leftvt == VT_I8 ||
5280                 leftvt == VT_UI8 || leftvt == VT_INT ||
5281                 leftvt == VT_UINT || leftvt == VT_EMPTY ||
5282                 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
5283                 leftvt == VT_DATE)
5284                 &&
5285                 (rightvt == VT_I2 || rightvt == VT_I4 ||
5286                 rightvt == VT_R4 || rightvt == VT_R8 ||
5287                 rightvt == VT_CY || rightvt == VT_BOOL ||
5288                 rightvt == VT_BSTR || rightvt == VT_I1 ||
5289                 rightvt == VT_UI1 || rightvt == VT_UI2 ||
5290                 rightvt == VT_UI4 || rightvt == VT_I8 ||
5291                 rightvt == VT_UI8 || rightvt == VT_INT ||
5292                 rightvt == VT_UINT || rightvt == VT_EMPTY ||
5293                 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
5294                 rightvt == VT_DATE))
5295                 resultvt = VT_BSTR;
5296             else if (rightvt == VT_ERROR && leftvt < VT_VOID)
5297                 expected_error_num = DISP_E_TYPEMISMATCH;
5298             else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
5299                 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
5300                 expected_error_num = DISP_E_TYPEMISMATCH;
5301             else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
5302                 rightvt == VT_DECIMAL)
5303                 expected_error_num = DISP_E_BADVARTYPE;
5304             else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
5305                 expected_error_num = DISP_E_TYPEMISMATCH;
5306             else if (leftvt == VT_VARIANT)
5307                 expected_error_num = DISP_E_TYPEMISMATCH;
5308             else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
5309                 leftvt == VT_NULL || leftvt ==  VT_I2 ||
5310                 leftvt == VT_I4 || leftvt == VT_R4 ||
5311                 leftvt == VT_R8 || leftvt == VT_CY ||
5312                 leftvt == VT_DATE || leftvt == VT_BSTR ||
5313                 leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
5314                 leftvt == VT_I1 || leftvt == VT_UI1 ||
5315                 leftvt == VT_UI2 || leftvt == VT_UI4 ||
5316                 leftvt == VT_I8 || leftvt == VT_UI8 ||
5317                 leftvt == VT_INT || leftvt == VT_UINT
5318                 ))
5319                 expected_error_num = DISP_E_TYPEMISMATCH;
5320             else
5321                 expected_error_num = DISP_E_BADVARTYPE;
5322
5323             V_VT(&left) = leftvt;
5324             V_VT(&right) = rightvt;
5325
5326             switch (leftvt) {
5327             case VT_BSTR:
5328                 V_BSTR(&left) = SysAllocString(sz_empty); break;
5329             case VT_DATE:
5330                 V_DATE(&left) = 0.0; break;
5331             case VT_DECIMAL:
5332                 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
5333             default:
5334                 V_I8(&left) = 0;
5335             }
5336
5337             switch (rightvt) {
5338             case VT_BSTR:
5339                 V_BSTR(&right) = SysAllocString(sz_empty); break;
5340             case VT_DATE:
5341                 V_DATE(&right) = 0.0; break;
5342             case VT_DECIMAL:
5343                 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
5344             default:
5345                 V_I8(&right) = 0;
5346             }
5347
5348             hres = VarCat(&left, &right, &result);
5349
5350             /* Determine the error code for the vt combination */
5351             ok(hres == expected_error_num,
5352                 "VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
5353                 leftvt, rightvt, expected_error_num, hres);
5354
5355             /* Check types are correct */
5356             ok(V_VT(&result) == resultvt,
5357                 "VarCat: %d, %d: expected vt %d, got vt %d\n",
5358                 leftvt, rightvt, resultvt, V_VT(&result));
5359
5360             VariantClear(&left);
5361             VariantClear(&right);
5362             VariantClear(&result);
5363         }
5364     }
5365
5366     /* Running single comparison tests to compare outputs */
5367
5368     /* Test concat strings */
5369     V_VT(&left) = VT_BSTR;
5370     V_VT(&right) = VT_BSTR;
5371     V_VT(&expected) = VT_BSTR;
5372     V_BSTR(&left) = SysAllocString(sz12);
5373     V_BSTR(&right) = SysAllocString(sz34);
5374     V_BSTR(&expected) = SysAllocString(sz1234);
5375     hres = VarCat(&left,&right,&result);
5376     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5377     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5378         "VarCat: VT_BSTR concat with VT_BSTR failed to return correct result\n");
5379
5380     VariantClear(&left);
5381     VariantClear(&right);
5382     VariantClear(&result);
5383
5384     /* Test if expression is VT_ERROR */
5385     V_VT(&left) = VT_ERROR;
5386     V_VT(&right) = VT_BSTR;
5387     V_BSTR(&right) = SysAllocString(sz1234);
5388     hres = VarCat(&left,&right,&result);
5389     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5390     ok(V_VT(&result) == VT_EMPTY,
5391         "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
5392
5393     VariantClear(&left);
5394     VariantClear(&right);
5395     VariantClear(&result);
5396
5397     V_VT(&left) = VT_BSTR;
5398     V_VT(&right) = VT_ERROR;
5399     V_BSTR(&left) = SysAllocString(sz1234);
5400     hres = VarCat(&left,&right,&result);
5401     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5402     ok(V_VT(&result) == VT_EMPTY,
5403         "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
5404
5405     VariantClear(&left);
5406     VariantClear(&right);
5407     VariantClear(&result);
5408     VariantClear(&expected);
5409
5410     /* Test combining boolean with number */
5411     V_VT(&left) = VT_INT;
5412     V_VT(&right) = VT_BOOL;
5413     V_VT(&expected) = VT_BSTR;
5414     V_INT(&left) = 12;
5415     V_BOOL(&right) = TRUE;
5416     V_BSTR(&expected) = SysAllocString(sz12_true);
5417     hres = VarCat(&left,&right,&result);
5418     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5419     hres = VarCmp(&result,&expected,lcid,0);
5420     ok(hres == VARCMP_EQ ||
5421        broken(hres == VARCMP_GT), "Expected VARCMP_EQ, got %08x\n", hres);
5422
5423     VariantClear(&left);
5424     VariantClear(&right);
5425     VariantClear(&result);
5426     VariantClear(&expected);
5427
5428     V_VT(&left) = VT_INT;
5429     V_VT(&right) = VT_BOOL;
5430     V_VT(&expected) = VT_BSTR;
5431     V_INT(&left) = 12;
5432     V_BOOL(&right) = FALSE;
5433     V_BSTR(&expected) = SysAllocString(sz12_false);
5434     hres = VarCat(&left,&right,&result);
5435     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5436     hres = VarCmp(&result,&expected,lcid,0);
5437     ok(hres == VARCMP_EQ ||
5438        broken(hres == VARCMP_GT), "Expected VARCMP_EQ, got %08x\n", hres);
5439
5440     VariantClear(&left);
5441     VariantClear(&right);
5442     VariantClear(&result);
5443     VariantClear(&expected);
5444
5445     /* Test when both expressions are numeric */
5446     V_VT(&left) = VT_INT;
5447     V_VT(&right) = VT_INT;
5448     V_VT(&expected) = VT_BSTR;
5449     V_INT(&left)  = 12;
5450     V_INT(&right) = 34;
5451     V_BSTR(&expected) = SysAllocString(sz1234);
5452     hres = VarCat(&left,&right,&result);
5453     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5454     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5455         "VarCat: NUMBER concat with NUMBER returned inncorrect result\n");
5456
5457     VariantClear(&left);
5458     VariantClear(&right);
5459     VariantClear(&result);
5460
5461     /* Test if one expression is numeric and the other is a string */
5462     V_VT(&left) = VT_INT;
5463     V_VT(&right) = VT_BSTR;
5464     V_INT(&left) = 12;
5465     V_BSTR(&right) = SysAllocString(sz34);
5466     hres = VarCat(&left,&right,&result);
5467     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5468     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5469         "VarCat: NUMBER concat with VT_BSTR, inncorrect result\n");
5470
5471     VariantClear(&left);
5472     VariantClear(&right);
5473     VariantClear(&result);
5474
5475     V_VT(&left) = VT_BSTR;
5476     V_VT(&right) = VT_INT;
5477     V_BSTR(&left) = SysAllocString(sz12);
5478     V_INT(&right) = 34;
5479     hres = VarCat(&left,&right,&result);
5480     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5481     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5482         "VarCat: VT_BSTR concat with NUMBER, inncorrect result\n");
5483
5484     VariantClear(&left);
5485     VariantClear(&right);
5486     VariantClear(&result);
5487     VariantClear(&expected);
5488
5489     /* Test concat dates with strings */
5490     V_VT(&left) = VT_BSTR;
5491     V_VT(&right) = VT_DATE;
5492     V_VT(&expected) = VT_BSTR;
5493     V_BSTR(&left) = SysAllocString(sz12);
5494     V_DATE(&right) = 29494.0;
5495     V_BSTR(&expected)= SysAllocString(sz12_date);
5496     hres = VarCat(&left,&right,&result);
5497     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5498     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5499         "VarCat: VT_BSTR concat with VT_DATE returned inncorrect result\n");
5500
5501     VariantClear(&left);
5502     VariantClear(&right);
5503     VariantClear(&result);
5504     VariantClear(&expected);
5505
5506     V_VT(&left) = VT_DATE;
5507     V_VT(&right) = VT_BSTR;
5508     V_VT(&expected) = VT_BSTR;
5509     V_DATE(&left) = 29494.0;
5510     V_BSTR(&right) = SysAllocString(sz12);
5511     V_BSTR(&expected)= SysAllocString(date_sz12);
5512     hres = VarCat(&left,&right,&result);
5513     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5514     ok(VarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5515         "VarCat: VT_DATE concat with VT_BSTR returned inncorrect result\n");
5516
5517     VariantClear(&left);
5518     VariantClear(&right);
5519     VariantClear(&result);
5520     VariantClear(&expected);
5521
5522     /* Test of both expressions are empty */
5523     V_VT(&left) = VT_BSTR;
5524     V_VT(&right) = VT_BSTR;
5525     V_VT(&expected) = VT_BSTR;
5526     V_BSTR(&left) = SysAllocString(sz_empty);
5527     V_BSTR(&right) = SysAllocString(sz_empty);
5528     V_BSTR(&expected)= SysAllocString(sz_empty);
5529     hres = VarCat(&left,&right,&result);
5530     ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5531     ok(VarCmp(&result,&left,lcid,0) == VARCMP_EQ,
5532         "VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
5533
5534     /* Restore original date format settings */
5535     SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
5536
5537     VariantClear(&left);
5538     VariantClear(&right);
5539     VariantClear(&result);
5540     VariantClear(&expected);
5541 }
5542
5543 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
5544
5545 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
5546         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5547         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5548         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5549         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5550
5551 #define VARANDCY(vt1,val1,val2,rvt,rval)                 \
5552         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5553         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5554         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5555         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5556
5557 /* Skip any type that is not defined or produces an error for every case */
5558 #define SKIPTESTAND(a)                                \
5559         if (a == VT_ERROR || a == VT_VARIANT ||       \
5560             a == VT_DISPATCH || a == VT_UNKNOWN ||    \
5561             a > VT_UINT || a == 15 /*not defined*/)   \
5562             continue
5563
5564 static void test_VarAnd(void)
5565 {
5566     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5567     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5568     VARIANT left, right, exp, result;
5569     BSTR false_str, true_str;
5570     VARTYPE i;
5571     HRESULT hres;
5572
5573     true_str = SysAllocString(szTrue);
5574     false_str = SysAllocString(szFalse);
5575
5576     CHECKPTR(VarAnd);
5577
5578     /* Test all possible flag/vt combinations & the resulting vt type */
5579     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5580     {
5581         VARTYPE leftvt, rightvt, resvt;
5582
5583         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5584         {
5585             SKIPTESTAND(leftvt);
5586
5587             /* Check if we need/have support for I8 and/or UI8 */
5588             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5589                 continue;
5590
5591             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5592             {
5593                 BOOL bFail = FALSE;
5594                 SKIPTESTAND(rightvt);
5595
5596                 /* Check if we need/have support for I8 and/or UI8 */
5597                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5598                     continue;
5599
5600                 memset(&left, 0, sizeof(left));
5601                 memset(&right, 0, sizeof(right));
5602                 V_VT(&left) = leftvt | ExtraFlags[i];
5603                 V_VT(&right) = rightvt | ExtraFlags[i];
5604                 V_VT(&result) = VT_EMPTY;
5605                 resvt = VT_EMPTY;
5606                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
5607                     V_BSTR(&left) = true_str;
5608                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
5609                     V_BSTR(&right) = true_str;
5610
5611                 /* Native VarAnd always returns an error when using extra
5612                  * flags or if the variant combination is I8 and INT.
5613                  */
5614                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5615                     (leftvt == VT_INT && rightvt == VT_I8) ||
5616                     ExtraFlags[i] != 0)
5617                     bFail = TRUE;
5618
5619                 /* Determine return type */
5620                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5621                     resvt = VT_I8;
5622                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5623                     leftvt == VT_UINT || rightvt == VT_UINT ||
5624                     leftvt == VT_INT || rightvt == VT_INT ||
5625                     leftvt == VT_UINT || rightvt == VT_UINT ||
5626                     leftvt == VT_R4 || rightvt == VT_R4 ||
5627                     leftvt == VT_R8 || rightvt == VT_R8 ||
5628                     leftvt == VT_CY || rightvt == VT_CY ||
5629                     leftvt == VT_DATE || rightvt == VT_DATE ||
5630                     leftvt == VT_I1 || rightvt == VT_I1 ||
5631                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5632                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5633                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5634                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5635                     resvt = VT_I4;
5636                 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
5637                     leftvt == VT_I2 || rightvt == VT_I2 ||
5638                     leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5639                     if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
5640                         (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5641                         (leftvt == VT_UI1 && rightvt == VT_UI1))
5642                         resvt = VT_UI1;
5643                     else
5644                         resvt = VT_I2;
5645                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5646                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
5647                     resvt = VT_BOOL;
5648                 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
5649                     leftvt == VT_BSTR || rightvt == VT_BSTR)
5650                     resvt = VT_NULL;
5651                 else
5652                     bFail = TRUE;
5653
5654                 hres = pVarAnd(&left, &right, &result);
5655
5656                 /* Check expected HRESULT and if result variant type is correct */
5657                 if (bFail)
5658                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
5659                         "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
5660                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
5661                         vtstr(V_VT(&result)), hres);
5662                 else
5663                     ok (hres == S_OK && resvt == V_VT(&result),
5664                         "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
5665                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
5666                         S_OK, vtstr(V_VT(&result)), hres);
5667             }
5668         }
5669     }
5670
5671     /*
5672      * Test returned values. Since we know the returned type is correct
5673      * and that we handle all combinations of invalid types, just check
5674      * that good type combinations produce the desired value.
5675      * FIXME: Test VT_DECIMAL
5676      */
5677     VARAND(EMPTY,0,EMPTY,0,I2,0);
5678     VARAND(EMPTY,1,EMPTY,0,I2,0);
5679     VARAND(EMPTY,1,EMPTY,1,I2,0);
5680     VARAND(EMPTY,0,NULL,0,I2,0);
5681     VARAND(EMPTY,1,NULL,0,I2,0);
5682     VARAND(EMPTY,1,NULL,1,I2,0);
5683     VARAND(EMPTY,0,I1,0,I4,0);
5684     VARAND(EMPTY,0,I1,1,I4,0);
5685     VARAND(EMPTY,1,I1,1,I4,0);
5686     VARAND(EMPTY,0,UI1,0,I2,0);
5687     VARAND(EMPTY,0,UI1,1,I2,0);
5688     VARAND(EMPTY,1,UI1,1,I2,0);
5689     VARAND(EMPTY,0,I2,0,I2,0);
5690     VARAND(EMPTY,0,I2,1,I2,0);
5691     VARAND(EMPTY,1,I2,1,I2,0);
5692     VARAND(EMPTY,0,UI2,0,I4,0);
5693     VARAND(EMPTY,0,UI2,1,I4,0);
5694     VARAND(EMPTY,1,UI2,1,I4,0);
5695     VARAND(EMPTY,0,I4,0,I4,0);
5696     VARAND(EMPTY,0,I4,1,I4,0);
5697     VARAND(EMPTY,1,I4,1,I4,0);
5698     VARAND(EMPTY,0,UI4,0,I4,0);
5699     VARAND(EMPTY,0,UI4,1,I4,0);
5700     VARAND(EMPTY,1,UI4,1,I4,0);
5701     if (HAVE_OLEAUT32_I8)
5702     {
5703         VARAND(EMPTY,0,I8,0,I8,0);
5704         VARAND(EMPTY,0,I8,1,I8,0);
5705         VARAND(EMPTY,1,I8,1,I8,0);
5706         VARAND(EMPTY,0,UI8,0,I4,0);
5707         VARAND(EMPTY,0,UI8,1,I4,0);
5708         VARAND(EMPTY,1,UI8,1,I4,0);
5709     }
5710     VARAND(EMPTY,0,INT,0,I4,0);
5711     VARAND(EMPTY,0,INT,1,I4,0);
5712     VARAND(EMPTY,1,INT,1,I4,0);
5713     VARAND(EMPTY,0,UINT,0,I4,0);
5714     VARAND(EMPTY,0,UINT,1,I4,0);
5715     VARAND(EMPTY,1,UINT,1,I4,0);
5716     VARAND(EMPTY,0,BOOL,0,I2,0);
5717     VARAND(EMPTY,0,BOOL,1,I2,0);
5718     VARAND(EMPTY,1,BOOL,1,I2,0);
5719     VARAND(EMPTY,0,R4,0,I4,0);
5720     VARAND(EMPTY,0,R4,1,I4,0);
5721     VARAND(EMPTY,1,R4,1,I4,0);
5722     VARAND(EMPTY,0,R8,0,I4,0);
5723     VARAND(EMPTY,0,R8,1,I4,0);
5724     VARAND(EMPTY,1,R8,1,I4,0);
5725     VARAND(EMPTY,0,BSTR,false_str,I2,0);
5726     VARAND(EMPTY,0,BSTR,true_str,I2,0);
5727     VARANDCY(EMPTY,0,10000,I4,0);
5728
5729     /* NULL OR 0 = NULL. NULL OR n = n */
5730     VARAND(NULL,0,NULL,0,NULL,0);
5731     VARAND(NULL,1,NULL,0,NULL,0);
5732     VARAND(NULL,0,I1,0,I4,0);
5733     VARAND(NULL,0,I1,1,NULL,0);
5734     VARAND(NULL,0,UI1,0,UI1,0);
5735     VARAND(NULL,0,UI1,1,NULL,0);
5736     VARAND(NULL,0,I2,0,I2,0);
5737     VARAND(NULL,0,I2,1,NULL,0);
5738     VARAND(NULL,0,UI2,0,I4,0);
5739     VARAND(NULL,0,UI2,1,NULL,0);
5740     VARAND(NULL,0,I4,0,I4,0);
5741     VARAND(NULL,0,I4,1,NULL,0);
5742     VARAND(NULL,0,UI4,0,I4,0);
5743     VARAND(NULL,0,UI4,1,NULL,0);
5744     if (HAVE_OLEAUT32_I8)
5745     {
5746         VARAND(NULL,0,I8,0,I8,0);
5747         VARAND(NULL,0,I8,1,NULL,0);
5748         VARAND(NULL,0,UI8,0,I4,0);
5749         VARAND(NULL,0,UI8,1,NULL,0);
5750     }
5751     VARAND(NULL,0,INT,0,I4,0);
5752     VARAND(NULL,0,INT,1,NULL,0);
5753     VARAND(NULL,0,UINT,0,I4,0);
5754     VARAND(NULL,0,UINT,1,NULL,0);
5755     VARAND(NULL,0,BOOL,0,BOOL,0);
5756     VARAND(NULL,0,BOOL,1,NULL,0);
5757     VARAND(NULL,0,R4,0,I4,0);
5758     VARAND(NULL,0,R4,1,NULL,0);
5759     VARAND(NULL,0,R8,0,I4,0);
5760     VARAND(NULL,0,R8,1,NULL,0);
5761     VARAND(NULL,0,BSTR,false_str,BOOL,0);
5762     VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
5763     VARANDCY(NULL,0,10000,NULL,0);
5764     VARANDCY(NULL,0,0,I4,0);
5765     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5766     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5767     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
5768     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5769
5770     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5771     VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5772     VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
5773     VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
5774     VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
5775     VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
5776     VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5777     VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5778     VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
5779     VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
5780     VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
5781     VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
5782     VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5783     VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5784     VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
5785     VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
5786     VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5787     VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
5788     VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5789     VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5790     VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
5791     VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
5792     VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5793     VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
5794     VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
5795     VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5796     VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
5797     VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5798     if (HAVE_OLEAUT32_I8)
5799     {
5800         VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5801         VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
5802         VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
5803         VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
5804         VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5805     }
5806     VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5807     VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
5808     VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
5809     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5810     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
5811     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5812     VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
5813     VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
5814     VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
5815     VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
5816     VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
5817     VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
5818     VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
5819     VARAND(I1,-1,I1,-1,I4,-1);
5820     VARAND(I1,-1,I1,0,I4,0);
5821     VARAND(I1,0,I1,0,I4,0);
5822     VARAND(I1,-1,UI1,255,I4,255);
5823     VARAND(I1,-1,UI1,0,I4,0);
5824     VARAND(I1,0,UI1,0,I4,0);
5825     VARAND(I1,-1,I2,-1,I4,-1);
5826     VARAND(I1,-1,I2,0,I4,0);
5827     VARAND(I1,0,I2,0,I4,0);
5828     VARAND(I1,-1,UI2,65535,I4,65535);
5829     VARAND(I1,-1,UI2,0,I4,0);
5830     VARAND(I1,0,UI2,0,I4,0);
5831     VARAND(I1,-1,I4,-1,I4,-1);
5832     VARAND(I1,-1,I4,0,I4,0);
5833     VARAND(I1,0,I4,0,I4,0);
5834     VARAND(I1,-1,UI4,0xffffffff,I4,-1);
5835     VARAND(I1,-1,UI4,0,I4,0);
5836     VARAND(I1,0,UI4,0,I4,0);
5837     VARAND(I1,-1,R4,-1,I4,-1);
5838     VARAND(I1,-1,R4,0,I4,0);
5839     VARAND(I1,0,R4,0,I4,0);
5840     VARAND(I1,-1,R8,-1,I4,-1);
5841     VARAND(I1,-1,R8,0,I4,0);
5842     VARAND(I1,0,R8,0,I4,0);
5843     VARAND(I1,-1,DATE,-1,I4,-1);
5844     VARAND(I1,-1,DATE,0,I4,0);
5845     VARAND(I1,0,DATE,0,I4,0);
5846     if (HAVE_OLEAUT32_I8)
5847     {
5848         VARAND(I1,-1,I8,-1,I8,-1);
5849         VARAND(I1,-1,I8,0,I8,0);
5850         VARAND(I1,0,I8,0,I8,0);
5851         VARAND(I1,-1,UI8,0,I4,0);
5852         VARAND(I1,0,UI8,0,I4,0);
5853     }
5854     VARAND(I1,-1,INT,-1,I4,-1);
5855     VARAND(I1,-1,INT,0,I4,0);
5856     VARAND(I1,0,INT,0,I4,0);
5857     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
5858     VARAND(I1,-1,UINT,0,I4,0);
5859     VARAND(I1,0,UINT,0,I4,0);
5860     VARAND(I1,0,BSTR,false_str,I4,0);
5861     VARAND(I1,-1,BSTR,false_str,I4,0);
5862     VARAND(I1,0,BSTR,true_str,I4,0);
5863     VARAND(I1,-1,BSTR,true_str,I4,-1);
5864     VARANDCY(I1,-1,10000,I4,1);
5865     VARANDCY(I1,-1,0,I4,0);
5866     VARANDCY(I1,0,0,I4,0);
5867
5868     VARAND(UI1,255,UI1,255,UI1,255);
5869     VARAND(UI1,255,UI1,0,UI1,0);
5870     VARAND(UI1,0,UI1,0,UI1,0);
5871     VARAND(UI1,255,I2,-1,I2,255);
5872     VARAND(UI1,255,I2,0,I2,0);
5873     VARAND(UI1,0,I2,0,I2,0);
5874     VARAND(UI1,255,UI2,65535,I4,255);
5875     VARAND(UI1,255,UI2,0,I4,0);
5876     VARAND(UI1,0,UI2,0,I4,0);
5877     VARAND(UI1,255,I4,-1,I4,255);
5878     VARAND(UI1,255,I4,0,I4,0);
5879     VARAND(UI1,0,I4,0,I4,0);
5880     VARAND(UI1,255,UI4,0xffffffff,I4,255);
5881     VARAND(UI1,255,UI4,0,I4,0);
5882     VARAND(UI1,0,UI4,0,I4,0);
5883     VARAND(UI1,255,R4,-1,I4,255);
5884     VARAND(UI1,255,R4,0,I4,0);
5885     VARAND(UI1,0,R4,0,I4,0);
5886     VARAND(UI1,255,R8,-1,I4,255);
5887     VARAND(UI1,255,R8,0,I4,0);
5888     VARAND(UI1,0,R8,0,I4,0);
5889     VARAND(UI1,255,DATE,-1,I4,255);
5890     VARAND(UI1,255,DATE,0,I4,0);
5891     VARAND(UI1,0,DATE,0,I4,0);
5892     if (HAVE_OLEAUT32_I8)
5893     {
5894         VARAND(UI1,255,I8,-1,I8,255);
5895         VARAND(UI1,255,I8,0,I8,0);
5896         VARAND(UI1,0,I8,0,I8,0);
5897         VARAND(UI1,255,UI8,0,I4,0);
5898         VARAND(UI1,0,UI8,0,I4,0);
5899     }
5900     VARAND(UI1,255,INT,-1,I4,255);
5901     VARAND(UI1,255,INT,0,I4,0);
5902     VARAND(UI1,0,INT,0,I4,0);
5903     VARAND(UI1,255,UINT,0xffffffff,I4,255);
5904     VARAND(UI1,255,UINT,0,I4,0);
5905     VARAND(UI1,0,UINT,0,I4,0);
5906     VARAND(UI1,0,BSTR,false_str,I2,0);
5907     VARAND(UI1,255,BSTR,false_str,I2,0);
5908     VARAND(UI1,0,BSTR,true_str,I2,0);
5909     VARAND(UI1,255,BSTR,true_str,I2,255);
5910     VARANDCY(UI1,255,10000,I4,1);
5911     VARANDCY(UI1,255,0,I4,0);
5912     VARANDCY(UI1,0,0,I4,0);
5913
5914     VARAND(I2,-1,I2,-1,I2,-1);
5915     VARAND(I2,-1,I2,0,I2,0);
5916     VARAND(I2,0,I2,0,I2,0);
5917     VARAND(I2,-1,UI2,65535,I4,65535);
5918     VARAND(I2,-1,UI2,0,I4,0);
5919     VARAND(I2,0,UI2,0,I4,0);
5920     VARAND(I2,-1,I4,-1,I4,-1);
5921     VARAND(I2,-1,I4,0,I4,0);
5922     VARAND(I2,0,I4,0,I4,0);
5923     VARAND(I2,-1,UI4,0xffffffff,I4,-1);
5924     VARAND(I2,-1,UI4,0,I4,0);
5925     VARAND(I2,0,UI4,0,I4,0);
5926     VARAND(I2,-1,R4,-1,I4,-1);
5927     VARAND(I2,-1,R4,0,I4,0);
5928     VARAND(I2,0,R4,0,I4,0);
5929     VARAND(I2,-1,R8,-1,I4,-1);
5930     VARAND(I2,-1,R8,0,I4,0);
5931     VARAND(I2,0,R8,0,I4,0);
5932     VARAND(I2,-1,DATE,-1,I4,-1);
5933     VARAND(I2,-1,DATE,0,I4,0);
5934     VARAND(I2,0,DATE,0,I4,0);
5935     if (HAVE_OLEAUT32_I8)
5936     {
5937         VARAND(I2,-1,I8,-1,I8,-1);
5938         VARAND(I2,-1,I8,0,I8,0);
5939         VARAND(I2,0,I8,0,I8,0);
5940         VARAND(I2,-1,UI8,0,I4,0);
5941         VARAND(I2,0,UI8,0,I4,0);
5942     }
5943     VARAND(I2,-1,INT,-1,I4,-1);
5944     VARAND(I2,-1,INT,0,I4,0);
5945     VARAND(I2,0,INT,0,I4,0);
5946     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
5947     VARAND(I2,-1,UINT,0,I4,0);
5948     VARAND(I2,0,UINT,0,I4,0);
5949     VARAND(I2,0,BSTR,false_str,I2,0);
5950     VARAND(I2,-1,BSTR,false_str,I2,0);
5951     VARAND(I2,0,BSTR,true_str,I2,0);
5952     VARAND(I2,-1,BSTR,true_str,I2,-1);
5953     VARANDCY(I2,-1,10000,I4,1);
5954     VARANDCY(I2,-1,0,I4,0);
5955     VARANDCY(I2,0,0,I4,0);
5956
5957     VARAND(UI2,65535,UI2,65535,I4,65535);
5958     VARAND(UI2,65535,UI2,0,I4,0);
5959     VARAND(UI2,0,UI2,0,I4,0);
5960     VARAND(UI2,65535,I4,-1,I4,65535);
5961     VARAND(UI2,65535,I4,0,I4,0);
5962     VARAND(UI2,0,I4,0,I4,0);
5963     VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
5964     VARAND(UI2,65535,UI4,0,I4,0);
5965     VARAND(UI2,0,UI4,0,I4,0);
5966     VARAND(UI2,65535,R4,-1,I4,65535);
5967     VARAND(UI2,65535,R4,0,I4,0);
5968     VARAND(UI2,0,R4,0,I4,0);
5969     VARAND(UI2,65535,R8,-1,I4,65535);
5970     VARAND(UI2,65535,R8,0,I4,0);
5971     VARAND(UI2,0,R8,0,I4,0);
5972     VARAND(UI2,65535,DATE,-1,I4,65535);
5973     VARAND(UI2,65535,DATE,0,I4,0);
5974     VARAND(UI2,0,DATE,0,I4,0);
5975     if (HAVE_OLEAUT32_I8)
5976     {
5977         VARAND(UI2,65535,I8,-1,I8,65535);
5978         VARAND(UI2,65535,I8,0,I8,0);
5979         VARAND(UI2,0,I8,0,I8,0);
5980         VARAND(UI2,65535,UI8,0,I4,0);
5981         VARAND(UI2,0,UI8,0,I4,0);
5982     }
5983     VARAND(UI2,65535,INT,-1,I4,65535);
5984     VARAND(UI2,65535,INT,0,I4,0);
5985     VARAND(UI2,0,INT,0,I4,0);
5986     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
5987     VARAND(UI2,65535,UINT,0,I4,0);
5988     VARAND(UI2,0,UINT,0,I4,0);
5989     VARAND(UI2,0,BSTR,false_str,I4,0);
5990     VARAND(UI2,65535,BSTR,false_str,I4,0);
5991     VARAND(UI2,0,BSTR,true_str,I4,0);
5992     VARAND(UI2,65535,BSTR,true_str,I4,65535);
5993     VARANDCY(UI2,65535,10000,I4,1);
5994     VARANDCY(UI2,65535,0,I4,0);
5995     VARANDCY(UI2,0,0,I4,0);
5996
5997     VARAND(I4,-1,I4,-1,I4,-1);
5998     VARAND(I4,-1,I4,0,I4,0);
5999     VARAND(I4,0,I4,0,I4,0);
6000     VARAND(I4,-1,UI4,0xffffffff,I4,-1);
6001     VARAND(I4,-1,UI4,0,I4,0);
6002     VARAND(I4,0,UI4,0,I4,0);
6003     VARAND(I4,-1,R4,-1,I4,-1);
6004     VARAND(I4,-1,R4,0,I4,0);
6005     VARAND(I4,0,R4,0,I4,0);
6006     VARAND(I4,-1,R8,-1,I4,-1);
6007     VARAND(I4,-1,R8,0,I4,0);
6008     VARAND(I4,0,R8,0,I4,0);
6009     VARAND(I4,-1,DATE,-1,I4,-1);
6010     VARAND(I4,-1,DATE,0,I4,0);
6011     VARAND(I4,0,DATE,0,I4,0);
6012     if (HAVE_OLEAUT32_I8)
6013     {
6014         VARAND(I4,-1,I8,-1,I8,-1);
6015         VARAND(I4,-1,I8,0,I8,0);
6016         VARAND(I4,0,I8,0,I8,0);
6017         VARAND(I4,-1,UI8,0,I4,0);
6018         VARAND(I4,0,UI8,0,I4,0);
6019     }
6020     VARAND(I4,-1,INT,-1,I4,-1);
6021     VARAND(I4,-1,INT,0,I4,0);
6022     VARAND(I4,0,INT,0,I4,0);
6023     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
6024     VARAND(I4,-1,UINT,0,I4,0);
6025     VARAND(I4,0,UINT,0,I4,0);
6026     VARAND(I4,0,BSTR,false_str,I4,0);
6027     VARAND(I4,-1,BSTR,false_str,I4,0);
6028     VARAND(I4,0,BSTR,true_str,I4,0);
6029     VARAND(I4,-1,BSTR,true_str,I4,-1);
6030     VARANDCY(I4,-1,10000,I4,1);
6031     VARANDCY(I4,-1,0,I4,0);
6032     VARANDCY(I4,0,0,I4,0);
6033
6034     VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
6035     VARAND(UI4,0xffffffff,UI4,0,I4,0);
6036     VARAND(UI4,0,UI4,0,I4,0);
6037     VARAND(UI4,0xffffffff,R4,-1,I4,-1);
6038     VARAND(UI4,0xffffffff,R4,0,I4,0);
6039     VARAND(UI4,0,R4,0,I4,0);
6040     VARAND(UI4,0xffffffff,R8,-1,I4,-1);
6041     VARAND(UI4,0xffffffff,R8,0,I4,0);
6042     VARAND(UI4,0,R8,0,I4,0);
6043     VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
6044     VARAND(UI4,0xffffffff,DATE,0,I4,0);
6045     VARAND(UI4,0,DATE,0,I4,0);
6046     if (HAVE_OLEAUT32_I8)
6047     {
6048         VARAND(UI4,0xffffffff,I8,0,I8,0);
6049         VARAND(UI4,0,I8,0,I8,0);
6050         VARAND(UI4,0xffffffff,UI8,0,I4,0);
6051         VARAND(UI4,0,UI8,0,I4,0);
6052     }
6053     VARAND(UI4,0xffffffff,INT,-1,I4,-1);
6054     VARAND(UI4,0xffffffff,INT,0,I4,0);
6055     VARAND(UI4,0,INT,0,I4,0);
6056     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
6057     VARAND(UI4,0xffffffff,UINT,0,I4,0);
6058     VARAND(UI4,0,UINT,0,I4,0);
6059     VARAND(UI4,0,BSTR,false_str,I4,0);
6060     VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
6061     VARAND(UI4,0,BSTR,true_str,I4,0);
6062     VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
6063     VARANDCY(UI4,0xffffffff,10000,I4,1);
6064     VARANDCY(UI4,0xffffffff,0,I4,0);
6065     VARANDCY(UI4,0,0,I4,0);
6066
6067     VARAND(R4,-1,R4,-1,I4,-1);
6068     VARAND(R4,-1,R4,0,I4,0);
6069     VARAND(R4,0,R4,0,I4,0);
6070     VARAND(R4,-1,R8,-1,I4,-1);
6071     VARAND(R4,-1,R8,0,I4,0);
6072     VARAND(R4,0,R8,0,I4,0);
6073     VARAND(R4,-1,DATE,-1,I4,-1);
6074     VARAND(R4,-1,DATE,0,I4,0);
6075     VARAND(R4,0,DATE,0,I4,0);
6076     if (HAVE_OLEAUT32_I8)
6077     {
6078         VARAND(R4,-1,I8,-1,I8,-1);
6079         VARAND(R4,-1,I8,0,I8,0);
6080         VARAND(R4,0,I8,0,I8,0);
6081         VARAND(R4,-1,UI8,0,I4,0);
6082         VARAND(R4,0,UI8,0,I4,0);
6083     }
6084     VARAND(R4,-1,INT,-1,I4,-1);
6085     VARAND(R4,-1,INT,0,I4,0);
6086     VARAND(R4,0,INT,0,I4,0);
6087     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
6088     VARAND(R4,-1,UINT,0,I4,0);
6089     VARAND(R4,0,UINT,0,I4,0);
6090     VARAND(R4,0,BSTR,false_str,I4,0);
6091     VARAND(R4,-1,BSTR,false_str,I4,0);
6092     VARAND(R4,0,BSTR,true_str,I4,0);
6093     VARAND(R4,-1,BSTR,true_str,I4,-1);
6094     VARANDCY(R4,-1,10000,I4,1);
6095     VARANDCY(R4,-1,0,I4,0);
6096     VARANDCY(R4,0,0,I4,0);
6097
6098     VARAND(R8,-1,R8,-1,I4,-1);
6099     VARAND(R8,-1,R8,0,I4,0);
6100     VARAND(R8,0,R8,0,I4,0);
6101     VARAND(R8,-1,DATE,-1,I4,-1);
6102     VARAND(R8,-1,DATE,0,I4,0);
6103     VARAND(R8,0,DATE,0,I4,0);
6104     if (HAVE_OLEAUT32_I8)
6105     {
6106         VARAND(R8,-1,I8,-1,I8,-1);
6107         VARAND(R8,-1,I8,0,I8,0);
6108         VARAND(R8,0,I8,0,I8,0);
6109         VARAND(R8,-1,UI8,0,I4,0);
6110         VARAND(R8,0,UI8,0,I4,0);
6111     }
6112     VARAND(R8,-1,INT,-1,I4,-1);
6113     VARAND(R8,-1,INT,0,I4,0);
6114     VARAND(R8,0,INT,0,I4,0);
6115     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
6116     VARAND(R8,-1,UINT,0,I4,0);
6117     VARAND(R8,0,UINT,0,I4,0);
6118     VARAND(R8,0,BSTR,false_str,I4,0);
6119     VARAND(R8,-1,BSTR,false_str,I4,0);
6120     VARAND(R8,0,BSTR,true_str,I4,0);
6121     VARAND(R8,-1,BSTR,true_str,I4,-1);
6122     VARANDCY(R8,-1,10000,I4,1);
6123     VARANDCY(R8,-1,0,I4,0);
6124     VARANDCY(R8,0,0,I4,0);
6125
6126     VARAND(DATE,-1,DATE,-1,I4,-1);
6127     VARAND(DATE,-1,DATE,0,I4,0);
6128     VARAND(DATE,0,DATE,0,I4,0);
6129     if (HAVE_OLEAUT32_I8)
6130     {
6131         VARAND(DATE,-1,I8,-1,I8,-1);
6132         VARAND(DATE,-1,I8,0,I8,0);
6133         VARAND(DATE,0,I8,0,I8,0);
6134         VARAND(DATE,-1,UI8,0,I4,0);
6135         VARAND(DATE,0,UI8,0,I4,0);
6136     }
6137     VARAND(DATE,-1,INT,-1,I4,-1);
6138     VARAND(DATE,-1,INT,0,I4,0);
6139     VARAND(DATE,0,INT,0,I4,0);
6140     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
6141     VARAND(DATE,-1,UINT,0,I4,0);
6142     VARAND(DATE,0,UINT,0,I4,0);
6143     VARAND(DATE,0,BSTR,false_str,I4,0);
6144     VARAND(DATE,-1,BSTR,false_str,I4,0);
6145     VARAND(DATE,0,BSTR,true_str,I4,0);
6146     VARAND(DATE,-1,BSTR,true_str,I4,-1);
6147     VARANDCY(DATE,-1,10000,I4,1);
6148     VARANDCY(DATE,-1,0,I4,0);
6149     VARANDCY(DATE,0,0,I4,0);
6150
6151     if (HAVE_OLEAUT32_I8)
6152     {
6153         VARAND(I8,-1,I8,-1,I8,-1);
6154         VARAND(I8,-1,I8,0,I8,0);
6155         VARAND(I8,0,I8,0,I8,0);
6156         VARAND(I8,-1,UI8,0,I8,0);
6157         VARAND(I8,0,UI8,0,I8,0);
6158         VARAND(I8,-1,UINT,0,I8,0);
6159         VARAND(I8,0,UINT,0,I8,0);
6160         VARAND(I8,0,BSTR,false_str,I8,0);
6161         VARAND(I8,-1,BSTR,false_str,I8,0);
6162         VARAND(I8,0,BSTR,true_str,I8,0);
6163         VARAND(I8,-1,BSTR,true_str,I8,-1);
6164         VARANDCY(I8,-1,10000,I8,1);
6165         VARANDCY(I8,-1,0,I8,0);
6166         VARANDCY(I8,0,0,I8,0);
6167
6168         VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
6169         VARAND(UI8,0xffff,UI8,0,I4,0);
6170         VARAND(UI8,0,UI8,0,I4,0);
6171         VARAND(UI8,0xffff,INT,-1,I4,65535);
6172         VARAND(UI8,0xffff,INT,0,I4,0);
6173         VARAND(UI8,0,INT,0,I4,0);
6174         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
6175         VARAND(UI8,0xffff,UINT,0,I4,0);
6176         VARAND(UI8,0,UINT,0,I4,0);
6177         VARAND(UI8,0,BSTR,false_str,I4,0);
6178         VARAND(UI8,0xffff,BSTR,false_str,I4,0);
6179         VARAND(UI8,0,BSTR,true_str,I4,0);
6180         VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
6181         VARANDCY(UI8,0xffff,10000,I4,1);
6182         VARANDCY(UI8,0xffff,0,I4,0);
6183         VARANDCY(UI8,0,0,I4,0);
6184     }
6185
6186     VARAND(INT,-1,INT,-1,I4,-1);
6187     VARAND(INT,-1,INT,0,I4,0);
6188     VARAND(INT,0,INT,0,I4,0);
6189     VARAND(INT,-1,UINT,0xffff,I4,65535);
6190     VARAND(INT,-1,UINT,0,I4,0);
6191     VARAND(INT,0,UINT,0,I4,0);
6192     VARAND(INT,0,BSTR,false_str,I4,0);
6193     VARAND(INT,-1,BSTR,false_str,I4,0);
6194     VARAND(INT,0,BSTR,true_str,I4,0);
6195     VARAND(INT,-1,BSTR,true_str,I4,-1);
6196     VARANDCY(INT,-1,10000,I4,1);
6197     VARANDCY(INT,-1,0,I4,0);
6198     VARANDCY(INT,0,0,I4,0);
6199
6200     VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
6201     VARAND(UINT,0xffff,UINT,0,I4,0);
6202     VARAND(UINT,0,UINT,0,I4,0);
6203     VARAND(UINT,0,BSTR,false_str,I4,0);
6204     VARAND(UINT,0xffff,BSTR, false_str,I4,0);
6205     VARAND(UINT,0,BSTR,true_str,I4,0);
6206     VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
6207     VARANDCY(UINT,0xffff,10000,I4,1);
6208     VARANDCY(UINT,0xffff,0,I4,0);
6209     VARANDCY(UINT,0,0,I4,0);
6210
6211     VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
6212     VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
6213     VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
6214     VARANDCY(BSTR,true_str,10000,I4,1);
6215     VARANDCY(BSTR,false_str,10000,I4,0);
6216
6217     SysFreeString(true_str);
6218     SysFreeString(false_str);
6219 }
6220
6221 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
6222
6223 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
6224 {
6225     HRESULT hres;
6226
6227     hres = pVarCmp(left,right,lcid,flags);
6228     ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
6229                        variantstr(left), variantstr(right), result, hres );
6230 }
6231 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
6232                         HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
6233 {
6234     test_cmp( line, lcid, 0, left, right, res1 );
6235     V_VT(left) |= VT_RESERVED;
6236     test_cmp( line, lcid, 0, left, right, res2 );
6237     V_VT(left) &= ~VT_RESERVED;
6238     V_VT(right) |= VT_RESERVED;
6239     test_cmp( line, lcid, 0, left, right, res3 );
6240     V_VT(left) |= VT_RESERVED;
6241     test_cmp( line, lcid, 0, left, right, res4 );
6242     ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
6243 }
6244
6245 /* ERROR from wingdi.h is interfering here */
6246 #undef ERROR
6247 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
6248         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
6249         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
6250         test_cmp( __LINE__, lcid, flags, &left, &right, result )
6251 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
6252         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
6253         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
6254         test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
6255 #define VARCMP(vt1,val1,vt2,val2,result) \
6256         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
6257 /* The above macros do not work for VT_NULL as NULL gets expanded first */
6258 #define V_NULL_  V_NULL
6259 #define VT_NULL_ VT_NULL
6260
6261 static void test_VarCmp(void)
6262 {
6263     VARIANT left, right;
6264     VARTYPE i;
6265     LCID lcid;
6266     HRESULT hres;
6267     DECIMAL dec;
6268     static const WCHAR szhuh[] = {'h','u','h','?','\0'};
6269     static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
6270     static const WCHAR szempty[] = {'\0'};
6271     static const WCHAR sz0[] = {'0','\0'};
6272     static const WCHAR sz1[] = {'1','\0'};
6273     static const WCHAR sz7[] = {'7','\0'};
6274     static const WCHAR sz42[] = {'4','2','\0'};
6275     static const WCHAR sz1neg[] = {'-','1','\0'};
6276     static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
6277     static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
6278     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
6279     BSTR bstr2cents, bstr1few;
6280
6281     CHECKPTR(VarCmp);
6282
6283     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
6284     bstrempty = SysAllocString(szempty);
6285     bstrhuh = SysAllocString(szhuh);
6286     bstr2cents = SysAllocString(sz2cents);
6287     bstr0 = SysAllocString(sz0);
6288     bstr1 = SysAllocString(sz1);
6289     bstr7 = SysAllocString(sz7);
6290     bstr42 = SysAllocString(sz42);
6291     bstr1neg = SysAllocString(sz1neg);
6292     bstr666neg = SysAllocString(sz666neg);
6293     bstr1few = SysAllocString(sz1few);
6294
6295     /* Test all possible flag/vt combinations & the resulting vt type */
6296     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6297     {
6298         VARTYPE leftvt, rightvt;
6299
6300         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6301         {
6302
6303             SKIPTESTS(leftvt);
6304
6305             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6306             {
6307                 BOOL bFail = FALSE;
6308                 HRESULT expect = VARCMP_EQ;
6309
6310                 SKIPTESTS(rightvt);
6311
6312                 memset(&left, 0, sizeof(left));
6313                 memset(&right, 0, sizeof(right));
6314                 V_VT(&left) = leftvt | ExtraFlags[i];
6315                 if (leftvt == VT_BSTR) {
6316                     V_BSTR(&left) = bstr1neg;
6317                     if (ExtraFlags[i] & VT_RESERVED)
6318                         expect = VARCMP_LT;
6319                     else
6320                         expect = VARCMP_GT;
6321                 }
6322                 V_VT(&right) = rightvt | ExtraFlags[i];
6323                 if (rightvt == VT_BSTR) {
6324                     V_BSTR(&right) = bstr1neg;
6325                     if (ExtraFlags[i] & VT_RESERVED)
6326                         expect = VARCMP_GT;
6327                     else
6328                         expect = VARCMP_LT;
6329                 }
6330
6331                 /* Don't ask me why but native VarCmp cannot handle:
6332                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
6333                    VT_INT is only supported as left variant. Go figure.
6334                    Tested with DCOM98, Win2k, WinXP */
6335                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6336                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
6337                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
6338                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6339                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6340                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6341                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6342                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
6343                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6344                     leftvt == VT_I1 || rightvt == VT_I1 ||
6345                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6346                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6347                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6348                     rightvt == VT_INT ||
6349                     leftvt == VT_UINT || rightvt == VT_UINT) {
6350                     bFail = TRUE;
6351                 }
6352
6353                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
6354                     !(ExtraFlags[i] & ~VT_RESERVED)) {
6355                     expect = VARCMP_EQ;
6356                     bFail = FALSE;
6357                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
6358                     expect = VARCMP_NULL;
6359                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
6360                     expect = VARCMP_EQ;
6361                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
6362                     expect = VARCMP_GT;
6363                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
6364                     expect = VARCMP_LT;
6365
6366                 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
6367                 if (bFail) {
6368                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6369                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%X\n",
6370                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
6371                 } else {
6372                     ok(hres == expect,
6373                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%X, got 0x%X\n",
6374                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
6375                        hres);
6376                 }
6377             }
6378         }
6379     }
6380
6381     /* VARCMP{,EX} run each 4 tests with a permutation of all possible
6382        input variants with (1) and without (0) VT_RESERVED set. The order
6383        of the permutations is (0,0); (1,0); (0,1); (1,1) */
6384     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
6385     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
6386     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
6387     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
6388     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
6389     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
6390     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
6391     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
6392     VARCMP(I4,1,UI1,1,VARCMP_EQ);
6393     VARCMP(I2,2,I2,2,VARCMP_EQ);
6394     VARCMP(I2,1,I2,2,VARCMP_LT);
6395     VARCMP(I2,2,I2,1,VARCMP_GT);
6396     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
6397     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
6398
6399     /* BSTR handling, especially in conjunction with VT_RESERVED */
6400     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
6401     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
6402     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
6403     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
6404     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
6405     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
6406     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
6407     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
6408     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
6409     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
6410     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
6411     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
6412     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
6413     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
6414     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6415     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6416     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6417     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6418     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6419     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
6420     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6421     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6422     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
6423     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
6424     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6425     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
6426     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6427     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6428     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6429     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6430     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
6431     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6432     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
6433     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6434     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
6435     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6436     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6437     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6438     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6439     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6440     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6441     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6442     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6443     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6444     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6445     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6446     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6447     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6448     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6449     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6450     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6451     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6452     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
6453     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
6454     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
6455
6456     /* DECIMAL handling */
6457     setdec(&dec,0,0,0,0);
6458     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6459     setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
6460     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
6461     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
6462     setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
6463     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
6464     setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001);    /* 1+1e-20 */
6465     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
6466
6467     /* Show that DATE is handled just as a R8 */
6468     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
6469     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
6470     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
6471     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
6472     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
6473     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
6474     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
6475     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
6476     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
6477
6478     /* R4 precision handling */
6479     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
6480     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
6481     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
6482     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
6483     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
6484     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
6485     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
6486     setdec(&dec,8,0,0,0x5F5E101);         /* 1+1e-8 */
6487     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
6488
6489     SysFreeString(bstrhuh);
6490     SysFreeString(bstrempty);
6491     SysFreeString(bstr0);
6492     SysFreeString(bstr1);
6493     SysFreeString(bstr7);
6494     SysFreeString(bstr42);
6495     SysFreeString(bstr1neg);
6496     SysFreeString(bstr666neg);
6497     SysFreeString(bstr2cents);
6498     SysFreeString(bstr1few);
6499 }
6500
6501 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
6502
6503 #define VARPOW(vt1,val1,vt2,val2,rvt,rval)               \
6504         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6505         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6506         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6507         test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
6508
6509 /* Skip any type that is not defined or produces an error for every case */
6510 #define SKIPTESTPOW(a)                            \
6511     if (a == VT_ERROR || a == VT_VARIANT ||       \
6512         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
6513         a == VT_RECORD || a > VT_UINT ||          \
6514         a == 15 /*not defined*/)                  \
6515         continue
6516
6517 static void test_VarPow(void)
6518 {
6519     static const WCHAR str2[] = { '2','\0' };
6520     static const WCHAR str3[] = { '3','\0' };
6521     VARIANT left, right, exp, result, cy, dec;
6522     BSTR num2_str, num3_str;
6523     VARTYPE i;
6524     HRESULT hres;
6525
6526     CHECKPTR(VarPow);
6527
6528     num2_str = SysAllocString(str2);
6529     num3_str = SysAllocString(str3);
6530
6531     /* Test all possible flag/vt combinations & the resulting vt type */
6532     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6533     {
6534         VARTYPE leftvt, rightvt, resvt;
6535
6536         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6537         {
6538             SKIPTESTPOW(leftvt);
6539
6540             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6541             {
6542                 BOOL bFail = FALSE;
6543                 SKIPTESTPOW(rightvt);
6544
6545                 /* Native crashes with VT_BYREF */
6546                 if (ExtraFlags[i] == VT_BYREF)
6547                     continue;
6548
6549                 memset(&left, 0, sizeof(left));
6550                 memset(&right, 0, sizeof(right));
6551                 V_VT(&left) = leftvt | ExtraFlags[i];
6552                 V_VT(&right) = rightvt | ExtraFlags[i];
6553                 V_VT(&result) = VT_EMPTY;
6554                 resvt = VT_EMPTY;
6555
6556                 if (leftvt == VT_BSTR)
6557                     V_BSTR(&left) = num2_str;
6558                 if (rightvt == VT_BSTR)
6559                     V_BSTR(&right) = num2_str;
6560
6561                 /* Native VarPow always returns an error when using extra flags */
6562                 if (ExtraFlags[i] != 0)
6563                     bFail = TRUE;
6564
6565                 /* Determine return type */
6566                 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
6567                          ((leftvt != VT_I8 && leftvt != VT_UI8 &&
6568                            rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
6569                     resvt = VT_NULL;
6570                 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
6571                     leftvt == VT_I4 || leftvt == VT_R4 ||
6572                     leftvt == VT_R8 || leftvt == VT_CY ||
6573                     leftvt == VT_DATE || leftvt == VT_BSTR ||
6574                     leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
6575                     (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
6576                     (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
6577                     leftvt == VT_INT || leftvt == VT_UINT) &&
6578                     (rightvt == VT_EMPTY || rightvt == VT_I2 ||
6579                     rightvt == VT_I4 || rightvt == VT_R4 ||
6580                     rightvt == VT_R8 || rightvt == VT_CY ||
6581                     rightvt == VT_DATE || rightvt == VT_BSTR ||
6582                     rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
6583                     (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
6584                     (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
6585                     rightvt == VT_INT || rightvt == VT_UINT))
6586                     resvt = VT_R8;
6587                 else
6588                     bFail = TRUE;
6589
6590                 hres = pVarPow(&left, &right, &result);
6591
6592                 /* Check expected HRESULT and if result variant type is correct */
6593                 if (bFail)
6594                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6595                         "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
6596                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
6597                         vtstr(V_VT(&result)), hres);
6598                 else
6599                     ok (hres == S_OK && resvt == V_VT(&result),
6600                         "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
6601                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
6602                         S_OK, vtstr(V_VT(&result)), hres);
6603             }
6604         }
6605     }
6606
6607     /* Check return values for valid variant type combinations */
6608     VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
6609     VARPOW(EMPTY,0,NULL,0,NULL,0);
6610     VARPOW(EMPTY,0,I2,3,R8,0.0);
6611     VARPOW(EMPTY,0,I4,3,R8,0.0);
6612     VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
6613     VARPOW(EMPTY,0,R8,3.0,R8,0.0);
6614     VARPOW(EMPTY,0,DATE,3,R8,0.0);
6615     VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
6616     VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
6617     VARPOW(EMPTY,0,I1,3,R8,0.0);
6618     VARPOW(EMPTY,0,UI1,3,R8,0.0);
6619     VARPOW(EMPTY,0,UI2,3,R8,0.0);
6620     VARPOW(EMPTY,0,UI4,3,R8,0.0);
6621     if (HAVE_OLEAUT32_I8)
6622     {
6623         VARPOW(EMPTY,0,I8,3,R8,0.0);
6624         VARPOW(EMPTY,0,UI8,3,R8,0.0);
6625     }
6626     VARPOW(EMPTY,0,INT,3,R8,0.0);
6627     VARPOW(EMPTY,0,UINT,3,R8,0.0);
6628     VARPOW(NULL,0,EMPTY,0,NULL,0);
6629     VARPOW(NULL,0,NULL,0,NULL,0);
6630     VARPOW(NULL,0,I2,3,NULL,0);
6631     VARPOW(NULL,0,I4,3,NULL,0);
6632     VARPOW(NULL,0,R4,3.0f,NULL,0);
6633     VARPOW(NULL,0,R8,3.0,NULL,0);
6634     VARPOW(NULL,0,DATE,3,NULL,0);
6635     VARPOW(NULL,0,BSTR,num3_str,NULL,0);
6636     VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
6637     VARPOW(NULL,0,I1,3,NULL,0);
6638     VARPOW(NULL,0,UI1,3,NULL,0);
6639     VARPOW(NULL,0,UI2,3,NULL,0);
6640     VARPOW(NULL,0,UI4,3,NULL,0);
6641     if (HAVE_OLEAUT32_I8)
6642     {
6643         VARPOW(NULL,0,I8,3,NULL,0);
6644         VARPOW(NULL,0,UI8,3,NULL,0);
6645     }
6646     VARPOW(NULL,0,INT,3,NULL,0);
6647     VARPOW(NULL,0,UINT,3,NULL,0);
6648     VARPOW(I2,2,EMPTY,0,R8,1.0);
6649     VARPOW(I2,2,NULL,0,NULL,0);
6650     VARPOW(I2,2,I2,3,R8,8.0);
6651     VARPOW(I2,2,I4,3,R8,8.0);
6652     VARPOW(I2,2,R4,3.0f,R8,8.0);
6653     VARPOW(I2,2,R8,3.0,R8,8.0);
6654     VARPOW(I2,2,DATE,3,R8,8.0);
6655     VARPOW(I2,2,BSTR,num3_str,R8,8.0);
6656     VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
6657     VARPOW(I2,2,I1,3,R8,8.0);
6658     VARPOW(I2,2,UI1,3,R8,8.0);
6659     VARPOW(I2,2,UI2,3,R8,8.0);
6660     VARPOW(I2,2,UI4,3,R8,8.0);
6661     if (HAVE_OLEAUT32_I8)
6662     {
6663         VARPOW(I2,2,I8,3,R8,8.0);
6664         VARPOW(I2,2,UI8,3,R8,8.0);
6665     }
6666     VARPOW(I2,2,INT,3,R8,8.0);
6667     VARPOW(I2,2,UINT,3,R8,8.0);
6668     VARPOW(I4,2,EMPTY,0,R8,1.0);
6669     VARPOW(I4,2,NULL,0,NULL,0);
6670     VARPOW(I4,2,I2,3,R8,8.0);
6671     VARPOW(I4,2,I4,3,R8,8.0);
6672     VARPOW(I4,2,R4,3.0f,R8,8.0);
6673     VARPOW(I4,2,R8,3.0,R8,8.0);
6674     VARPOW(I4,2,DATE,3,R8,8.0);
6675     VARPOW(I4,2,BSTR,num3_str,R8,8.0);
6676     VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
6677     VARPOW(I4,2,I1,3,R8,8.0);
6678     VARPOW(I4,2,UI1,3,R8,8.0);
6679     VARPOW(I4,2,UI2,3,R8,8.0);
6680     VARPOW(I4,2,UI4,3,R8,8.0);
6681     if (HAVE_OLEAUT32_I8)
6682     {
6683         VARPOW(I4,2,I8,3,R8,8.0);
6684         VARPOW(I4,2,UI8,3,R8,8.0);
6685     }
6686     VARPOW(I4,2,INT,3,R8,8.0);
6687     VARPOW(I4,2,UINT,3,R8,8.0);
6688     VARPOW(R4,2,EMPTY,0,R8,1.0);
6689     VARPOW(R4,2,NULL,0,NULL,0);
6690     VARPOW(R4,2,I2,3,R8,8.0);
6691     VARPOW(R4,2,I4,3,R8,8.0);
6692     VARPOW(R4,2,R4,3.0f,R8,8.0);
6693     VARPOW(R4,2,R8,3.0,R8,8.0);
6694     VARPOW(R4,2,DATE,3,R8,8.0);
6695     VARPOW(R4,2,BSTR,num3_str,R8,8.0);
6696     VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
6697     VARPOW(R4,2,I1,3,R8,8.0);
6698     VARPOW(R4,2,UI1,3,R8,8.0);
6699     VARPOW(R4,2,UI2,3,R8,8.0);
6700     VARPOW(R4,2,UI4,3,R8,8.0);
6701     if (HAVE_OLEAUT32_I8)
6702     {
6703         VARPOW(R4,2,I8,3,R8,8.0);
6704         VARPOW(R4,2,UI8,3,R8,8.0);
6705     }
6706     VARPOW(R4,2,INT,3,R8,8.0);
6707     VARPOW(R4,2,UINT,3,R8,8.0);
6708     VARPOW(R8,2,EMPTY,0,R8,1.0);
6709     VARPOW(R8,2,NULL,0,NULL,0);
6710     VARPOW(R8,2,I2,3,R8,8.0);
6711     VARPOW(R8,2,I4,3,R8,8.0);
6712     VARPOW(R8,2,R4,3.0f,R8,8.0);
6713     VARPOW(R8,2,R8,3.0,R8,8.0);
6714     VARPOW(R8,2,DATE,3,R8,8.0);
6715     VARPOW(R8,2,BSTR,num3_str,R8,8.0);
6716     VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
6717     VARPOW(R8,2,I1,3,R8,8.0);
6718     VARPOW(R8,2,UI1,3,R8,8.0);
6719     VARPOW(R8,2,UI2,3,R8,8.0);
6720     VARPOW(R8,2,UI4,3,R8,8.0);
6721     if (HAVE_OLEAUT32_I8)
6722     {
6723         VARPOW(R8,2,I8,3,R8,8.0);
6724         VARPOW(R8,2,UI8,3,R8,8.0);
6725     }
6726     VARPOW(R8,2,INT,3,R8,8.0);
6727     VARPOW(R8,2,UINT,3,R8,8.0);
6728     VARPOW(DATE,2,EMPTY,0,R8,1.0);
6729     VARPOW(DATE,2,NULL,0,NULL,0);
6730     VARPOW(DATE,2,I2,3,R8,8.0);
6731     VARPOW(DATE,2,I4,3,R8,8.0);
6732     VARPOW(DATE,2,R4,3.0f,R8,8.0);
6733     VARPOW(DATE,2,R8,3.0,R8,8.0);
6734     VARPOW(DATE,2,DATE,3,R8,8.0);
6735     VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
6736     VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
6737     VARPOW(DATE,2,I1,3,R8,8.0);
6738     VARPOW(DATE,2,UI1,3,R8,8.0);
6739     VARPOW(DATE,2,UI2,3,R8,8.0);
6740     VARPOW(DATE,2,UI4,3,R8,8.0);
6741     if (HAVE_OLEAUT32_I8)
6742     {
6743         VARPOW(DATE,2,I8,3,R8,8.0);
6744         VARPOW(DATE,2,UI8,3,R8,8.0);
6745     }
6746     VARPOW(DATE,2,INT,3,R8,8.0);
6747     VARPOW(DATE,2,UINT,3,R8,8.0);
6748     VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
6749     VARPOW(BSTR,num2_str,NULL,0,NULL,0);
6750     VARPOW(BSTR,num2_str,I2,3,R8,8.0);
6751     VARPOW(BSTR,num2_str,I4,3,R8,8.0);
6752     VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
6753     VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
6754     VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
6755     VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
6756     VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
6757     VARPOW(BSTR,num2_str,I1,3,R8,8.0);
6758     VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
6759     VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
6760     VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
6761     if (HAVE_OLEAUT32_I8)
6762     {
6763         VARPOW(BSTR,num2_str,I8,3,R8,8.0);
6764         VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
6765     }
6766     VARPOW(BSTR,num2_str,INT,3,R8,8.0);
6767     VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
6768     VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
6769     VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
6770     VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
6771     VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
6772     VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
6773     VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
6774     VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
6775     VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
6776     VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
6777     VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
6778     VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
6779     VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
6780     VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
6781     if (HAVE_OLEAUT32_I8)
6782     {
6783         VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
6784         VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
6785     }
6786     VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
6787     VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
6788     VARPOW(I1,2,EMPTY,0,R8,1.0);
6789     VARPOW(I1,2,NULL,0,NULL,0);
6790     VARPOW(I1,2,I2,3,R8,8.0);
6791     VARPOW(I1,2,I4,3,R8,8.0);
6792     VARPOW(I1,2,R4,3.0f,R8,8.0);
6793     VARPOW(I1,2,R8,3.0,R8,8.0);
6794     VARPOW(I1,2,DATE,3,R8,8.0);
6795     VARPOW(I1,2,BSTR,num3_str,R8,8.0);
6796     VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
6797     VARPOW(I1,2,I1,3,R8,8.0);
6798     VARPOW(I1,2,UI1,3,R8,8.0);
6799     VARPOW(I1,2,UI2,3,R8,8.0);
6800     VARPOW(I1,2,UI4,3,R8,8.0);
6801     if (HAVE_OLEAUT32_I8)
6802     {
6803         VARPOW(I1,2,I8,3,R8,8.0);
6804         VARPOW(I1,2,UI8,3,R8,8.0);
6805     }
6806     VARPOW(I1,2,INT,3,R8,8.0);
6807     VARPOW(I1,2,UINT,3,R8,8.0);
6808     VARPOW(UI1,2,EMPTY,0,R8,1.0);
6809     VARPOW(UI1,2,NULL,0,NULL,0);
6810     VARPOW(UI1,2,I2,3,R8,8.0);
6811     VARPOW(UI1,2,I4,3,R8,8.0);
6812     VARPOW(UI1,2,R4,3.0f,R8,8.0);
6813     VARPOW(UI1,2,R8,3.0,R8,8.0);
6814     VARPOW(UI1,2,DATE,3,R8,8.0);
6815     VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
6816     VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
6817     VARPOW(UI1,2,I1,3,R8,8.0);
6818     VARPOW(UI1,2,UI1,3,R8,8.0);
6819     VARPOW(UI1,2,UI2,3,R8,8.0);
6820     VARPOW(UI1,2,UI4,3,R8,8.0);
6821     if (HAVE_OLEAUT32_I8)
6822     {
6823         VARPOW(UI1,2,I8,3,R8,8.0);
6824         VARPOW(UI1,2,UI8,3,R8,8.0);
6825     }
6826     VARPOW(UI1,2,INT,3,R8,8.0);
6827     VARPOW(UI1,2,UINT,3,R8,8.0);
6828     VARPOW(UI2,2,EMPTY,0,R8,1.0);
6829     VARPOW(UI2,2,NULL,0,NULL,0);
6830     VARPOW(UI2,2,I2,3,R8,8.0);
6831     VARPOW(UI2,2,I4,3,R8,8.0);
6832     VARPOW(UI2,2,R4,3.0f,R8,8.0);
6833     VARPOW(UI2,2,R8,3.0,R8,8.0);
6834     VARPOW(UI2,2,DATE,3,R8,8.0);
6835     VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
6836     VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
6837     VARPOW(UI2,2,I1,3,R8,8.0);
6838     VARPOW(UI2,2,UI1,3,R8,8.0);
6839     VARPOW(UI2,2,UI2,3,R8,8.0);
6840     VARPOW(UI2,2,UI4,3,R8,8.0);
6841     if (HAVE_OLEAUT32_I8)
6842     {
6843         VARPOW(UI2,2,I8,3,R8,8.0);
6844         VARPOW(UI2,2,UI8,3,R8,8.0);
6845     }
6846     VARPOW(UI2,2,INT,3,R8,8.0);
6847     VARPOW(UI2,2,UINT,3,R8,8.0);
6848     VARPOW(UI4,2,EMPTY,0,R8,1.0);
6849     VARPOW(UI4,2,NULL,0,NULL,0);
6850     VARPOW(UI4,2,I2,3,R8,8.0);
6851     VARPOW(UI4,2,I4,3,R8,8.0);
6852     VARPOW(UI4,2,R4,3.0f,R8,8.0);
6853     VARPOW(UI4,2,R8,3.0,R8,8.0);
6854     VARPOW(UI4,2,DATE,3,R8,8.0);
6855     VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
6856     VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
6857     VARPOW(UI4,2,I1,3,R8,8.0);
6858     VARPOW(UI4,2,UI1,3,R8,8.0);
6859     VARPOW(UI4,2,UI2,3,R8,8.0);
6860     VARPOW(UI4,2,UI4,3,R8,8.0);
6861     if (HAVE_OLEAUT32_I8)
6862     {
6863         VARPOW(UI4,2,I8,3,R8,8.0);
6864         VARPOW(UI4,2,UI8,3,R8,8.0);
6865     }
6866     VARPOW(UI4,2,INT,3,R8,8.0);
6867     VARPOW(UI4,2,UINT,3,R8,8.0);
6868     if (HAVE_OLEAUT32_I8)
6869     {
6870         VARPOW(I8,2,EMPTY,0,R8,1.0);
6871         VARPOW(I8,2,NULL,0,NULL,0);
6872         VARPOW(I8,2,I2,3,R8,8.0);
6873         VARPOW(I8,2,I4,3,R8,8.0);
6874         VARPOW(I8,2,R4,3.0f,R8,8.0);
6875         VARPOW(I8,2,R8,3.0,R8,8.0);
6876         VARPOW(I8,2,DATE,3,R8,8.0);
6877         VARPOW(I8,2,BSTR,num3_str,R8,8.0);
6878         VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
6879         VARPOW(I8,2,I1,3,R8,8.0);
6880         VARPOW(I8,2,UI1,3,R8,8.0);
6881         VARPOW(I8,2,UI2,3,R8,8.0);
6882         VARPOW(I8,2,UI4,3,R8,8.0);
6883         VARPOW(I8,2,I8,3,R8,8.0);
6884         VARPOW(I8,2,UI8,3,R8,8.0);
6885         VARPOW(I8,2,INT,3,R8,8.0);
6886         VARPOW(I8,2,UINT,3,R8,8.0);
6887         VARPOW(UI8,2,EMPTY,0,R8,1.0);
6888         VARPOW(UI8,2,NULL,0,NULL,0);
6889         VARPOW(UI8,2,I2,3,R8,8.0);
6890         VARPOW(UI8,2,I4,3,R8,8.0);
6891         VARPOW(UI8,2,R4,3.0f,R8,8.0);
6892         VARPOW(UI8,2,R8,3.0,R8,8.0);
6893         VARPOW(UI8,2,DATE,3,R8,8.0);
6894         VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
6895         VARPOW(UI8,2,I1,3,R8,8.0);
6896         VARPOW(UI8,2,UI1,3,R8,8.0);
6897         VARPOW(UI8,2,UI2,3,R8,8.0);
6898         VARPOW(UI8,2,UI4,3,R8,8.0);
6899         VARPOW(UI8,2,I8,3,R8,8.0);
6900         VARPOW(UI8,2,UI8,3,R8,8.0);
6901         VARPOW(UI8,2,INT,3,R8,8.0);
6902         VARPOW(UI8,2,UINT,3,R8,8.0);
6903     }
6904     VARPOW(INT,2,EMPTY,0,R8,1.0);
6905     VARPOW(INT,2,NULL,0,NULL,0);
6906     VARPOW(INT,2,I2,3,R8,8.0);
6907     VARPOW(INT,2,I4,3,R8,8.0);
6908     VARPOW(INT,2,R4,3.0f,R8,8.0);
6909     VARPOW(INT,2,R8,3.0,R8,8.0);
6910     VARPOW(INT,2,DATE,3,R8,8.0);
6911     VARPOW(INT,2,BSTR,num3_str,R8,8.0);
6912     VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
6913     VARPOW(INT,2,I1,3,R8,8.0);
6914     VARPOW(INT,2,UI1,3,R8,8.0);
6915     VARPOW(INT,2,UI2,3,R8,8.0);
6916     VARPOW(INT,2,UI4,3,R8,8.0);
6917     if (HAVE_OLEAUT32_I8)
6918     {
6919         VARPOW(INT,2,I8,3,R8,8.0);
6920         VARPOW(INT,2,UI8,3,R8,8.0);
6921     }
6922     VARPOW(INT,2,INT,3,R8,8.0);
6923     VARPOW(INT,2,UINT,3,R8,8.0);
6924     VARPOW(UINT,2,EMPTY,0,R8,1.0);
6925     VARPOW(UINT,2,NULL,0,NULL,0);
6926     VARPOW(UINT,2,I2,3,R8,8.0);
6927     VARPOW(UINT,2,I4,3,R8,8.0);
6928     VARPOW(UINT,2,R4,3.0f,R8,8.0);
6929     VARPOW(UINT,2,R8,3.0,R8,8.0);
6930     VARPOW(UINT,2,DATE,3,R8,8.0);
6931     VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
6932     VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
6933     VARPOW(UINT,2,I1,3,R8,8.0);
6934     VARPOW(UINT,2,UI1,3,R8,8.0);
6935     VARPOW(UINT,2,UI2,3,R8,8.0);
6936     VARPOW(UINT,2,UI4,3,R8,8.0);
6937     if (HAVE_OLEAUT32_I8)
6938     {
6939         VARPOW(UINT,2,I8,3,R8,8.0);
6940         VARPOW(UINT,2,UI8,3,R8,8.0);
6941     }
6942     VARPOW(UINT,2,INT,3,R8,8.0);
6943     VARPOW(UINT,2,UINT,3,R8,8.0);
6944
6945     /* Manually test some VT_CY, VT_DECIMAL variants */
6946     V_VT(&cy) = VT_CY;
6947     hres = VarCyFromI4(2, &V_CY(&cy));
6948     ok(hres == S_OK, "VarCyFromI4 failed!\n");
6949     V_VT(&dec) = VT_DECIMAL;
6950     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
6951     ok(hres == S_OK, "VarDecFromR4 failed!\n");
6952     memset(&left, 0, sizeof(left));
6953     memset(&right, 0, sizeof(right));
6954     V_VT(&left) = VT_I4;
6955     V_I4(&left) = 100;
6956     V_VT(&right) = VT_I8;
6957     V_UI1(&right) = 2;
6958
6959     hres = pVarPow(&cy, &cy, &result);
6960     ok(hres == S_OK && V_VT(&result) == VT_R8,
6961         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
6962         S_OK, hres, vtstr(V_VT(&result)));
6963     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
6964         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
6965
6966     hres = pVarPow(&cy, &right, &result);
6967     if (hres == S_OK)
6968     {
6969         ok(hres == S_OK && V_VT(&result) == VT_R8,
6970            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
6971            S_OK, hres, vtstr(V_VT(&result)));
6972         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
6973            "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
6974     }
6975     else
6976     {
6977         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
6978            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
6979            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
6980     }
6981
6982     hres = pVarPow(&left, &cy, &result);
6983     ok(hres == S_OK && V_VT(&result) == VT_R8,
6984         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
6985         S_OK, hres, vtstr(V_VT(&result)));
6986     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
6987         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
6988
6989     hres = pVarPow(&left, &dec, &result);
6990     ok(hres == S_OK && V_VT(&result) == VT_R8,
6991         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
6992         S_OK, hres, vtstr(V_VT(&result)));
6993     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
6994         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
6995
6996     hres = pVarPow(&dec, &dec, &result);
6997     ok(hres == S_OK && V_VT(&result) == VT_R8,
6998         "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
6999         S_OK, hres, vtstr(V_VT(&result)));
7000     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7001         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7002
7003     hres = pVarPow(&dec, &right, &result);
7004     if (hres == S_OK)
7005     {
7006         ok(hres == S_OK && V_VT(&result) == VT_R8,
7007            "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7008            S_OK, hres, vtstr(V_VT(&result)));
7009         ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7010            "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7011     }
7012     else
7013     {
7014         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7015            "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7016            DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7017     }
7018
7019     SysFreeString(num2_str);
7020     SysFreeString(num3_str);
7021 }
7022
7023 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7024
7025 #define VARDIV(vt1,val1,vt2,val2,rvt,rval)               \
7026         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7027         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7028         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7029         test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
7030
7031 /* Skip any type that is not defined or produces an error for every case */
7032 #define SKIPTESTDIV(a)                            \
7033     if (a == VT_ERROR || a == VT_VARIANT ||       \
7034         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7035         a == VT_RECORD || a > VT_UINT ||          \
7036         a == VT_I1 || a == VT_UI8 ||              \
7037         a == VT_INT || a == VT_UINT ||            \
7038         a == VT_UI2 || a == VT_UI4 ||             \
7039         a == 15 /*not defined*/)                  \
7040         continue
7041
7042 static void test_VarDiv(void)
7043 {
7044     static const WCHAR str1[] = { '1','\0' };
7045     static const WCHAR str2[] = { '2','\0' };
7046     VARIANT left, right, exp, result, cy, dec;
7047     BSTR num1_str, num2_str;
7048     VARTYPE i;
7049     HRESULT hres, expectedhres;
7050     double r;
7051
7052     num1_str = SysAllocString(str1);
7053     num2_str = SysAllocString(str2);
7054
7055     CHECKPTR(VarDiv);
7056
7057     /* Test all possible flag/vt combinations & the resulting vt type */
7058     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7059     {
7060         VARTYPE leftvt, rightvt, resvt;
7061
7062         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7063         {
7064             SKIPTESTDIV(leftvt);
7065
7066             /* Check if we need/have support for I8 */
7067             if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
7068                 continue;
7069
7070             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7071             {
7072                 BOOL bFail = FALSE;
7073                 SKIPTESTDIV(rightvt);
7074
7075                 /* Check if we need/have support for I8 */
7076                 if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
7077                     continue;
7078
7079                 /* Native crashes with VT_BYREF */
7080                 if (ExtraFlags[i] == VT_BYREF)
7081                     continue;
7082
7083                 memset(&left, 0, sizeof(left));
7084                 memset(&right, 0, sizeof(right));
7085                 V_VT(&left) = leftvt | ExtraFlags[i];
7086                 V_VT(&right) = rightvt | ExtraFlags[i];
7087                 V_VT(&result) = VT_EMPTY;
7088                 resvt = VT_EMPTY;
7089                 expectedhres = S_OK;
7090
7091                 if (leftvt == VT_BSTR)
7092                     V_BSTR(&left) = num2_str;
7093                 else if (leftvt == VT_DECIMAL)
7094                 {
7095                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7096                     V_VT(&left) = leftvt | ExtraFlags[i];
7097                 }
7098
7099                 /* Division by 0 is undefined */
7100                 switch(rightvt)
7101                 {
7102                 case VT_BSTR:
7103                     V_BSTR(&right) = num2_str;
7104                     break;
7105                 case VT_DECIMAL:
7106                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7107                     V_VT(&right) = rightvt | ExtraFlags[i];
7108                     break;
7109                 case VT_BOOL:
7110                     V_BOOL(&right) = VARIANT_TRUE;
7111                     break;
7112                 case VT_I2: V_I2(&right) = 2; break;
7113                 case VT_I4: V_I4(&right) = 2; break;
7114                 case VT_R4: V_R4(&right) = 2.0f; break;
7115                 case VT_R8: V_R8(&right) = 2.0; break;
7116                 case VT_CY: V_CY(&right).int64 = 2; break;
7117                 case VT_DATE: V_DATE(&right) = 2; break;
7118                 case VT_UI1: V_UI1(&right) = 2; break;
7119                 case VT_I8: V_I8(&right) = 2; break;
7120                 default: break;
7121                 }
7122
7123                 /* Determine return type */
7124                 if (!(rightvt == VT_EMPTY))
7125                 {
7126                     if (leftvt == VT_NULL || rightvt == VT_NULL)
7127                         resvt = VT_NULL;
7128                     else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
7129                         resvt = VT_DECIMAL;
7130                     else if (leftvt == VT_I8 || rightvt == VT_I8 ||
7131                         leftvt == VT_CY || rightvt == VT_CY ||
7132                         leftvt == VT_DATE || rightvt == VT_DATE ||
7133                         leftvt == VT_I4 || rightvt == VT_I4 ||
7134                         leftvt == VT_BSTR || rightvt == VT_BSTR ||
7135                         leftvt == VT_I2 || rightvt == VT_I2 ||
7136                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
7137                         leftvt == VT_R8 || rightvt == VT_R8 ||
7138                         leftvt == VT_UI1 || rightvt == VT_UI1)
7139                     {
7140                         if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
7141                             (leftvt == VT_R4 && rightvt == VT_UI1))
7142                             resvt = VT_R4;
7143                         else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
7144                             rightvt == VT_I2)) || (rightvt == VT_R4 &&
7145                             (leftvt == VT_BOOL || leftvt == VT_I2)))
7146                             resvt = VT_R4;
7147                         else
7148                             resvt = VT_R8;
7149                     }
7150                     else if (leftvt == VT_R4 || rightvt == VT_R4)
7151                         resvt = VT_R4;
7152                 }
7153                 else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
7154                     resvt = VT_NULL;
7155                 else
7156                     bFail = TRUE;
7157
7158                 /* Native VarDiv always returns an error when using extra flags */
7159                 if (ExtraFlags[i] != 0)
7160                     bFail = TRUE;
7161
7162                 hres = pVarDiv(&left, &right, &result);
7163
7164                 /* Check expected HRESULT and if result variant type is correct */
7165                 if (bFail)
7166                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7167                         hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
7168                         "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7169                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7170                         vtstr(V_VT(&result)), hres);
7171                 else
7172                     ok (hres == S_OK && resvt == V_VT(&result),
7173                         "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7174                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7175                         S_OK, vtstr(V_VT(&result)), hres);
7176             }
7177         }
7178     }
7179
7180     /* Test return values for all the good cases */
7181     VARDIV(EMPTY,0,NULL,0,NULL,0);
7182     VARDIV(EMPTY,0,I2,2,R8,0.0);
7183     VARDIV(EMPTY,0,I4,2,R8,0.0);
7184     VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
7185     VARDIV(EMPTY,0,R8,2.0,R8,0.0);
7186     VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
7187     VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
7188     VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
7189     VARDIV(EMPTY,0,UI1,2,R8,0.0);
7190     if (HAVE_OLEAUT32_I8)
7191     {
7192         VARDIV(EMPTY,0,I8,2,R8,0.0);
7193     }
7194     VARDIV(NULL,0,EMPTY,0,NULL,0);
7195     VARDIV(NULL,0,NULL,0,NULL,0);
7196     VARDIV(NULL,0,I2,2,NULL,0);
7197     VARDIV(NULL,0,I4,2,NULL,0);
7198     VARDIV(NULL,0,R4,2.0f,NULL,0);
7199     VARDIV(NULL,0,R8,2.0,NULL,0);
7200     VARDIV(NULL,0,DATE,2,NULL,0);
7201     VARDIV(NULL,0,BSTR,num2_str,NULL,0);
7202     VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7203     VARDIV(NULL,0,UI1,2,NULL,0);
7204     if (HAVE_OLEAUT32_I8)
7205     {
7206         VARDIV(NULL,0,I8,2,NULL,0);
7207     }
7208     VARDIV(I2,2,NULL,0,NULL,0);
7209     VARDIV(I2,1,I2,2,R8,0.5);
7210     VARDIV(I2,1,I4,2,R8,0.5);
7211     VARDIV(I2,1,R4,2,R4,0.5f);
7212     VARDIV(I2,1,R8,2.0,R8,0.5);
7213     VARDIV(I2,1,DATE,2,R8,0.5);
7214     VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
7215     VARDIV(I2,1,UI1,2,R8,0.5);
7216     if (HAVE_OLEAUT32_I8)
7217     {
7218         VARDIV(I2,1,I8,2,R8,0.5);
7219     }
7220     VARDIV(I4,1,NULL,0,NULL,0);
7221     VARDIV(I4,1,I2,2,R8,0.5);
7222     VARDIV(I4,1,I4,2,R8,0.5);
7223     VARDIV(I4,1,R4,2.0f,R8,0.5);
7224     VARDIV(I4,1,R8,2.0,R8,0.5);
7225     VARDIV(I4,1,DATE,2,R8,0.5);
7226     VARDIV(I4,1,BSTR,num2_str,R8,0.5);
7227     VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
7228     VARDIV(I4,1,UI1,2,R8,0.5);
7229     if (HAVE_OLEAUT32_I8)
7230     {
7231         VARDIV(I4,1,I8,2,R8,0.5);
7232     }
7233     VARDIV(R4,1.0f,NULL,0,NULL,0);
7234     VARDIV(R4,1.0f,I2,2,R4,0.5f);
7235     VARDIV(R4,1.0f,I4,2,R8,0.5);
7236     VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
7237     VARDIV(R4,1.0f,R8,2.0,R8,0.5);
7238     VARDIV(R4,1.0f,DATE,2,R8,0.5);
7239     VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
7240     VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
7241     VARDIV(R4,1.0f,UI1,2,R4,0.5f);
7242     if (HAVE_OLEAUT32_I8)
7243     {
7244         VARDIV(R4,1.0f,I8,2,R8,0.5);
7245     }
7246     VARDIV(R8,1.0,NULL,0,NULL,0);
7247     VARDIV(R8,1.0,I2,2,R8,0.5);
7248     VARDIV(R8,1.0,I4,2,R8,0.5);
7249     VARDIV(R8,1.0,R4,2.0f,R8,0.5);
7250     VARDIV(R8,1.0,R8,2.0,R8,0.5);
7251     VARDIV(R8,1.0,DATE,2,R8,0.5);
7252     VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
7253     VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
7254     VARDIV(R8,1.0,UI1,2,R8,0.5);
7255     if (HAVE_OLEAUT32_I8)
7256     {
7257         VARDIV(R8,1.0,I8,2,R8,0.5);
7258     }
7259     VARDIV(DATE,1,NULL,0,NULL,0);
7260     VARDIV(DATE,1,I2,2,R8,0.5);
7261     VARDIV(DATE,1,I4,2,R8,0.5);
7262     VARDIV(DATE,1,R4,2.0f,R8,0.5);
7263     VARDIV(DATE,1,R8,2.0,R8,0.5);
7264     VARDIV(DATE,1,DATE,2,R8,0.5);
7265     VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
7266     VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
7267     VARDIV(DATE,1,UI1,2,R8,0.5);
7268     if (HAVE_OLEAUT32_I8)
7269     {
7270         VARDIV(DATE,1,I8,2,R8,0.5);
7271     }
7272     VARDIV(BSTR,num1_str,NULL,0,NULL,0);
7273     VARDIV(BSTR,num1_str,I2,2,R8,0.5);
7274     VARDIV(BSTR,num1_str,I4,2,R8,0.5);
7275     VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
7276     VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
7277     VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
7278     VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
7279     VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
7280     VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
7281     if (HAVE_OLEAUT32_I8)
7282     {
7283         VARDIV(BSTR,num1_str,I8,2,R8,0.5);
7284     }
7285     VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7286     VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
7287     VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
7288     VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
7289     VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
7290     VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
7291     VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
7292     VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
7293     VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
7294     VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
7295     VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
7296     VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
7297     VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
7298     VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
7299     if (HAVE_OLEAUT32_I8)
7300     {
7301         VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
7302     }
7303     VARDIV(UI1,1,NULL,0,NULL,0);
7304     VARDIV(UI1,1,I2,2,R8,0.5);
7305     VARDIV(UI1,1,I4,2,R8,0.5);
7306     VARDIV(UI1,1,R4,2.0f,R4,0.5f);
7307     VARDIV(UI1,1,R8,2.0,R8,0.5);
7308     VARDIV(UI1,1,DATE,2,R8,0.5);
7309     VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
7310     VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
7311     VARDIV(UI1,1,UI1,2,R8,0.5);
7312     if (HAVE_OLEAUT32_I8)
7313     {
7314         VARDIV(UI1,1,I8,2,R8,0.5);
7315         VARDIV(I8,1,NULL,0,NULL,0);
7316         VARDIV(I8,1,I2,2,R8,0.5);
7317         VARDIV(I8,1,I4,2,R8,0.5);
7318         VARDIV(I8,1,R4,2.0f,R8,0.5);
7319         VARDIV(I8,1,R8,2.0,R8,0.5);
7320         VARDIV(I8,1,DATE,2,R8,0.5);
7321         VARDIV(I8,1,BSTR,num2_str,R8,0.5);
7322         VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
7323         VARDIV(I8,1,UI1,2,R8,0.5);
7324         VARDIV(I8,1,I8,2,R8,0.5);
7325     }
7326
7327     /* Manually test some VT_CY, VT_DECIMAL variants */
7328     V_VT(&cy) = VT_CY;
7329     hres = VarCyFromI4(10000, &V_CY(&cy));
7330     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7331     V_VT(&dec) = VT_DECIMAL;
7332     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7333     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7334     memset(&left, 0, sizeof(left));
7335     memset(&right, 0, sizeof(right));
7336     V_VT(&left) = VT_I4;
7337     V_I4(&left) = 100;
7338     V_VT(&right) = VT_UI1;
7339     V_UI1(&right) = 2;
7340
7341     hres = pVarDiv(&cy, &cy, &result);
7342     ok(hres == S_OK && V_VT(&result) == VT_R8,
7343         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7344     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
7345         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
7346
7347     hres = pVarDiv(&cy, &right, &result);
7348     ok(hres == S_OK && V_VT(&result) == VT_R8,
7349         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7350     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
7351         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
7352
7353     hres = pVarDiv(&left, &cy, &result);
7354     ok(hres == S_OK && V_VT(&result) == VT_R8,
7355         "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7356     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
7357         "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
7358
7359     hres = pVarDiv(&left, &dec, &result);
7360     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7361         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7362     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7363     ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
7364         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
7365
7366     hres = pVarDiv(&dec, &dec, &result);
7367     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7368         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7369     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7370     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7371         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7372
7373     hres = pVarDiv(&dec, &right, &result);
7374     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7375         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7376     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7377     ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7378         "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7379
7380     /* Check for division by zero and overflow */
7381     V_VT(&left) = VT_R8;
7382     V_I4(&left) = 1;
7383     V_VT(&right) = VT_R8;
7384     V_I4(&right) = 0;
7385     hres = pVarDiv(&left, &right, &result);
7386     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7387         "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7388
7389     V_VT(&left) = VT_R8;
7390     V_I4(&left) = 0;
7391     V_VT(&right) = VT_R8;
7392     V_I4(&right) = 0;
7393     hres = pVarDiv(&left, &right, &result);
7394     ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
7395         "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%X\n", hres);
7396
7397     SysFreeString(num1_str);
7398     SysFreeString(num2_str);
7399 }
7400
7401 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7402
7403 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval)              \
7404         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7405         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7406         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7407         test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
7408
7409 /* Skip any type that is not defined or produces an error for every case */
7410 #define SKIPTESTIDIV(a)                           \
7411     if (a == VT_ERROR || a == VT_VARIANT ||       \
7412         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7413         a == VT_RECORD || a > VT_UINT ||          \
7414         a == 15 /*not defined*/)                  \
7415         continue
7416
7417 static void test_VarIdiv(void)
7418 {
7419     static const WCHAR str1[] = { '1','\0' };
7420     static const WCHAR str2[] = { '2','\0' };
7421     VARIANT left, right, exp, result, cy, dec;
7422     BSTR num1_str, num2_str;
7423     VARTYPE i;
7424     HRESULT hres;
7425
7426     CHECKPTR(VarIdiv);
7427
7428     num1_str = SysAllocString(str1);
7429     num2_str = SysAllocString(str2);
7430
7431     /* Test all possible flag/vt combinations & the resulting vt type */
7432     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7433     {
7434         VARTYPE leftvt, rightvt, resvt;
7435
7436         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7437         {
7438             SKIPTESTIDIV(leftvt);
7439
7440             /* Check if we need/have support for I8 and/or UI8 */
7441             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7442                 continue;
7443
7444             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7445             {
7446                 BOOL bFail = FALSE;
7447                 SKIPTESTIDIV(rightvt);
7448
7449                 /* Native crashes with extra flag VT_BYREF */
7450                 if (ExtraFlags[i] == VT_BYREF)
7451                     continue;
7452
7453                 /* Check if we need/have support for I8 and/or UI8 */
7454                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7455                     continue;
7456
7457                 memset(&left, 0, sizeof(left));
7458                 memset(&right, 0, sizeof(right));
7459                 V_VT(&left) = leftvt | ExtraFlags[i];
7460                 V_VT(&right) = rightvt | ExtraFlags[i];
7461                 V_VT(&result) = VT_EMPTY;
7462                 resvt = VT_EMPTY;
7463
7464                 if (leftvt == VT_BSTR)
7465                     V_BSTR(&left) = num2_str;
7466                 else if (leftvt == VT_DECIMAL)
7467                 {
7468                     VarDecFromR8(2.0, &V_DECIMAL(&left));
7469                     V_VT(&left) = leftvt | ExtraFlags[i];
7470                 }
7471
7472                 /* Division by 0 is undefined */
7473                 switch(rightvt)
7474                 {
7475                 case VT_BSTR:
7476                     V_BSTR(&right) = num2_str;
7477                     break;
7478                 case VT_DECIMAL:
7479                     VarDecFromR8(2.0, &V_DECIMAL(&right));
7480                     V_VT(&right) = rightvt | ExtraFlags[i];
7481                     break;
7482                 case VT_BOOL:
7483                     V_BOOL(&right) = VARIANT_TRUE;
7484                     break;
7485                 case VT_CY:
7486                     VarCyFromI4(10000, &V_CY(&right));
7487                     V_VT(&right) = rightvt | ExtraFlags[i];
7488                     break;
7489                 case VT_I2: V_I2(&right) = 2; break;
7490                 case VT_I4: V_I4(&right) = 2; break;
7491                 case VT_R4: V_R4(&right) = 2.0f; break;
7492                 case VT_R8: V_R8(&right) = 2.0; break;
7493                 case VT_DATE: V_DATE(&right) = 2; break;
7494                 case VT_I1: V_I1(&right) = 2; break;
7495                 case VT_UI1: V_UI1(&right) = 2; break;
7496                 case VT_UI2: V_UI2(&right) = 2; break;
7497                 case VT_UI4: V_UI4(&right) = 2; break;
7498                 case VT_I8: V_I8(&right) = 2; break;
7499                 case VT_UI8: V_UI8(&right) = 2; break;
7500                 case VT_INT: V_INT(&right) = 2; break;
7501                 case VT_UINT: V_UINT(&right) = 2; break;
7502                 default: break;
7503                 }
7504
7505                 /* Native VarIdiv always returns an error when using extra
7506                  * flags or if the variant combination is I8 and INT.
7507                  */
7508                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
7509                     (leftvt == VT_INT && rightvt == VT_I8) ||
7510                     (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
7511                     ExtraFlags[i] != 0)
7512                     bFail = TRUE;
7513
7514                 /* Determine variant type */
7515                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
7516                     resvt = VT_NULL;
7517                 else if (leftvt == VT_I8 || rightvt == VT_I8)
7518                     resvt = VT_I8;
7519                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
7520                     leftvt == VT_INT || rightvt == VT_INT ||
7521                     leftvt == VT_UINT || rightvt == VT_UINT ||
7522                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
7523                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
7524                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
7525                     leftvt == VT_I1 || rightvt == VT_I1 ||
7526                     leftvt == VT_BSTR || rightvt == VT_BSTR ||
7527                     leftvt == VT_DATE || rightvt == VT_DATE ||
7528                     leftvt == VT_CY || rightvt == VT_CY ||
7529                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
7530                     leftvt == VT_R8 || rightvt == VT_R8 ||
7531                     leftvt == VT_R4 || rightvt == VT_R4)
7532                     resvt = VT_I4;
7533                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
7534                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
7535                     leftvt == VT_EMPTY)
7536                     resvt = VT_I2;
7537                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
7538                     resvt = VT_UI1;
7539                 else
7540                     bFail = TRUE;
7541
7542                 hres = pVarIdiv(&left, &right, &result);
7543
7544                 /* Check expected HRESULT and if result variant type is correct */
7545                 if (bFail)
7546                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7547                         hres == DISP_E_DIVBYZERO,
7548                         "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7549                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7550                         vtstr(V_VT(&result)), hres);
7551                 else
7552                     ok (hres == S_OK && resvt == V_VT(&result),
7553                         "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7554                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7555                         S_OK, vtstr(V_VT(&result)), hres);
7556             }
7557         }
7558     }
7559
7560     /* Test return values for all the good cases */
7561     VARIDIV(EMPTY,0,NULL,0,NULL,0);
7562     VARIDIV(EMPTY,0,I2,1,I2,0);
7563     VARIDIV(EMPTY,0,I4,1,I4,0);
7564     VARIDIV(EMPTY,0,R4,1.0f,I4,0);
7565     VARIDIV(EMPTY,0,R8,1.0,I4,0);
7566     VARIDIV(EMPTY,0,DATE,1.0,I4,0);
7567     VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
7568     VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
7569     VARIDIV(EMPTY,0,I1,1,I4,0);
7570     VARIDIV(EMPTY,0,UI1,1,I2,0);
7571     VARIDIV(EMPTY,0,UI2,1,I4,0);
7572     VARIDIV(EMPTY,0,UI4,1,I4,0);
7573     if (HAVE_OLEAUT32_I8)
7574     {
7575         VARIDIV(EMPTY,0,I8,1,I8,0);
7576         VARIDIV(EMPTY,0,UI8,1,I4,0);
7577     }
7578     VARIDIV(EMPTY,0,INT,1,I4,0);
7579     VARIDIV(EMPTY,0,UINT,1,I4,0);
7580     VARIDIV(NULL,0,EMPTY,0,NULL,0);
7581     VARIDIV(NULL,0,NULL,0,NULL,0);
7582     VARIDIV(NULL,0,I2,1,NULL,0);
7583     VARIDIV(NULL,0,I4,1,NULL,0);
7584     VARIDIV(NULL,0,R4,1,NULL,0);
7585     VARIDIV(NULL,0,R8,1,NULL,0);
7586     VARIDIV(NULL,0,DATE,1,NULL,0);
7587     VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
7588     VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7589     VARIDIV(NULL,0,I1,1,NULL,0);
7590     VARIDIV(NULL,0,UI1,1,NULL,0);
7591     VARIDIV(NULL,0,UI2,1,NULL,0);
7592     VARIDIV(NULL,0,UI4,1,NULL,0);
7593     if (HAVE_OLEAUT32_I8)
7594     {
7595         VARIDIV(NULL,0,I8,1,NULL,0);
7596         VARIDIV(NULL,0,UI8,1,NULL,0);
7597     }
7598     VARIDIV(NULL,0,INT,1,NULL,0);
7599     VARIDIV(NULL,0,UINT,1,NULL,0);
7600     VARIDIV(I2,2,NULL,0,NULL,0);
7601     VARIDIV(I2,2,I2,1,I2,2);
7602     VARIDIV(I2,2,I4,1,I4,2);
7603     VARIDIV(I2,2,R4,1,I4,2);
7604     VARIDIV(I2,2,R8,1,I4,2);
7605     VARIDIV(I2,2,DATE,1,I4,2);
7606     VARIDIV(I2,2,BSTR,num1_str,I4,2);
7607     VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
7608     VARIDIV(I2,2,I1,1,I4,2);
7609     VARIDIV(I2,2,UI1,1,I2,2);
7610     VARIDIV(I2,2,UI2,1,I4,2);
7611     VARIDIV(I2,2,UI4,1,I4,2);
7612     if (HAVE_OLEAUT32_I8)
7613     {
7614         VARIDIV(I2,2,I8,1,I8,2);
7615         VARIDIV(I2,2,UI8,1,I4,2);
7616     }
7617     VARIDIV(I2,2,INT,1,I4,2);
7618     VARIDIV(I2,2,UINT,1,I4,2);
7619     VARIDIV(I4,2,NULL,0,NULL,0);
7620     VARIDIV(I4,2,I2,1,I4,2);
7621     VARIDIV(I4,2,I4,1,I4,2);
7622     VARIDIV(I4,2,R4,1,I4,2);
7623     VARIDIV(I4,2,R8,1,I4,2);
7624     VARIDIV(I4,2,DATE,1,I4,2);
7625     VARIDIV(I4,2,BSTR,num1_str,I4,2);
7626     VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
7627     VARIDIV(I4,2,I1,1,I4,2);
7628     VARIDIV(I4,2,UI1,1,I4,2);
7629     VARIDIV(I4,2,UI2,1,I4,2);
7630     VARIDIV(I4,2,UI4,1,I4,2);
7631     if (HAVE_OLEAUT32_I8)
7632     {
7633         VARIDIV(I4,2,I8,1,I8,2);
7634         VARIDIV(I4,2,UI8,1,I4,2);
7635     }
7636     VARIDIV(I4,2,INT,1,I4,2);
7637     VARIDIV(I4,2,UINT,1,I4,2);
7638     VARIDIV(R4,2.0f,NULL,0,NULL,0);
7639     VARIDIV(R4,2.0f,I2,1,I4,2);
7640     VARIDIV(R4,2.0f,I4,1,I4,2);
7641     VARIDIV(R4,2.0f,R4,1.0f,I4,2);
7642     VARIDIV(R4,2.0f,R8,1.0,I4,2);
7643     VARIDIV(R4,2.0f,DATE,1,I4,2);
7644     VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
7645     VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
7646     VARIDIV(R4,2.0f,I1,1,I4,2);
7647     VARIDIV(R4,2.0f,UI1,1,I4,2);
7648     VARIDIV(R4,2.0f,UI2,1,I4,2);
7649     VARIDIV(R4,2.0f,UI4,1,I4,2);
7650     if (HAVE_OLEAUT32_I8)
7651     {
7652         VARIDIV(R4,2.0f,I8,1,I8,2);
7653         VARIDIV(R4,2.0f,UI8,1,I4,2);
7654     }
7655     VARIDIV(R4,2.0f,INT,1,I4,2);
7656     VARIDIV(R4,2.0f,UINT,1,I4,2);
7657     VARIDIV(R8,2.0,NULL,0,NULL,0);
7658     VARIDIV(R8,2.0,I2,1,I4,2);
7659     VARIDIV(R8,2.0,I4,1,I4,2);
7660     VARIDIV(R8,2.0,R4,1,I4,2);
7661     VARIDIV(R8,2.0,R8,1,I4,2);
7662     VARIDIV(R8,2.0,DATE,1,I4,2);
7663     VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
7664     VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
7665     VARIDIV(R8,2.0,I1,1,I4,2);
7666     VARIDIV(R8,2.0,UI1,1,I4,2);
7667     VARIDIV(R8,2.0,UI2,1,I4,2);
7668     VARIDIV(R8,2.0,UI4,1,I4,2);
7669     if (HAVE_OLEAUT32_I8)
7670     {
7671         VARIDIV(R8,2.0,I8,1,I8,2);
7672         VARIDIV(R8,2.0,UI8,1,I4,2);
7673     }
7674     VARIDIV(R8,2.0,INT,1,I4,2);
7675     VARIDIV(R8,2.0,UINT,1,I4,2);
7676     VARIDIV(DATE,2,NULL,0,NULL,0);
7677     VARIDIV(DATE,2,I2,1,I4,2);
7678     VARIDIV(DATE,2,I4,1,I4,2);
7679     VARIDIV(DATE,2,R4,1,I4,2);
7680     VARIDIV(DATE,2,R8,1,I4,2);
7681     VARIDIV(DATE,2,DATE,1,I4,2);
7682     VARIDIV(DATE,2,BSTR,num1_str,I4,2);
7683     VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
7684     VARIDIV(DATE,2,I1,1,I4,2);
7685     VARIDIV(DATE,2,UI1,1,I4,2);
7686     VARIDIV(DATE,2,UI2,1,I4,2);
7687     VARIDIV(DATE,2,UI4,1,I4,2);
7688     if (HAVE_OLEAUT32_I8)
7689     {
7690         VARIDIV(DATE,2,I8,1,I8,2);
7691         VARIDIV(DATE,2,UI8,1,I4,2);
7692     }
7693     VARIDIV(DATE,2,INT,1,I4,2);
7694     VARIDIV(DATE,2,UINT,1,I4,2);
7695     VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
7696     VARIDIV(BSTR,num2_str,I2,1,I4,2);
7697     VARIDIV(BSTR,num2_str,I4,1,I4,2);
7698     VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
7699     VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
7700     VARIDIV(BSTR,num2_str,DATE,1,I4,2);
7701     VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
7702     VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
7703     VARIDIV(BSTR,num2_str,I1,1,I4,2);
7704     VARIDIV(BSTR,num2_str,UI1,1,I4,2);
7705     VARIDIV(BSTR,num2_str,UI2,1,I4,2);
7706     VARIDIV(BSTR,num2_str,UI4,1,I4,2);
7707     if (HAVE_OLEAUT32_I8)
7708     {
7709         VARIDIV(BSTR,num2_str,I8,1,I8,2);
7710         VARIDIV(BSTR,num2_str,UI8,1,I4,2);
7711     }
7712     VARIDIV(BSTR,num2_str,INT,1,I4,2);
7713     VARIDIV(BSTR,num2_str,UINT,1,I4,2);
7714     VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7715     VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
7716     VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
7717     VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
7718     VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
7719     VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
7720     VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
7721     VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
7722     VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
7723     VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
7724     VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
7725     VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
7726     if (HAVE_OLEAUT32_I8)
7727     {
7728         VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
7729         VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
7730     }
7731     VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
7732     VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
7733     VARIDIV(I1,2,NULL,0,NULL,0);
7734     VARIDIV(I1,2,I2,1,I4,2);
7735     VARIDIV(I1,2,I4,1,I4,2);
7736     VARIDIV(I1,2,R4,1.0f,I4,2);
7737     VARIDIV(I1,2,R8,1.0,I4,2);
7738     VARIDIV(I1,2,DATE,1,I4,2);
7739     VARIDIV(I1,2,BSTR,num1_str,I4,2);
7740     VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
7741     VARIDIV(I1,2,I1,1,I4,2);
7742     VARIDIV(I1,2,UI1,1,I4,2);
7743     VARIDIV(I1,2,UI2,1,I4,2);
7744     VARIDIV(I1,2,UI4,1,I4,2);
7745     if (HAVE_OLEAUT32_I8)
7746     {
7747         VARIDIV(I1,2,I8,1,I8,2);
7748         VARIDIV(I1,2,UI8,1,I4,2);
7749     }
7750     VARIDIV(I1,2,INT,1,I4,2);
7751     VARIDIV(I1,2,UINT,1,I4,2);
7752     VARIDIV(UI1,2,NULL,0,NULL,0);
7753     VARIDIV(UI1,2,I2,1,I2,2);
7754     VARIDIV(UI1,2,I4,1,I4,2);
7755     VARIDIV(UI1,2,R4,1.0f,I4,2);
7756     VARIDIV(UI1,2,R8,1.0,I4,2);
7757     VARIDIV(UI1,2,DATE,1,I4,2);
7758     VARIDIV(UI1,2,BSTR,num1_str,I4,2);
7759     VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
7760     VARIDIV(UI1,2,I1,1,I4,2);
7761     VARIDIV(UI1,2,UI1,1,UI1,2);
7762     VARIDIV(UI1,2,UI2,1,I4,2);
7763     VARIDIV(UI1,2,UI4,1,I4,2);
7764     if (HAVE_OLEAUT32_I8)
7765     {
7766         VARIDIV(UI1,2,I8,1,I8,2);
7767         VARIDIV(UI1,2,UI8,1,I4,2);
7768     }
7769     VARIDIV(UI1,2,INT,1,I4,2);
7770     VARIDIV(UI1,2,UINT,1,I4,2);
7771     VARIDIV(UI2,2,NULL,0,NULL,0);
7772     VARIDIV(UI2,2,I2,1,I4,2);
7773     VARIDIV(UI2,2,I4,1,I4,2);
7774     VARIDIV(UI2,2,R4,1.0f,I4,2);
7775     VARIDIV(UI2,2,R8,1.0,I4,2);
7776     VARIDIV(UI2,2,DATE,1,I4,2);
7777     VARIDIV(UI2,2,BSTR,num1_str,I4,2);
7778     VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
7779     VARIDIV(UI2,2,I1,1,I4,2);
7780     VARIDIV(UI2,2,UI1,1,I4,2);
7781     VARIDIV(UI2,2,UI2,1,I4,2);
7782     VARIDIV(UI2,2,UI4,1,I4,2);
7783     if (HAVE_OLEAUT32_I8)
7784     {
7785         VARIDIV(UI2,2,I8,1,I8,2);
7786         VARIDIV(UI2,2,UI8,1,I4,2);
7787     }
7788     VARIDIV(UI2,2,INT,1,I4,2);
7789     VARIDIV(UI2,2,UINT,1,I4,2);
7790     VARIDIV(UI4,2,NULL,0,NULL,0);
7791     VARIDIV(UI4,2,I2,1,I4,2);
7792     VARIDIV(UI4,2,I4,1,I4,2);
7793     VARIDIV(UI4,2,R4,1.0f,I4,2);
7794     VARIDIV(UI4,2,R8,1.0,I4,2);
7795     VARIDIV(UI4,2,DATE,1,I4,2);
7796     VARIDIV(UI4,2,BSTR,num1_str,I4,2);
7797     VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
7798     VARIDIV(UI4,2,I1,1,I4,2);
7799     VARIDIV(UI4,2,UI1,1,I4,2);
7800     VARIDIV(UI4,2,UI2,1,I4,2);
7801     VARIDIV(UI4,2,UI4,1,I4,2);
7802     if (HAVE_OLEAUT32_I8)
7803     {
7804         VARIDIV(UI4,2,I8,1,I8,2);
7805         VARIDIV(UI4,2,UI8,1,I4,2);
7806     }
7807     VARIDIV(UI4,2,INT,1,I4,2);
7808     VARIDIV(UI4,2,UINT,1,I4,2);
7809     if (HAVE_OLEAUT32_I8)
7810     {
7811         VARIDIV(I8,2,NULL,0,NULL,0);
7812         VARIDIV(I8,2,I2,1,I8,2);
7813         VARIDIV(I8,2,I4,1,I8,2);
7814         VARIDIV(I8,2,R4,1.0f,I8,2);
7815         VARIDIV(I8,2,R8,1.0,I8,2);
7816         VARIDIV(I8,2,DATE,1,I8,2);
7817         VARIDIV(I8,2,BSTR,num1_str,I8,2);
7818         VARIDIV(I8,2,BOOL,1,I8,2);
7819         VARIDIV(I8,2,I1,1,I8,2);
7820         VARIDIV(I8,2,UI1,1,I8,2);
7821         VARIDIV(I8,2,UI2,1,I8,2);
7822         VARIDIV(I8,2,UI4,1,I8,2);
7823         VARIDIV(I8,2,I8,1,I8,2);
7824         VARIDIV(I8,2,UI8,1,I8,2);
7825         VARIDIV(I8,2,UINT,1,I8,2);
7826         VARIDIV(UI8,2,NULL,0,NULL,0);
7827         VARIDIV(UI8,2,I2,1,I4,2);
7828         VARIDIV(UI8,2,I4,1,I4,2);
7829         VARIDIV(UI8,2,R4,1.0f,I4,2);
7830         VARIDIV(UI8,2,R8,1.0,I4,2);
7831         VARIDIV(UI8,2,DATE,1,I4,2);
7832         VARIDIV(UI8,2,BSTR,num1_str,I4,2);
7833         VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
7834         VARIDIV(UI8,2,I1,1,I4,2);
7835         VARIDIV(UI8,2,UI1,1,I4,2);
7836         VARIDIV(UI8,2,UI2,1,I4,2);
7837         VARIDIV(UI8,2,UI4,1,I4,2);
7838         VARIDIV(UI8,2,I8,1,I8,2);
7839         VARIDIV(UI8,2,UI8,1,I4,2);
7840         VARIDIV(UI8,2,INT,1,I4,2);
7841         VARIDIV(UI8,2,UINT,1,I4,2);
7842     }
7843     VARIDIV(INT,2,NULL,0,NULL,0);
7844     VARIDIV(INT,2,I2,1,I4,2);
7845     VARIDIV(INT,2,I4,1,I4,2);
7846     VARIDIV(INT,2,R4,1.0f,I4,2);
7847     VARIDIV(INT,2,R8,1.0,I4,2);
7848     VARIDIV(INT,2,DATE,1,I4,2);
7849     VARIDIV(INT,2,BSTR,num1_str,I4,2);
7850     VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
7851     VARIDIV(INT,2,I1,1,I4,2);
7852     VARIDIV(INT,2,UI1,1,I4,2);
7853     VARIDIV(INT,2,UI2,1,I4,2);
7854     VARIDIV(INT,2,UI4,1,I4,2);
7855     if (HAVE_OLEAUT32_I8)
7856     {
7857         VARIDIV(INT,2,UI8,1,I4,2);
7858     }
7859     VARIDIV(INT,2,INT,1,I4,2);
7860     VARIDIV(INT,2,UINT,1,I4,2);
7861     VARIDIV(UINT,2,NULL,0,NULL,0);
7862     VARIDIV(UINT,2,I2,1,I4,2);
7863     VARIDIV(UINT,2,I4,1,I4,2);
7864     VARIDIV(UINT,2,R4,1.0f,I4,2);
7865     VARIDIV(UINT,2,R8,1.0,I4,2);
7866     VARIDIV(UINT,2,DATE,1,I4,2);
7867     VARIDIV(UINT,2,BSTR,num1_str,I4,2);
7868     VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
7869     VARIDIV(UINT,2,I1,1,I4,2);
7870     VARIDIV(UINT,2,UI1,1,I4,2);
7871     VARIDIV(UINT,2,UI2,1,I4,2);
7872     VARIDIV(UINT,2,UI4,1,I4,2);
7873     if (HAVE_OLEAUT32_I8)
7874     {
7875         VARIDIV(UINT,2,I8,1,I8,2);
7876         VARIDIV(UINT,2,UI8,1,I4,2);
7877     }
7878     VARIDIV(UINT,2,INT,1,I4,2);
7879     VARIDIV(UINT,2,UINT,1,I4,2);
7880
7881     /* Manually test some VT_CY, VT_DECIMAL variants */
7882     V_VT(&cy) = VT_CY;
7883     hres = VarCyFromI4(10000, &V_CY(&cy));
7884     ok(hres == S_OK, "VarCyFromI4 failed!\n");
7885     V_VT(&dec) = VT_DECIMAL;
7886     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7887     ok(hres == S_OK, "VarDecFromR4 failed!\n");
7888     memset(&left, 0, sizeof(left));
7889     memset(&right, 0, sizeof(right));
7890     V_VT(&left) = VT_I4;
7891     V_I4(&left) = 100;
7892     V_VT(&right) = VT_I8;
7893     V_UI1(&right) = 2;
7894
7895     hres = VarIdiv(&cy, &cy, &result);
7896     ok(hres == S_OK && V_VT(&result) == VT_I4,
7897         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
7898         S_OK, hres, vtstr(V_VT(&result)));
7899     ok(hres == S_OK && V_I4(&result) == 1,
7900         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
7901
7902     if (HAVE_OLEAUT32_I8)
7903     {
7904         hres = VarIdiv(&cy, &right, &result);
7905         ok(hres == S_OK && V_VT(&result) == VT_I8,
7906             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
7907             S_OK, hres, vtstr(V_VT(&result)));
7908         ok(hres == S_OK && V_I8(&result) == 5000,
7909             "VARIDIV: CY value 0x%x%08x, expected 0x%x\n",
7910             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), 5000);
7911     }
7912
7913     hres = VarIdiv(&left, &cy, &result);
7914     ok(hres == S_OK && V_VT(&result) == VT_I4,
7915         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
7916         S_OK, hres, vtstr(V_VT(&result)));
7917     ok(hres == S_OK && V_I4(&result) == 0,
7918         "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 0);
7919
7920     hres = VarIdiv(&left, &dec, &result);
7921     ok(hres == S_OK && V_VT(&result) == VT_I4,
7922         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
7923         S_OK, hres, vtstr(V_VT(&result)));
7924     ok(hres == S_OK && V_I4(&result) == 50,
7925         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 50);
7926
7927     hres = VarIdiv(&dec, &dec, &result);
7928     ok(hres == S_OK && V_VT(&result) == VT_I4,
7929         "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
7930         S_OK, hres, vtstr(V_VT(&result)));
7931     ok(hres == S_OK && V_I4(&result) == 1,
7932         "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
7933
7934     if (HAVE_OLEAUT32_I8)
7935     {
7936         hres = VarIdiv(&dec, &right, &result);
7937         ok(hres == S_OK && V_VT(&result) == VT_I8,
7938             "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
7939             S_OK, hres, vtstr(V_VT(&result)));
7940         ok(hres == S_OK && V_I8(&result) == 1,
7941             "VARIDIV: DECIMAL value 0x%x%08x, expected %d\n",
7942             (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result), 1);
7943     }
7944
7945     /* Check for division by zero */
7946     V_VT(&left) = VT_INT;
7947     V_I4(&left) = 1;
7948     V_VT(&right) = VT_INT;
7949     V_I4(&right) = 0;
7950     hres = pVarIdiv(&left, &right, &result);
7951     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7952         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7953
7954     V_VT(&left) = VT_INT;
7955     V_I4(&left) = 0;
7956     V_VT(&right) = VT_INT;
7957     V_I4(&right) = 0;
7958     hres = pVarIdiv(&left, &right, &result);
7959     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7960         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7961
7962     SysFreeString(num1_str);
7963     SysFreeString(num2_str);
7964 }
7965
7966
7967 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
7968
7969 #define VARIMP(vt1,val1,vt2,val2,rvt,rval)              \
7970         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7971         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7972         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7973         test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
7974
7975 /* Skip any type that is not defined or produces an error for every case */
7976 #define SKIPTESTIMP(a)                            \
7977     if (a == VT_ERROR || a == VT_VARIANT ||       \
7978         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7979         a == VT_RECORD || a > VT_UINT ||          \
7980         a == 15 /*not defined*/)                  \
7981         continue
7982
7983 static void test_VarImp(void)
7984 {
7985     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
7986     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
7987     VARIANT left, right, exp, result, cy, dec;
7988     BSTR true_str, false_str;
7989     VARTYPE i;
7990     HRESULT hres;
7991
7992     CHECKPTR(VarImp);
7993
7994     true_str = SysAllocString(szTrue);
7995     false_str = SysAllocString(szFalse);
7996
7997     /* Test all possible flag/vt combinations & the resulting vt type */
7998     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7999     {
8000         VARTYPE leftvt, rightvt, resvt;
8001
8002         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8003         {
8004             SKIPTESTIMP(leftvt);
8005
8006             /* Check if we need/have support for I8 and/or UI8 */
8007             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8008                 continue;
8009
8010             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8011             {
8012                 BOOL bFail = FALSE;
8013                 SKIPTESTIMP(rightvt);
8014
8015                 /* Native crashes when using the extra flag VT_BYREF
8016                  * or with the following VT combinations
8017                  */
8018                 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
8019                     (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
8020                     ExtraFlags[i] == VT_BYREF)
8021                     continue;
8022
8023                 /* Check if we need/have support for I8 and/or UI8 */
8024                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8025                     continue;
8026
8027                 memset(&left, 0, sizeof(left));
8028                 memset(&right, 0, sizeof(right));
8029                 V_VT(&left) = leftvt | ExtraFlags[i];
8030                 V_VT(&right) = rightvt | ExtraFlags[i];
8031                 V_VT(&result) = VT_EMPTY;
8032                 resvt = VT_EMPTY;
8033
8034                 if (leftvt == VT_BSTR)
8035                     V_BSTR(&left) = true_str;
8036
8037                 /* This allows us to test return types that are not NULL
8038                  * (NULL Imp value = n, NULL Imp 0 = NULL)
8039                  */
8040                 switch(rightvt)
8041                 {
8042                 case VT_BSTR:
8043                     V_BSTR(&right) = true_str;
8044                     break;
8045                 case VT_DECIMAL:
8046                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8047                     V_VT(&right) = rightvt | ExtraFlags[i];
8048                     break;
8049                 case VT_BOOL:
8050                     V_BOOL(&right) = VARIANT_TRUE;
8051                     break;
8052                 case VT_I1: V_I1(&right) = 2; break;
8053                 case VT_I2: V_I2(&right) = 2; break;
8054                 case VT_I4: V_I4(&right) = 2; break;
8055                 case VT_R4: V_R4(&right) = 2.0f; break;
8056                 case VT_R8: V_R8(&right) = 2.0; break;
8057                 case VT_CY: V_CY(&right).int64 = 10000; break;
8058                 case VT_DATE: V_DATE(&right) = 2; break;
8059                 case VT_I8: V_I8(&right) = 2; break;
8060                 case VT_INT: V_INT(&right) = 2; break;
8061                 case VT_UINT: V_UINT(&right) = 2; break;
8062                 case VT_UI1: V_UI1(&right) = 2; break;
8063                 case VT_UI2: V_UI2(&right) = 2; break;
8064                 case VT_UI4: V_UI4(&right) = 2; break;
8065                 case VT_UI8: V_UI8(&right) = 2; break;
8066                 default: break;
8067                 }
8068
8069                 /* Native VarImp always returns an error when using extra
8070                  * flags or if the variants are I8 and INT.
8071                  */
8072                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8073                     ExtraFlags[i] != 0)
8074                     bFail = TRUE;
8075
8076                 /* Determine result type */
8077                 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
8078                     (leftvt == VT_NULL && rightvt == VT_NULL) ||
8079                     (leftvt == VT_NULL && rightvt == VT_EMPTY))
8080                     resvt = VT_NULL;
8081                 else if (leftvt == VT_I8 || rightvt == VT_I8)
8082                     resvt = VT_I8;
8083                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8084                     leftvt == VT_INT || rightvt == VT_INT ||
8085                     leftvt == VT_UINT || rightvt == VT_UINT ||
8086                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
8087                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
8088                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
8089                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8090                     leftvt == VT_DATE || rightvt == VT_DATE ||
8091                     leftvt == VT_CY || rightvt == VT_CY ||
8092                     leftvt == VT_R8 || rightvt == VT_R8 ||
8093                     leftvt == VT_R4 || rightvt == VT_R4 ||
8094                     leftvt == VT_I1 || rightvt == VT_I1)
8095                     resvt = VT_I4;
8096                 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
8097                     (leftvt == VT_UI1 && rightvt == VT_NULL) ||
8098                     (leftvt == VT_NULL && rightvt == VT_UI1))
8099                     resvt = VT_UI1;
8100                 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
8101                     leftvt == VT_I2 || rightvt == VT_I2 ||
8102                     leftvt == VT_UI1 || rightvt == VT_UI1)
8103                     resvt = VT_I2;
8104                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
8105                     leftvt == VT_BSTR || rightvt == VT_BSTR)
8106                     resvt = VT_BOOL;
8107
8108                 hres = pVarImp(&left, &right, &result);
8109
8110                 /* Check expected HRESULT and if result variant type is correct */
8111                 if (bFail)
8112                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
8113                         "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
8114                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
8115                         vtstr(V_VT(&result)), hres);
8116                 else
8117                     ok (hres == S_OK && resvt == V_VT(&result),
8118                         "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
8119                         vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
8120                         S_OK, vtstr(V_VT(&result)), hres);
8121             }
8122         }
8123     }
8124
8125     VARIMP(EMPTY,0,EMPTY,0,I2,-1);
8126     VARIMP(EMPTY,0,NULL,0,I2,-1);
8127     VARIMP(EMPTY,0,I2,-1,I2,-1);
8128     VARIMP(EMPTY,0,I4,-1,I4,-1);
8129     VARIMP(EMPTY,0,R4,0.0f,I4,-1);
8130     VARIMP(EMPTY,0,R8,-1.0,I4,-1);
8131     VARIMP(EMPTY,0,DATE,0,I4,-1);
8132     VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
8133     VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
8134     VARIMP(EMPTY,0,I1,0,I4,-1);
8135     VARIMP(EMPTY,0,UI1,1,I2,-1);
8136     VARIMP(EMPTY,0,UI2,1,I4,-1);
8137     VARIMP(EMPTY,0,UI4,1,I4,-1);
8138     if (HAVE_OLEAUT32_I8)
8139     {
8140         VARIMP(EMPTY,0,I8,1,I8,-1);
8141         VARIMP(EMPTY,0,UI8,1,I4,-1);
8142     }
8143     VARIMP(EMPTY,0,INT,-1,I4,-1);
8144     VARIMP(EMPTY,0,UINT,1,I4,-1);
8145     VARIMP(NULL,0,EMPTY,0,NULL,0);
8146     VARIMP(NULL,0,NULL,0,NULL,0);
8147     VARIMP(NULL,0,I2,-1,I2,-1);
8148     VARIMP(NULL,0,I4,-1,I4,-1);
8149     VARIMP(NULL,0,R4,0.0f,NULL,0);
8150     VARIMP(NULL,0,R8,-1.0,I4,-1);
8151     VARIMP(NULL,0,DATE,0,NULL,0);
8152     VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
8153     VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
8154     VARIMP(NULL,0,I1,0,NULL,0);
8155     VARIMP(NULL,0,UI1,1,UI1,1);
8156     VARIMP(NULL,0,UI2,1,I4,1);
8157     VARIMP(NULL,0,UI4,1,I4,1);
8158     if (HAVE_OLEAUT32_I8)
8159     {
8160         VARIMP(NULL,0,I8,1,I8,1);
8161         VARIMP(NULL,0,UI8,1,I4,1);
8162     }
8163     VARIMP(NULL,0,INT,-1,I4,-1);
8164     VARIMP(NULL,0,UINT,1,I4,1);
8165     VARIMP(I2,-1,EMPTY,0,I2,0);
8166     VARIMP(I2,-1,I2,-1,I2,-1);
8167     VARIMP(I2,-1,I4,-1,I4,-1);
8168     VARIMP(I2,-1,R4,0.0f,I4,0);
8169     VARIMP(I2,-1,R8,-1.0,I4,-1);
8170     VARIMP(I2,-1,DATE,0,I4,0);
8171     VARIMP(I2,-1,BSTR,true_str,I2,-1);
8172     VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
8173     VARIMP(I2,-1,I1,0,I4,0);
8174     VARIMP(I2,-1,UI1,1,I2,1);
8175     VARIMP(I2,-1,UI2,1,I4,1);
8176     VARIMP(I2,-1,UI4,1,I4,1);
8177     if (HAVE_OLEAUT32_I8)
8178     {
8179         VARIMP(I2,-1,I8,1,I8,1);
8180         VARIMP(I2,-1,UI8,1,I4,1);
8181     }
8182     VARIMP(I2,-1,INT,-1,I4,-1);
8183     VARIMP(I2,-1,UINT,1,I4,1);
8184     VARIMP(I4,2,EMPTY,0,I4,-3);
8185     VARIMP(I4,2,NULL,0,I4,-3);
8186     VARIMP(I4,2,I2,-1,I4,-1);
8187     VARIMP(I4,2,I4,-1,I4,-1);
8188     VARIMP(I4,2,R4,0.0f,I4,-3);
8189     VARIMP(I4,2,R8,-1.0,I4,-1);
8190     VARIMP(I4,2,DATE,0,I4,-3);
8191     VARIMP(I4,2,BSTR,true_str,I4,-1);
8192     VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
8193     VARIMP(I4,2,I1,0,I4,-3);
8194     VARIMP(I4,2,UI1,1,I4,-3);
8195     VARIMP(I4,2,UI2,1,I4,-3);
8196     VARIMP(I4,2,UI4,1,I4,-3);
8197     if (HAVE_OLEAUT32_I8)
8198     {
8199         VARIMP(I4,2,I8,1,I8,-3);
8200         VARIMP(I4,2,UI8,1,I4,-3);
8201     }
8202     VARIMP(I4,2,INT,-1,I4,-1);
8203     VARIMP(I4,2,UINT,1,I4,-3);
8204     VARIMP(R4,-1.0f,EMPTY,0,I4,0);
8205     VARIMP(R4,-1.0f,NULL,0,NULL,0);
8206     VARIMP(R4,-1.0f,I2,-1,I4,-1);
8207     VARIMP(R4,-1.0f,I4,-1,I4,-1);
8208     VARIMP(R4,-1.0f,R4,0.0f,I4,0);
8209     VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
8210     VARIMP(R4,-1.0f,DATE,1,I4,1);
8211     VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
8212     VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
8213     VARIMP(R4,-1.0f,I1,0,I4,0);
8214     VARIMP(R4,-1.0f,UI1,1,I4,1);
8215     VARIMP(R4,-1.0f,UI2,1,I4,1);
8216     VARIMP(R4,-1.0f,UI4,1,I4,1);
8217     if (HAVE_OLEAUT32_I8)
8218     {
8219         VARIMP(R4,-1.0f,I8,1,I8,1);
8220         VARIMP(R4,-1.0f,UI8,1,I4,1);
8221     }
8222     VARIMP(R4,-1.0f,INT,-1,I4,-1);
8223     VARIMP(R4,-1.0f,UINT,1,I4,1);
8224     VARIMP(R8,1.0,EMPTY,0,I4,-2);
8225     VARIMP(R8,1.0,NULL,0,I4,-2);
8226     VARIMP(R8,1.0,I2,-1,I4,-1);
8227     VARIMP(R8,1.0,I4,-1,I4,-1);
8228     VARIMP(R8,1.0,R4,0.0f,I4,-2);
8229     VARIMP(R8,1.0,R8,-1.0,I4,-1);
8230     VARIMP(R8,1.0,DATE,0,I4,-2);
8231     VARIMP(R8,1.0,BSTR,true_str,I4,-1);
8232     VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
8233     VARIMP(R8,1.0,I1,0,I4,-2);
8234     VARIMP(R8,1.0,UI1,1,I4,-1);
8235     VARIMP(R8,1.0,UI2,1,I4,-1);
8236     VARIMP(R8,1.0,UI4,1,I4,-1);
8237     if (HAVE_OLEAUT32_I8)
8238     {
8239         VARIMP(R8,1.0,I8,1,I8,-1);
8240         VARIMP(R8,1.0,UI8,1,I4,-1);
8241     }
8242     VARIMP(R8,1.0,INT,-1,I4,-1);
8243     VARIMP(R8,1.0,UINT,1,I4,-1);
8244     VARIMP(DATE,0,EMPTY,0,I4,-1);
8245     VARIMP(DATE,0,NULL,0,I4,-1);
8246     VARIMP(DATE,0,I2,-1,I4,-1);
8247     VARIMP(DATE,0,I4,-1,I4,-1);
8248     VARIMP(DATE,0,R4,0.0f,I4,-1);
8249     VARIMP(DATE,0,R8,-1.0,I4,-1);
8250     VARIMP(DATE,0,DATE,0,I4,-1);
8251     VARIMP(DATE,0,BSTR,true_str,I4,-1);
8252     VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
8253     VARIMP(DATE,0,I1,0,I4,-1);
8254     VARIMP(DATE,0,UI1,1,I4,-1);
8255     VARIMP(DATE,0,UI2,1,I4,-1);
8256     VARIMP(DATE,0,UI4,1,I4,-1);
8257     if (HAVE_OLEAUT32_I8)
8258     {
8259         VARIMP(DATE,0,I8,1,I8,-1);
8260         VARIMP(DATE,0,UI8,1,I4,-1);
8261     }
8262     VARIMP(DATE,0,INT,-1,I4,-1);
8263     VARIMP(DATE,0,UINT,1,I4,-1);
8264     VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
8265     VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
8266     VARIMP(BSTR,false_str,I2,-1,I2,-1);
8267     VARIMP(BSTR,false_str,I4,-1,I4,-1);
8268     VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
8269     VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
8270     VARIMP(BSTR,false_str,DATE,0,I4,-1);
8271     VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
8272     VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
8273     VARIMP(BSTR,false_str,I1,0,I4,-1);
8274     VARIMP(BSTR,false_str,UI1,1,I2,-1);
8275     VARIMP(BSTR,false_str,UI2,1,I4,-1);
8276     VARIMP(BSTR,false_str,UI4,1,I4,-1);
8277     if (HAVE_OLEAUT32_I8)
8278     {
8279         VARIMP(BSTR,false_str,I8,1,I8,-1);
8280         VARIMP(BSTR,false_str,UI8,1,I4,-1);
8281     }
8282     VARIMP(BSTR,false_str,INT,-1,I4,-1);
8283     VARIMP(BSTR,false_str,UINT,1,I4,-1);
8284     VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
8285     VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8286     VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
8287     VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
8288     VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
8289     VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
8290     VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
8291     VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
8292     VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
8293     VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
8294     VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
8295     VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
8296     VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
8297     if (HAVE_OLEAUT32_I8)
8298     {
8299         VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
8300         VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
8301     }
8302     VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
8303     VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
8304     VARIMP(I1,-1,EMPTY,0,I4,0);
8305     VARIMP(I1,-1,NULL,0,NULL,0);
8306     VARIMP(I1,-1,I2,-1,I4,-1);
8307     VARIMP(I1,-1,I4,-1,I4,-1);
8308     VARIMP(I1,-1,R4,0.0f,I4,0);
8309     VARIMP(I1,-1,R8,-1.0,I4,-1);
8310     VARIMP(I1,-1,DATE,0,I4,0);
8311     VARIMP(I1,-1,BSTR,true_str,I4,-1);
8312     VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
8313     VARIMP(I1,-1,I1,0,I4,0);
8314     VARIMP(I1,-1,UI1,1,I4,1);
8315     VARIMP(I1,-1,UI2,1,I4,1);
8316     VARIMP(I1,-1,UI4,1,I4,1);
8317     if (HAVE_OLEAUT32_I8)
8318     {
8319         VARIMP(I1,-1,I8,1,I8,1);
8320         VARIMP(I1,-1,UI8,1,I4,1);
8321     }
8322     VARIMP(I1,-1,INT,-1,I4,-1);
8323     VARIMP(I1,-1,UINT,1,I4,1);
8324     VARIMP(UI1,0,EMPTY,0,I2,-1);
8325     VARIMP(UI1,0,NULL,0,UI1,255);
8326     VARIMP(UI1,0,I2,-1,I2,-1);
8327     VARIMP(UI1,0,I4,-1,I4,-1);
8328     VARIMP(UI1,0,R4,0.0f,I4,-1);
8329     VARIMP(UI1,0,R8,-1.0,I4,-1);
8330     VARIMP(UI1,0,DATE,0,I4,-1);
8331     VARIMP(UI1,0,BSTR,true_str,I2,-1);
8332     VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
8333     VARIMP(UI1,0,I1,0,I4,-1);
8334     VARIMP(UI1,0,UI1,1,UI1,255);
8335     VARIMP(UI1,0,UI2,1,I4,-1);
8336     VARIMP(UI1,0,UI4,1,I4,-1);
8337     if (HAVE_OLEAUT32_I8)
8338     {
8339         VARIMP(UI1,0,I8,1,I8,-1);
8340         VARIMP(UI1,0,UI8,1,I4,-1);
8341     }
8342     VARIMP(UI1,0,INT,-1,I4,-1);
8343     VARIMP(UI1,0,UINT,1,I4,-1);
8344     VARIMP(UI2,0,EMPTY,0,I4,-1);
8345     VARIMP(UI2,0,NULL,0,I4,-1);
8346     VARIMP(UI2,0,I2,-1,I4,-1);
8347     VARIMP(UI2,0,I4,-1,I4,-1);
8348     VARIMP(UI2,0,R4,0.0f,I4,-1);
8349     VARIMP(UI2,0,R8,-1.0,I4,-1);
8350     VARIMP(UI2,0,DATE,0,I4,-1);
8351     VARIMP(UI2,0,BSTR,true_str,I4,-1);
8352     VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
8353     VARIMP(UI2,0,I1,0,I4,-1);
8354     VARIMP(UI2,0,UI1,1,I4,-1);
8355     VARIMP(UI2,0,UI2,1,I4,-1);
8356     VARIMP(UI2,0,UI4,1,I4,-1);
8357     if (HAVE_OLEAUT32_I8)
8358     {
8359         VARIMP(UI2,0,I8,1,I8,-1);
8360         VARIMP(UI2,0,UI8,1,I4,-1);
8361     }
8362     VARIMP(UI2,0,INT,-1,I4,-1);
8363     VARIMP(UI2,0,UINT,1,I4,-1);
8364     VARIMP(UI4,0,EMPTY,0,I4,-1);
8365     VARIMP(UI4,0,NULL,0,I4,-1);
8366     VARIMP(UI4,0,I2,-1,I4,-1);
8367     VARIMP(UI4,0,I4,-1,I4,-1);
8368     VARIMP(UI4,0,R4,0.0f,I4,-1);
8369     VARIMP(UI4,0,R8,-1.0,I4,-1);
8370     VARIMP(UI4,0,DATE,0,I4,-1);
8371     VARIMP(UI4,0,BSTR,true_str,I4,-1);
8372     VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
8373     VARIMP(UI4,0,I1,0,I4,-1);
8374     VARIMP(UI4,0,UI1,1,I4,-1);
8375     VARIMP(UI4,0,UI2,1,I4,-1);
8376     VARIMP(UI4,0,UI4,1,I4,-1);
8377     if (HAVE_OLEAUT32_I8)
8378     {
8379         VARIMP(UI4,0,I8,1,I8,-1);
8380         VARIMP(UI4,0,UI8,1,I4,-1);
8381     }
8382     VARIMP(UI4,0,INT,-1,I4,-1);
8383     VARIMP(UI4,0,UINT,1,I4,-1);
8384     if (HAVE_OLEAUT32_I8)
8385     {
8386         VARIMP(I8,-1,EMPTY,0,I8,0);
8387         VARIMP(I8,-1,NULL,0,NULL,0);
8388         VARIMP(I8,-1,I2,-1,I8,-1);
8389         VARIMP(I8,-1,I4,-1,I8,-1);
8390         VARIMP(I8,-1,R4,0.0f,I8,0);
8391         VARIMP(I8,-1,R8,-1.0,I8,-1);
8392         VARIMP(I8,-1,DATE,0,I8,0);
8393         VARIMP(I8,-1,BSTR,true_str,I8,-1);
8394         VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
8395         VARIMP(I8,-1,I1,0,I8,0);
8396         VARIMP(I8,-1,UI1,1,I8,1);
8397         VARIMP(I8,-1,UI2,1,I8,1);
8398         VARIMP(I8,-1,UI4,1,I8,1);
8399         VARIMP(I8,-1,I8,1,I8,1);
8400         VARIMP(I8,-1,UI8,1,I8,1);
8401         VARIMP(I8,-1,UINT,1,I8,1);
8402         VARIMP(UI8,0,EMPTY,0,I4,-1);
8403         VARIMP(UI8,0,NULL,0,I4,-1);
8404         VARIMP(UI8,0,I2,-1,I4,-1);
8405         VARIMP(UI8,0,I4,-1,I4,-1);
8406         VARIMP(UI8,0,R4,0.0f,I4,-1);
8407         VARIMP(UI8,0,R8,-1.0,I4,-1);
8408         VARIMP(UI8,0,DATE,0,I4,-1);
8409         VARIMP(UI8,0,BSTR,true_str,I4,-1);
8410         VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
8411         VARIMP(UI8,0,I1,0,I4,-1);
8412         VARIMP(UI8,0,UI1,1,I4,-1);
8413         VARIMP(UI8,0,UI2,1,I4,-1);
8414         VARIMP(UI8,0,UI4,1,I4,-1);
8415         VARIMP(UI8,0,I8,1,I8,-1);
8416         VARIMP(UI8,0,UI8,1,I4,-1);
8417         VARIMP(UI8,0,INT,-1,I4,-1);
8418         VARIMP(UI8,0,UINT,1,I4,-1);
8419     }
8420     VARIMP(INT,-1,EMPTY,0,I4,0);
8421     VARIMP(INT,-1,NULL,0,NULL,0);
8422     VARIMP(INT,-1,I2,-1,I4,-1);
8423     VARIMP(INT,-1,I4,-1,I4,-1);
8424     VARIMP(INT,-1,R4,0.0f,I4,0);
8425     VARIMP(INT,-1,R8,-1.0,I4,-1);
8426     VARIMP(INT,-1,DATE,0,I4,0);
8427     VARIMP(INT,-1,BSTR,true_str,I4,-1);
8428     VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
8429     VARIMP(INT,-1,I1,0,I4,0);
8430     VARIMP(INT,-1,UI1,1,I4,1);
8431     VARIMP(INT,-1,UI2,1,I4,1);
8432     VARIMP(INT,-1,UI4,1,I4,1);
8433     if (HAVE_OLEAUT32_I8)
8434     {
8435         VARIMP(INT,-1,I8,1,I8,1);
8436         VARIMP(INT,-1,UI8,1,I4,1);
8437     }
8438     VARIMP(INT,-1,INT,-1,I4,-1);
8439     VARIMP(INT,-1,UINT,1,I4,1);
8440     VARIMP(UINT,1,EMPTY,0,I4,-2);
8441     VARIMP(UINT,1,NULL,0,I4,-2);
8442     VARIMP(UINT,1,I2,-1,I4,-1);
8443     VARIMP(UINT,1,I4,-1,I4,-1);
8444     VARIMP(UINT,1,R4,0.0f,I4,-2);
8445     VARIMP(UINT,1,R8,-1.0,I4,-1);
8446     VARIMP(UINT,1,DATE,0,I4,-2);
8447     VARIMP(UINT,1,BSTR,true_str,I4,-1);
8448     VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
8449     VARIMP(UINT,1,I1,0,I4,-2);
8450     VARIMP(UINT,1,UI1,1,I4,-1);
8451     VARIMP(UINT,1,UI2,1,I4,-1);
8452     VARIMP(UINT,1,UI4,1,I4,-1);
8453     if (HAVE_OLEAUT32_I8)
8454     {
8455         VARIMP(UINT,1,I8,1,I8,-1);
8456         VARIMP(UINT,1,UI8,1,I4,-1);
8457     }
8458     VARIMP(UINT,1,INT,-1,I4,-1);
8459     VARIMP(UINT,1,UINT,1,I4,-1);
8460
8461     /* Manually test some VT_CY, VT_DECIMAL variants */
8462     V_VT(&cy) = VT_CY;
8463     hres = VarCyFromI4(1, &V_CY(&cy));
8464     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8465     V_VT(&dec) = VT_DECIMAL;
8466     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8467     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8468     memset(&left, 0, sizeof(left));
8469     memset(&right, 0, sizeof(right));
8470     V_VT(&left) = VT_I4;
8471     V_I4(&left) = 0;
8472     V_VT(&right) = VT_I8;
8473     V_UI1(&right) = 0;
8474
8475     hres = pVarImp(&cy, &cy, &result);
8476     ok(hres == S_OK && V_VT(&result) == VT_I4,
8477         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8478         S_OK, hres, vtstr(V_VT(&result)));
8479     ok(hres == S_OK && V_I4(&result) == -1,
8480         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8481
8482     if (HAVE_OLEAUT32_I8)
8483     {
8484         hres = pVarImp(&cy, &right, &result);
8485         ok(hres == S_OK && V_VT(&result) == VT_I8,
8486             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8487             S_OK, hres, vtstr(V_VT(&result)));
8488         ok(hres == S_OK && V_I8(&result) == -2,
8489             "VARIMP: CY value %x%08x, expected %d\n",
8490             (DWORD)((V_I8(&result)) >> 32), (DWORD)(V_I8(&result)), -2);
8491     }
8492
8493     hres = pVarImp(&left, &cy, &result);
8494     ok(hres == S_OK && V_VT(&result) == VT_I4,
8495         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8496         S_OK, hres, vtstr(V_VT(&result)));
8497     ok(hres == S_OK && V_I4(&result) == -1,
8498         "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8499
8500     hres = pVarImp(&left, &dec, &result);
8501     ok(hres == S_OK && V_VT(&result) == VT_I4,
8502         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8503         S_OK, hres, vtstr(V_VT(&result)));
8504     ok(hres == S_OK && V_I4(&result) == -1,
8505         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8506
8507     hres = pVarImp(&dec, &dec, &result);
8508     ok(hres == S_OK && V_VT(&result) == VT_I4,
8509         "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8510         S_OK, hres, vtstr(V_VT(&result)));
8511     ok(hres == S_OK && V_I4(&result) == -1,
8512         "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8513
8514     if (HAVE_OLEAUT32_I8)
8515     {
8516         hres = pVarImp(&dec, &right, &result);
8517         ok(hres == S_OK && V_VT(&result) == VT_I8,
8518             "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8519             S_OK, hres, vtstr(V_VT(&result)));
8520         ok(hres == S_OK && V_I8(&result) == -3,
8521             "VARIMP: DECIMAL value 0x%x%08x, expected %d\n",
8522             (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), -3);
8523     }
8524
8525     SysFreeString(false_str);
8526     SysFreeString(true_str);
8527 }
8528
8529 START_TEST(vartest)
8530 {
8531   init();
8532
8533   test_VariantInit();
8534   test_VariantClear();
8535   test_VariantCopy();
8536   test_VariantCopyInd();
8537   test_VarParseNumFromStr();
8538   test_VarNumFromParseNum();
8539   test_VarUdateFromDate();
8540   test_VarDateFromUdate();
8541   test_SystemTimeToVariantTime();
8542   test_VariantTimeToSystemTime();
8543   test_DosDateTimeToVariantTime();
8544   test_VariantTimeToDosDateTime();
8545   test_VarAbs();
8546   test_VarNot();
8547   test_VarSub();
8548   test_VarMod();
8549   test_VarFix();
8550   test_VarInt();
8551   test_VarNeg();
8552   test_VarRound();
8553   test_VarXor();
8554   test_VarOr();
8555   test_VarPow();
8556   test_VarEqv();
8557   test_VarMul();
8558   test_VarAdd();
8559   test_VarCat();
8560   test_VarCmp();
8561   test_VarAnd();
8562   test_VarDiv();
8563   test_VarIdiv();
8564   test_VarImp();
8565 }