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

   1 /*
   2  * VARIANT test program
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <math.h>
  24 #include <float.h>
  25 #include <time.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winsock.h"
  30 #include "wine/test.h"
  31 #include "winuser.h"
  32 #include "wingdi.h"
  33 #include "winnls.h"
  34 #include "winerror.h"
  35 #include "winnt.h"
  36
  37 #include "wtypes.h"
  38 #include "oleauto.h"
  39
  40 static HMODULE hOleaut32;
  41
  42 static HRESULT (WINAPI *pVarUdateFromDate)(DATE,ULONG,UDATE*);
  43 static HRESULT (WINAPI *pVarDateFromUdate)(UDATE*,ULONG,DATE*);
  44 static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
  45 static INT (WINAPI *pVariantTimeToSystemTime)(double,LPSYSTEMTIME);
  46 static INT (WINAPI *pDosDateTimeToVariantTime)(USHORT,USHORT,double*);
  47 static INT (WINAPI *pVariantTimeToDosDateTime)(double,USHORT*,USHORT *);
  48 static HRESULT (WINAPI *pVarFormatNumber)(LPVARIANT,int,int,int,int,ULONG,BSTR*);
  49 static HRESULT (WINAPI *pVarFormat)(LPVARIANT,LPOLESTR,int,int,ULONG,BSTR*);
  50
  51 /* Get a conversion function ptr, return if function not available */
  52 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
  53   if (!p##func) { trace("function " # func " not available, not testing it\n"); return; }
  54
  55   /* Is a given function exported from oleaut32? */
  56 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
  57
  58 /* Have IRecordInfo data type? */
  59 #define HAVE_OLEAUT32_RECORD  HAVE_FUNC(SafeArraySetRecordInfo)
  60 /* Have CY data type? */
  61 #define HAVE_OLEAUT32_CY      HAVE_FUNC(VarCyAdd)
  62 /* Have I8/UI8 data type? */
  63 #define HAVE_OLEAUT32_I8      HAVE_FUNC(VarI8FromI1)
  64 /* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
  65 #define IS_ANCIENT (!HAVE_FUNC(VarI1FromI2))
  66
  67 /* When comparing floating point values we cannot expect an exact match
  68  * because the rounding errors depend on the exact algorithm.
  69  */
  70 #define EQ_DOUBLE(a,b)     (fabs((a)-(b))<1e-14)
  71 #define EQ_FLOAT(a,b)      (fabs((a)-(b))<1e-7)
  72
  73 #define SKIPTESTS(a)  if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue;
  74
  75 /* Allow our test macros to work for VT_NULL and VT_EMPTY too */
  76 #define V_EMPTY(v) V_I4(v)
  77 #define V_NULL(v) V_I4(v)
  78
  79 /* Size constraints for overflow tests */
  80 #define I1_MAX   0x7f
  81 #define I1_MIN   ((-I1_MAX)-1)
  82 #define UI1_MAX  0xff
  83 #define UI1_MIN  0
  84 #define I2_MAX   0x7fff
  85 #define I2_MIN   ((-I2_MAX)-1)
  86 #define UI2_MAX  0xffff
  87 #define UI2_MIN  0
  88 #define I4_MAX   0x7fffffff
  89 #define I4_MIN   ((-I4_MAX)-1)
  90 #define UI4_MAX  0xffffffff
  91 #define UI4_MIN  0
  92 #define I8_MAX   (((LONGLONG)I4_MAX << 32) | UI4_MAX)
  93 #define I8_MIN   ((-I8_MAX)-1)
  94 #define UI8_MAX  (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
  95 #define UI8_MIN  0
  96 #define DATE_MAX 2958465
  97 #define DATE_MIN -657434
  98 #define R4_MAX FLT_MAX
  99 #define R4_MIN FLT_MIN
 100 #define R8_MAX DBL_MAX
 101 #define R8_MIN DBL_MIN
 102
 103 /* Macros to set a DECIMAL */
 104 #define SETDEC(dec, scl, sgn, hi, lo) S(U(dec)).scale = (BYTE)scl; \
 105         S(U(dec)).sign = (BYTE)sgn; dec.Hi32 = (ULONG)hi; \
 106         U1(dec).Lo64 = (ULONG64)lo
 107 #define SETDEC64(dec, scl, sgn, hi, mid, lo) S(U(dec)).scale = (BYTE)scl; \
 108         S(U(dec)).sign = (BYTE)sgn; dec.Hi32 = (ULONG)hi; \
 109         S1(U1(dec)).Mid32 = mid; S1(U1(dec)).Lo32 = lo;
 110
 111 static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
 112 {
 113     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 114     return *str1 - *str2;
 115 }
 116
 117 /* return the string text of a given variant type */
 118 static const char *vtstr(int x)
 119 {
 120         switch(x) {
 121         case 0:
 122                 return "VT_EMPTY";
 123         case 1:
 124                 return "VT_NULL";
 125         case 2:
 126                 return "VT_I2";
 127         case 3:
 128                 return "VT_I4";
 129         case 4:
 130                 return "VT_R4";
 131         case 5:
 132                 return "VT_R8";
 133         case 6:
 134                 return "VT_CY";
 135         case 7:
 136                 return "VT_DATE";
 137         case 8:
 138                 return "VT_BSTR";
 139         case 9:
 140                 return "VT_DISPATCH";
 141         case 10:
 142                 return "VT_ERROR";
 143         case 11:
 144                 return "VT_BOOL";
 145         case 12:
 146                 return "VT_VARIANT";
 147         case 13:
 148                 return "VT_UNKNOWN";
 149         case 14:
 150                 return "VT_DECIMAL";
 151         case 15:
 152                 return "notdefined";
 153         case 16:
 154                 return "VT_I1";
 155         case 17:
 156                 return "VT_UI1";
 157         case 18:
 158                 return "VT_UI2";
 159         case 19:
 160                 return "VT_UI4";
 161         case 20:
 162                 return "VT_I8";
 163         case 21:
 164                 return "VT_UI8";
 165         case 22:
 166                 return "VT_INT";
 167         case 23:
 168                 return "VT_UINT";
 169         case 24:
 170                 return "VT_VOID";
 171         case 25:
 172                 return "VT_HRESULT";
 173         case 26:
 174                 return "VT_PTR";
 175         case 27:
 176                 return "VT_SAFEARRAY";
 177         case 28:
 178                 return "VT_CARRAY";
 179         case 29:
 180                 return "VT_USERDEFINED";
 181         case 30:
 182                 return "VT_LPSTR";
 183         case 31:
 184                 return "VT_LPWSTR";
 185         case 36:
 186                 return "VT_RECORD";
 187         case 64:
 188                 return "VT_FILETIME";
 189         case 65:
 190                 return "VT_BLOB";
 191         case 66:
 192                 return "VT_STREAM";
 193         case 67:
 194                 return "VT_STORAGE";
 195         case 68:
 196                 return "VT_STREAMED_OBJECT";
 197         case 69:
 198                 return "VT_STORED_OBJECT";
 199         case 70:
 200                 return "VT_BLOB_OBJECT";
 201         case 71:
 202                 return "VT_CF";
 203         case 72:
 204                 return "VT_CLSID";
 205         case 0xFFF:
 206                 return "VT_BSTR_BLOB/VT_ILLEGALMASKED/VT_TYPEMASK";
 207         case 0x1000:
 208                 return "VT_VECTOR";
 209         case 0x2000:
 210                 return "VT_ARRAY";
 211         case 0x4000:
 212                 return "VT_BYREF";
 213         case 0x8000:
 214                 return "VT_BYREF";
 215         case 0xFFFF:
 216                 return "VT_ILLEGAL";
 217
 218         default:
 219                 return "defineme";
 220         }
 221 }
 222
 223 static void test_VariantInit(void)
 224 {
 225   VARIANTARG v1, v2;
 226
 227   /* Test that VariantInit() only sets the type */
 228   memset(&v1, -1, sizeof(v1));
 229   v2 = v1;
 230   V_VT(&v2) = VT_EMPTY;
 231   VariantInit(&v1);
 232   ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
 233 }
 234
 235 /* All possible combinations of extra V_VT() flags */
 236 static const VARTYPE ExtraFlags[16] =
 237 {
 238   0,
 239   VT_VECTOR,
 240   VT_ARRAY,
 241   VT_BYREF,
 242   VT_RESERVED,
 243   VT_VECTOR|VT_ARRAY,
 244   VT_VECTOR|VT_BYREF,
 245   VT_VECTOR|VT_RESERVED,
 246   VT_VECTOR|VT_ARRAY|VT_BYREF,
 247   VT_VECTOR|VT_ARRAY|VT_RESERVED,
 248   VT_VECTOR|VT_BYREF|VT_RESERVED,
 249   VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
 250   VT_ARRAY|VT_BYREF,
 251   VT_ARRAY|VT_RESERVED,
 252   VT_ARRAY|VT_BYREF|VT_RESERVED,
 253   VT_BYREF|VT_RESERVED,
 254 };
 255
 256 /* Determine if a vt is valid for VariantClear() */
 257 static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
 258 {
 259   int ret = 0;
 260
 261   /* Only the following flags/types are valid */
 262   if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
 263       vt != (VARTYPE)15 &&
 264       (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
 265       (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
 266       (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
 267        extraFlags == (VT_ARRAY|VT_BYREF)))
 268     ret = 1; /* ok */
 269
 270   if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
 271       ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
 272     ret = 0; /* Old versions of oleaut32 */
 273   return ret;
 274 }
 275
 276 typedef struct
 277 {
 278     const IUnknownVtbl *lpVtbl;
 279     LONG               ref;
 280     LONG               events;
 281 } test_VariantClearImpl;
 282
 283 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
 284 {
 285     test_VariantClearImpl *This = (test_VariantClearImpl *)iface;
 286     This->events |= 0x1;
 287     return E_NOINTERFACE;
 288 }
 289
 290 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
 291     test_VariantClearImpl *This = (test_VariantClearImpl *)iface;
 292     This->events |= 0x2;
 293     return InterlockedIncrement(&This->ref);
 294 }
 295
 296 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
 297     test_VariantClearImpl *This = (test_VariantClearImpl *)iface;
 298     /* static class, won't be  freed */
 299     This->events |= 0x4;
 300     return InterlockedDecrement(&This->ref);
 301 }
 302
 303 static const IUnknownVtbl test_VariantClear_vtbl = {
 304     VC_QueryInterface,
 305     VC_AddRef,
 306     VC_Release,
 307 };
 308
 309 static test_VariantClearImpl test_myVariantClearImpl = {&test_VariantClear_vtbl, 1, 0};
 310
 311 static void test_VariantClear(void)
 312 {
 313   HRESULT hres;
 314   VARIANTARG v;
 315   VARIANT v2;
 316   size_t i;
 317   LONG i4;
 318   IUnknown *punk;
 319
 320 #if 0
 321   /* Crashes: Native does not test input for NULL, so neither does Wine */
 322   hres = VariantClear(NULL);
 323 #endif
 324
 325   /* Only the type field is set, to VT_EMPTY */
 326   V_VT(&v) = VT_UI4;
 327   V_UI4(&v) = ~0u;
 328   hres = VariantClear(&v);
 329   ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
 330      (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
 331      "VariantClear: Type set to %d, res %08lx\n", V_VT(&v), hres);
 332   ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
 333
 334   /* Test all possible V_VT values.
 335    * Also demonstrates that null pointers in 'v' are not dereferenced.
 336    * Individual variant tests should test VariantClear() with non-NULL values.
 337    */
 338   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 339   {
 340     VARTYPE vt;
 341
 342     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 343     {
 344       HRESULT hExpected = DISP_E_BADVARTYPE;
 345
 346       SKIPTESTS(vt);
 347
 348       memset(&v, 0, sizeof(v));
 349       V_VT(&v) = vt | ExtraFlags[i];
 350
 351       hres = VariantClear(&v);
 352
 353       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 354         hExpected = S_OK;
 355
 356       ok(hres == hExpected, "VariantClear: expected 0x%lX, got 0x%lX for vt %d | 0x%X\n",
 357          hExpected, hres, vt, ExtraFlags[i]);
 358     }
 359   }
 360
 361   /* Some BYREF tests with non-NULL ptrs */
 362
 363   /* VARIANT BYREF */
 364   V_VT(&v2) = VT_I4;
 365   V_I4(&v2) = 0x1234;
 366   V_VT(&v) = VT_VARIANT | VT_BYREF;
 367   V_VARIANTREF(&v) = &v2;
 368
 369   hres = VariantClear(&v);
 370   ok(hres == S_OK, "ret %08lx\n", hres);
 371   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 372   ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
 373   ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
 374   ok(V_I4(&v2) == 0x1234, "i4 %04lx\n", V_I4(&v2));
 375
 376   /* I4 BYREF */
 377   i4 = 0x4321;
 378   V_VT(&v) = VT_I4 | VT_BYREF;
 379   V_I4REF(&v) = &i4;
 380
 381   hres = VariantClear(&v);
 382   ok(hres == S_OK, "ret %08lx\n", hres);
 383   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 384   ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
 385   ok(i4 == 0x4321, "i4 changed %08lx\n", i4);
 386
 387
 388   /* UNKNOWN */
 389   V_VT(&v) = VT_UNKNOWN;
 390   V_UNKNOWN(&v) = (IUnknown*)&test_myVariantClearImpl;
 391   test_myVariantClearImpl.events = 0;
 392   hres = VariantClear(&v);
 393   ok(hres == S_OK, "ret %08lx\n", hres);
 394   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 395   ok(V_UNKNOWN(&v) == (IUnknown*)&test_myVariantClearImpl, "unknown %p\n", V_UNKNOWN(&v));
 396   /* Check that Release got called, but nothing else */
 397   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 398
 399   /* UNKNOWN BYREF */
 400   punk = (IUnknown*)&test_myVariantClearImpl;
 401   V_VT(&v) = VT_UNKNOWN | VT_BYREF;
 402   V_UNKNOWNREF(&v) = &punk;
 403   test_myVariantClearImpl.events = 0;
 404   hres = VariantClear(&v);
 405   ok(hres == S_OK, "ret %08lx\n", hres);
 406   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 407   ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
 408   /* Check that nothing got called */
 409   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 410
 411   /* DISPATCH */
 412   V_VT(&v) = VT_DISPATCH;
 413   V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
 414   test_myVariantClearImpl.events = 0;
 415   hres = VariantClear(&v);
 416   ok(hres == S_OK, "ret %08lx\n", hres);
 417   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 418   ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
 419   /* Check that Release got called, but nothing else */
 420   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 421
 422   /* DISPATCH BYREF */
 423   punk = (IUnknown*)&test_myVariantClearImpl;
 424   V_VT(&v) = VT_DISPATCH | VT_BYREF;
 425   V_DISPATCHREF(&v) = (IDispatch**)&punk;
 426   test_myVariantClearImpl.events = 0;
 427   hres = VariantClear(&v);
 428   ok(hres == S_OK, "ret %08lx\n", hres);
 429   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 430   ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
 431   /* Check that nothing got called */
 432   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 433 }
 434
 435 static void test_VariantCopy(void)
 436 {
 437   VARIANTARG vSrc, vDst;
 438   VARTYPE vt;
 439   size_t i;
 440   HRESULT hres, hExpected;
 441
 442   /* Establish that the failure/other cases are dealt with. Individual tests
 443    * for each type should verify that data is copied correctly, references
 444    * are updated, etc.
 445    */
 446
 447   /* vSrc == vDst */
 448   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 449   {
 450     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 451     {
 452       SKIPTESTS(vt);
 453
 454       memset(&vSrc, 0, sizeof(vSrc));
 455       V_VT(&vSrc) = vt | ExtraFlags[i];
 456
 457       hExpected = DISP_E_BADVARTYPE;
 458       /* src is allowed to be a VT_CLSID */
 459       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 460         hExpected = S_OK;
 461
 462       hres = VariantCopy(&vSrc, &vSrc);
 463
 464       ok(hres == hExpected,
 465          "Copy(src==dst): expected 0x%lX, got 0x%lX for src==dest vt %d|0x%X\n",
 466          hExpected, hres, vt, ExtraFlags[i]);
 467     }
 468   }
 469
 470   /* Test that if VariantClear() fails on dest, the function fails. This also
 471    * shows that dest is in fact cleared and not just overwritten
 472    */
 473   memset(&vSrc, 0, sizeof(vSrc));
 474   V_VT(&vSrc) = VT_UI1;
 475
 476   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 477   {
 478     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 479     {
 480       SKIPTESTS(vt);
 481
 482       hExpected = DISP_E_BADVARTYPE;
 483
 484       memset(&vDst, 0, sizeof(vDst));
 485       V_VT(&vDst) = vt | ExtraFlags[i];
 486
 487       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 488         hExpected = S_OK;
 489
 490       hres = VariantCopy(&vDst, &vSrc);
 491
 492       ok(hres == hExpected,
 493          "Copy(bad dst): expected 0x%lX, got 0x%lX for dest vt %d|0x%X\n",
 494          hExpected, hres, vt, ExtraFlags[i]);
 495       if (hres == S_OK)
 496         ok(V_VT(&vDst) == VT_UI1,
 497            "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 498     }
 499   }
 500
 501   /* Test that VariantClear() checks vSrc for validity before copying */
 502   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 503   {
 504     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 505     {
 506       SKIPTESTS(vt);
 507
 508       hExpected = DISP_E_BADVARTYPE;
 509
 510       memset(&vDst, 0, sizeof(vDst));
 511       V_VT(&vDst) = VT_EMPTY;
 512
 513       memset(&vSrc, 0, sizeof(vSrc));
 514       V_VT(&vSrc) = vt | ExtraFlags[i];
 515
 516       /* src is allowed to be a VT_CLSID */
 517       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 518         hExpected = S_OK;
 519
 520       hres = VariantCopy(&vDst, &vSrc);
 521
 522       ok(hres == hExpected,
 523          "Copy(bad src): expected 0x%lX, got 0x%lX for src vt %d|0x%X\n",
 524          hExpected, hres, vt, ExtraFlags[i]);
 525       if (hres == S_OK)
 526         ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
 527            "Copy(bad src): expected vt = %d, got %d\n",
 528            vt | ExtraFlags[i], V_VT(&vDst));
 529     }
 530   }
 531
 532   /* Test that copying a NULL BSTR results in an empty BSTR */
 533   memset(&vDst, 0, sizeof(vDst));
 534   V_VT(&vDst) = VT_EMPTY;
 535   memset(&vSrc, 0, sizeof(vSrc));
 536   V_VT(&vSrc) = VT_BSTR;
 537   hres = VariantCopy(&vDst, &vSrc);
 538   ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
 539   if (hres == S_OK)
 540   {
 541     ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
 542        "Copy(NULL BSTR): should have non-NULL result\n");
 543     if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
 544     {
 545       ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
 546     }
 547   }
 548 }
 549
 550 /* Determine if a vt is valid for VariantCopyInd() */
 551 static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
 552 {
 553   int ret = 0;
 554
 555   if ((extraFlags & VT_ARRAY) ||
 556      (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
 557      !(extraFlags & (VT_VECTOR|VT_RESERVED))))
 558   {
 559     ret = 1; /* ok */
 560   }
 561   return ret;
 562 }
 563
 564 static void test_VariantCopyInd(void)
 565 {
 566   VARIANTARG vSrc, vDst, vRef, vRef2;
 567   VARTYPE vt;
 568   size_t i;
 569   BYTE buffer[64];
 570   HRESULT hres, hExpected;
 571
 572   memset(buffer, 0, sizeof(buffer));
 573
 574   /* vSrc == vDst */
 575   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 576   {
 577     if (ExtraFlags[i] & VT_ARRAY)
 578       continue; /* Native crashes on NULL safearray */
 579
 580     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 581     {
 582       SKIPTESTS(vt);
 583
 584       memset(&vSrc, 0, sizeof(vSrc));
 585       V_VT(&vSrc) = vt | ExtraFlags[i];
 586
 587       hExpected = DISP_E_BADVARTYPE;
 588       if (!(ExtraFlags[i] & VT_BYREF))
 589       {
 590         /* if src is not by-reference, acts as VariantCopy() */
 591         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 592           hExpected = S_OK;
 593       }
 594       else
 595       {
 596         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 597             vt == VT_DISPATCH || vt == VT_RECORD)
 598           continue; /* Need valid ptrs for deep copies */
 599
 600         V_BYREF(&vSrc) = &buffer;
 601         hExpected = E_INVALIDARG;
 602
 603         if ((vt == VT_I8 || vt == VT_UI8) &&
 604             ExtraFlags[i] == VT_BYREF)
 605         {
 606           if (HAVE_OLEAUT32_I8)
 607             hExpected = S_OK; /* Only valid if I8 is a known type */
 608         }
 609         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 610           hExpected = S_OK;
 611       }
 612
 613       hres = VariantCopyInd(&vSrc, &vSrc);
 614
 615       ok(hres == hExpected,
 616          "CopyInd(src==dst): expected 0x%lX, got 0x%lX for src==dst vt %d|0x%X\n",
 617          hExpected, hres, vt, ExtraFlags[i]);
 618     }
 619   }
 620
 621   /* Bad dest */
 622   memset(&vSrc, 0, sizeof(vSrc));
 623   V_VT(&vSrc) = VT_UI1|VT_BYREF;
 624   V_BYREF(&vSrc) = &buffer;
 625
 626   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 627   {
 628     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 629     {
 630       SKIPTESTS(vt);
 631
 632       memset(&vDst, 0, sizeof(vDst));
 633       V_VT(&vDst) = vt | ExtraFlags[i];
 634
 635       hExpected = DISP_E_BADVARTYPE;
 636
 637       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 638         hExpected = S_OK;
 639
 640       hres = VariantCopyInd(&vDst, &vSrc);
 641
 642       ok(hres == hExpected,
 643          "CopyInd(bad dst): expected 0x%lX, got 0x%lX for dst vt %d|0x%X\n",
 644          hExpected, hres, vt, ExtraFlags[i]);
 645       if (hres == S_OK)
 646         ok(V_VT(&vDst) == VT_UI1,
 647            "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 648     }
 649   }
 650
 651   /* bad src */
 652   for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
 653   {
 654     if (ExtraFlags[i] & VT_ARRAY)
 655       continue; /* Native crashes on NULL safearray */
 656
 657     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 658     {
 659       SKIPTESTS(vt);
 660
 661       memset(&vDst, 0, sizeof(vDst));
 662       V_VT(&vDst) = VT_EMPTY;
 663
 664       memset(&vSrc, 0, sizeof(vSrc));
 665       V_VT(&vSrc) = vt | ExtraFlags[i];
 666
 667       hExpected = DISP_E_BADVARTYPE;
 668       if (!(ExtraFlags[i] & VT_BYREF))
 669       {
 670         /* if src is not by-reference, acts as VariantCopy() */
 671         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 672           hExpected = S_OK;
 673       }
 674       else
 675       {
 676         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 677             vt == VT_DISPATCH || vt == VT_RECORD)
 678           continue; /* Need valid ptrs for deep copies, see vartype.c */
 679
 680         V_BYREF(&vSrc) = &buffer;
 681
 682         hExpected = E_INVALIDARG;
 683
 684         if ((vt == VT_I8 || vt == VT_UI8) &&
 685             ExtraFlags[i] == VT_BYREF)
 686         {
 687           if (HAVE_OLEAUT32_I8)
 688             hExpected = S_OK; /* Only valid if I8 is a known type */
 689         }
 690         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 691           hExpected = S_OK;
 692       }
 693
 694       hres = VariantCopyInd(&vDst, &vSrc);
 695
 696       ok(hres == hExpected,
 697          "CopyInd(bad src): expected 0x%lX, got 0x%lX for src vt %d|0x%X\n",
 698          hExpected, hres, vt, ExtraFlags[i]);
 699       if (hres == S_OK)
 700       {
 701         if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
 702         {
 703           /* Type of vDst should be the type of the referenced variant.
 704            * Since we set the buffer to all zeros, its type should be
 705            * VT_EMPTY.
 706            */
 707           ok(V_VT(&vDst) == VT_EMPTY,
 708              "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
 709              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 710         }
 711         else
 712         {
 713           ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
 714              "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
 715              vt, ExtraFlags[i] & ~VT_BYREF,
 716              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
 717         }
 718       }
 719     }
 720   }
 721
 722   /* By-reference variants are dereferenced */
 723   V_VT(&vRef) = VT_UI1;
 724   V_UI1(&vRef) = 0x77;
 725   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 726   V_VARIANTREF(&vSrc) = &vRef;
 727   VariantInit(&vDst);
 728
 729   hres = VariantCopyInd(&vDst, &vSrc);
 730   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
 731      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 732       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 733
 734   /* By-reference variant to a by-reference type succeeds */
 735   V_VT(&vRef) = VT_UI1|VT_BYREF;
 736   V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
 737   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 738   V_VARIANTREF(&vSrc) = &vRef;
 739   VariantInit(&vDst);
 740
 741   hres = VariantCopyInd(&vDst, &vSrc);
 742   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
 743      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
 744       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
 745
 746   /* But a by-reference variant to a by-reference variant fails */
 747   V_VT(&vRef2) = VT_UI1;
 748   V_UI1(&vRef2) = 0x77;
 749   V_VT(&vRef) = VT_VARIANT|VT_BYREF;
 750   V_VARIANTREF(&vRef) = &vRef2;
 751   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
 752   V_VARIANTREF(&vSrc) = &vRef;
 753   VariantInit(&vDst);
 754
 755   hres = VariantCopyInd(&vDst, &vSrc);
 756   ok(hres == E_INVALIDARG,
 757      "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08lx\n", hres);
 758 }
 759
 760 static HRESULT (WINAPI *pVarParseNumFromStr)(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
 761
 762 /* Macros for converting and testing the result of VarParseNumFromStr */
 763 #define FAILDIG 255
 764 #define CONVERTN(str,dig,flags) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
 765   memset(rgb, FAILDIG, sizeof(rgb)); memset(&np,-1,sizeof(np)); np.cDig = dig; np.dwInFlags = flags; \
 766   hres = pVarParseNumFromStr(buff,lcid,LOCALE_NOUSEROVERRIDE,&np,rgb)
 767 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
 768 #define EXPECT(a,b,c,d,e,f) ok(hres == (HRESULT)S_OK, "Call failed, hres = %08lx\n", hres); \
 769   if (hres == (HRESULT)S_OK) { \
 770     ok(np.cDig == (a), "Expected cDig = %d, got %d\n", (a), np.cDig); \
 771     ok(np.dwInFlags == (b), "Expected dwInFlags = 0x%lx, got 0x%lx\n", (ULONG)(b), np.dwInFlags); \
 772     ok(np.dwOutFlags == (c), "Expected dwOutFlags = 0x%lx, got 0x%lx\n", (ULONG)(c), np.dwOutFlags); \
 773     ok(np.cchUsed == (d), "Expected cchUsed = %d, got %d\n", (d), np.cchUsed); \
 774     ok(np.nBaseShift == (e), "Expected nBaseShift = %d, got %d\n", (e), np.nBaseShift); \
 775     ok(np.nPwr10 == (f), "Expected nPwr10 = %d, got %d\n", (f), np.nPwr10); \
 776   }
 777 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
 778 #define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08lx\n", hres)
 779 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
 780
 781 static void test_VarParseNumFromStr(void)
 782 {
 783   HRESULT hres;
 784   OLECHAR buff[128];
 785   /* Ensure all tests are using the same locale characters for '$', ',' etc */
 786   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 787   NUMPARSE np;
 788   BYTE rgb[128];
 789
 790   /** No flags **/
 791
 792   CHECKPTR(VarParseNumFromStr);
 793
 794   /* Consume a single digit */
 795   CONVERT("7", 0);
 796   EXPECT(1,0,0,1,0,0);
 797   EXPECT2(7,FAILDIG);
 798
 799   /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
 800   CONVERT("10", 0);
 801   EXPECT(1,0,0,2,0,1);
 802   /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
 803    * but then excludes them from the returned cDig count.
 804    * In our implementation we don't bother writing them at all.
 805    */
 806   EXPECTRGB(0, 1);
 807
 808   /* if cDig is too small and numbers follow, sets INEXACT */
 809   CONVERTN("11",1, 0);
 810   EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
 811   EXPECT2(1,FAILDIG);
 812
 813   /* Strips leading zeros */
 814   CONVERT("01", 0);
 815   EXPECT(1,0,0,2,0,0);
 816   EXPECT2(1,FAILDIG);
 817
 818   /* Strips leading zeros */
 819   CONVERTN("01",1, 0);
 820   EXPECT(1,0,0,2,0,0);
 821   EXPECT2(1,FAILDIG);
 822
 823
 824   /* Fails on non digits */
 825   CONVERT("a", 0);
 826   EXPECTFAIL;
 827   EXPECTRGB(0,FAILDIG);
 828
 829   /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
 830
 831   /* Without flag, fails on whitespace */
 832   CONVERT(" 0", 0);
 833   EXPECTFAIL;
 834   EXPECTRGB(0,FAILDIG);
 835
 836
 837   /* With flag, consumes whitespace */
 838   CONVERT(" 0", NUMPRS_LEADING_WHITE);
 839   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 840   EXPECT2(0,FAILDIG);
 841
 842   /* Test TAB once, then assume it acts as space for all cases */
 843   CONVERT("\t0", NUMPRS_LEADING_WHITE);
 844   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 845   EXPECT2(0,FAILDIG);
 846
 847
 848   /* Doesn't pick up trailing whitespace without flag */
 849   CONVERT("0 ", 0);
 850   EXPECT(1,0,0,1,0,0);
 851   EXPECT2(0,FAILDIG);
 852
 853   /* With flag, consumes trailing whitespace */
 854   CONVERT("0 ", NUMPRS_TRAILING_WHITE);
 855   EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
 856   EXPECT2(0,FAILDIG);
 857
 858   /* Leading flag only consumes leading */
 859   CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
 860   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
 861   EXPECT2(0,FAILDIG);
 862
 863   /* Both flags consumes both */
 864   CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
 865   EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
 866   EXPECT2(0,FAILDIG);
 867
 868   /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
 869
 870   /* Without flag, fails on + */
 871   CONVERT("+0", 0);
 872   EXPECTFAIL;
 873   EXPECTRGB(0,FAILDIG);
 874
 875   /* With flag, consumes + */
 876   CONVERT("+0", NUMPRS_LEADING_PLUS);
 877   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
 878   EXPECT2(0,FAILDIG);
 879
 880   /* Without flag, doesn't consume trailing + */
 881   CONVERT("0+", 0);
 882   EXPECT(1,0,0,1,0,0);
 883   EXPECT2(0,FAILDIG);
 884
 885   /* With flag, consumes trailing + */
 886   CONVERT("0+", NUMPRS_TRAILING_PLUS);
 887   EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
 888   EXPECT2(0,FAILDIG);
 889
 890   /* With leading flag, doesn't consume trailing + */
 891   CONVERT("+0+", NUMPRS_LEADING_PLUS);
 892   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
 893   EXPECT2(0,FAILDIG);
 894
 895   /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
 896   CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
 897   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
 898   EXPECT2(0,FAILDIG);
 899
 900   /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
 901
 902   /* Without flag, fails on - */
 903   CONVERT("-0", 0);
 904   EXPECTFAIL;
 905   EXPECTRGB(0,FAILDIG);
 906
 907   /* With flag, consumes - */
 908   CONVERT("-0", NUMPRS_LEADING_MINUS);
 909   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
 910   EXPECT2(0,FAILDIG);
 911
 912   /* Without flag, doesn't consume trailing - */
 913   CONVERT("0-", 0);
 914   EXPECT(1,0,0,1,0,0);
 915   EXPECT2(0,FAILDIG);
 916
 917   /* With flag, consumes trailing - */
 918   CONVERT("0-", NUMPRS_TRAILING_MINUS);
 919   EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
 920   EXPECT2(0,FAILDIG);
 921
 922   /* With leading flag, doesn't consume trailing - */
 923   CONVERT("-0-", NUMPRS_LEADING_MINUS);
 924   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
 925   EXPECT2(0,FAILDIG);
 926
 927   /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
 928   CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
 929   EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
 930   EXPECT2(0,FAILDIG);
 931
 932   /** NUMPRS_HEX_OCT **/
 933
 934   /* Could be hex, octal or decimal - With flag reads as decimal */
 935   CONVERT("0", NUMPRS_HEX_OCT);
 936   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
 937   EXPECT2(0,FAILDIG);
 938
 939   /* Doesn't recognise hex in .asm sytax */
 940   CONVERT("0h", NUMPRS_HEX_OCT);
 941   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
 942   EXPECT2(0,FAILDIG);
 943
 944   /* Doesn't fail with valid leading string but no digits */
 945   CONVERT("0x", NUMPRS_HEX_OCT);
 946   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
 947   EXPECT2(0,FAILDIG);
 948
 949   /* Doesn't recognise hex format humbers at all! */
 950   CONVERT("0x0", NUMPRS_HEX_OCT);
 951   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
 952   EXPECT2(0,FAILDIG);
 953
 954   /* Doesn't recognise plain hex digits either */
 955   CONVERT("FE", NUMPRS_HEX_OCT);
 956   EXPECTFAIL;
 957   EXPECTRGB(0,FAILDIG);
 958
 959   /* Octal */
 960   CONVERT("0100", NUMPRS_HEX_OCT);
 961   EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
 962   EXPECTRGB(0,1);
 963   EXPECTRGB(1,0);
 964   EXPECTRGB(2,0);
 965   EXPECTRGB(3,FAILDIG);
 966
 967   /* VB hex */
 968   CONVERT("&HF800", NUMPRS_HEX_OCT);
 969   EXPECT(4,NUMPRS_HEX_OCT,0x40,6,4,0);
 970   EXPECTRGB(0,15);
 971   EXPECTRGB(1,8);
 972   EXPECTRGB(2,0);
 973   EXPECTRGB(3,0);
 974   EXPECTRGB(4,FAILDIG);
 975
 976   /* VB hex lower case and leading zero */
 977   CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
 978   EXPECT(6,NUMPRS_HEX_OCT,0x40,9,4,0);
 979   EXPECTRGB(0,10);
 980   EXPECTRGB(1,11);
 981   EXPECTRGB(2,12);
 982   EXPECTRGB(3,13);
 983   EXPECTRGB(4,14);
 984   EXPECTRGB(5,15);
 985   EXPECTRGB(6,FAILDIG);
 986
 987   /* VB oct */
 988   CONVERT("&O300", NUMPRS_HEX_OCT);
 989   EXPECT(3,NUMPRS_HEX_OCT,0x40,5,3,0);
 990   EXPECTRGB(0,3);
 991   EXPECTRGB(1,0);
 992   EXPECTRGB(2,0);
 993   EXPECTRGB(3,FAILDIG);
 994
 995   /* VB oct lower case and leading zero */
 996   CONVERT("&o0777", NUMPRS_HEX_OCT);
 997   EXPECT(3,NUMPRS_HEX_OCT,0x40,6,3,0);
 998   EXPECTRGB(0,7);
 999   EXPECTRGB(1,7);
1000   EXPECTRGB(2,7);
1001   EXPECTRGB(3,FAILDIG);
1002
1003   /* VB oct char bigger than 7 */
1004   CONVERT("&o128", NUMPRS_HEX_OCT);
1005 /*
1006   Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
1007   EXPECTFAIL;
1008   EXPECTRGB(0,FAILDIG);
1009 */
1010   /** NUMPRS_PARENS **/
1011
1012   /* Empty parens = error */
1013   CONVERT("()", NUMPRS_PARENS);
1014   EXPECTFAIL;
1015   EXPECTRGB(0,FAILDIG);
1016
1017   /* With flag, trailing parens not consumed */
1018   CONVERT("0()", NUMPRS_PARENS);
1019   EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1020   EXPECT2(0,FAILDIG);
1021
1022   /* With flag, Number in parens made negative and parens consumed */
1023   CONVERT("(0)", NUMPRS_PARENS);
1024   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1025   EXPECT2(0,FAILDIG);
1026
1027   /** NUMPRS_THOUSANDS **/
1028
1029   /* With flag, thousands sep. not needed */
1030   CONVERT("0", NUMPRS_THOUSANDS);
1031   EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1032   EXPECT2(0,FAILDIG);
1033
1034   /* With flag, thousands sep. and following digits consumed */
1035   CONVERT("1,000", NUMPRS_THOUSANDS);
1036   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1037   EXPECTRGB(0,1);
1038
1039   /* With flag and decimal point, thousands sep. but not decimals consumed */
1040   CONVERT("1,000.0", NUMPRS_THOUSANDS);
1041   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1042   EXPECTRGB(0,1);
1043
1044   /** NUMPRS_CURRENCY **/
1045
1046   /* Without flag, chokes on currency sign */
1047   CONVERT("$11", 0);
1048   EXPECTFAIL;
1049   EXPECTRGB(0,FAILDIG);
1050
1051   /* With flag, consumes currency sign */
1052   CONVERT("$11", NUMPRS_CURRENCY);
1053   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1054   EXPECT2(1,1);
1055   EXPECTRGB(2,FAILDIG);
1056
1057   /* With flag only, doesn't consume decimal point */
1058   CONVERT("$11.1", NUMPRS_CURRENCY);
1059   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1060   EXPECT2(1,1);
1061   EXPECTRGB(2,FAILDIG);
1062
1063   /* With flag and decimal flag, consumes decimal point and following digits */
1064   CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1065   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1066   EXPECT2(1,1);
1067   EXPECTRGB(2,1);
1068   EXPECTRGB(3,FAILDIG);
1069
1070   /* Thousands flag can only be used with currency */
1071   CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1072   EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1073   EXPECT2(1,2);
1074   EXPECTRGB(2,3);
1075   EXPECTRGB(3,4);
1076   EXPECTRGB(4,FAILDIG);
1077
1078   /** NUMPRS_DECIMAL **/
1079
1080   /* With flag, consumes decimal point */
1081   CONVERT("1.1", NUMPRS_DECIMAL);
1082   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1083   EXPECT2(1,1);
1084   EXPECTRGB(2,FAILDIG);
1085
1086   /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1087   CONVERT("1.", NUMPRS_DECIMAL);
1088   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1089   EXPECT2(1,FAILDIG);
1090
1091   /* Consumes only one decimal point */
1092   CONVERT("1.1.", NUMPRS_DECIMAL);
1093   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1094   EXPECT2(1,1);
1095   EXPECTRGB(2,FAILDIG);
1096
1097   /** NUMPRS_EXPONENT **/
1098
1099   /* Without flag, doesn't consume exponent */
1100   CONVERT("1e1", 0);
1101   EXPECT(1,0,0,1,0,0);
1102   EXPECT2(1,FAILDIG);
1103
1104   /* With flag, consumes exponent */
1105   CONVERT("1e1", NUMPRS_EXPONENT);
1106   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1107   EXPECT2(1,FAILDIG);
1108
1109   /* Negative exponents are accepted without flags */
1110   CONVERT("1e-1", NUMPRS_EXPONENT);
1111   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1112   EXPECT2(1,FAILDIG);
1113
1114   /* As are positive exponents and leading exponent 0's */
1115   CONVERT("1e+01", NUMPRS_EXPONENT);
1116   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1117   EXPECT2(1,FAILDIG);
1118
1119   /* The same for zero exponents */
1120   CONVERT("1e0", NUMPRS_EXPONENT);
1121   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1122   EXPECT2(1,FAILDIG);
1123
1124   /* Sign on a zero exponent doesn't matter */
1125   CONVERT("1e+0", NUMPRS_EXPONENT);
1126   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1127   EXPECT2(1,FAILDIG);
1128
1129   CONVERT("1e-0", NUMPRS_EXPONENT);
1130   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1131   EXPECT2(1,FAILDIG);
1132
1133   /* Doesn't consume a real number exponent */
1134   CONVERT("1e1.", NUMPRS_EXPONENT);
1135   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1136   EXPECT2(1,FAILDIG);
1137
1138   /* Powers of 10 are calculated from the position of any decimal point */
1139   CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1140   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1141   EXPECT2(1,5);
1142
1143   CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1144   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1145   EXPECT2(1,5);
1146
1147   /** NUMPRS_USE_ALL **/
1148
1149   /* Flag expects all digits */
1150   CONVERT("0", NUMPRS_USE_ALL);
1151   EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1152   EXPECT2(0,FAILDIG);
1153
1154   /* Rejects anything trailing */
1155   CONVERT("0 ", NUMPRS_USE_ALL);
1156   EXPECTFAIL;
1157   EXPECT2(0,FAILDIG);
1158
1159   /* Unless consumed by trailing flag */
1160   CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1161   EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1162   EXPECT2(0,FAILDIG);
1163
1164   /** Combinations **/
1165
1166   /* Leading whitepace and plus, doesn't consume trailing whitespace */
1167   CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1168   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1169   EXPECT2(0,FAILDIG);
1170
1171   /* Order of whitepace and plus is unimportant */
1172   CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1173   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1174   EXPECT2(0,FAILDIG);
1175
1176   /* Leading whitespace can be repeated */
1177   CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1178   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1179   EXPECT2(0,FAILDIG);
1180
1181   /* But plus/minus etc. cannot */
1182   CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1183   EXPECTFAIL;
1184   EXPECTRGB(0,FAILDIG);
1185
1186   /* Inexact is not set if trailing zeros are removed */
1187   CONVERTN("10", 1, 0);
1188   EXPECT(1,0,0,2,0,1);
1189   EXPECT2(1,FAILDIG);
1190
1191   /* Make sure a leading 0 is stripped but decimals after it get read */
1192   CONVERT("-0.51", NUMPRS_STD);
1193   EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1194   EXPECT2(5,1);
1195
1196   /* Keep trailing zeros on whole number part of a decimal */
1197   CONVERT("10.1", NUMPRS_STD);
1198   EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1199   EXPECT2(1,0);
1200   EXPECTRGB(2,1);
1201
1202   /* Zeros after decimal sign */
1203   CONVERT("0.01", NUMPRS_STD);
1204   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1205   EXPECT2(1,FAILDIG);
1206
1207   /* Trailing zeros after decimal part */
1208   CONVERT("0.10", NUMPRS_STD);
1209   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1210   EXPECT2(1,0);
1211 }
1212
1213 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1214
1215 /* Macros for converting and testing the result of VarNumFromParseNum */
1216 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1217 #undef CONVERT
1218 #define CONVERT(a,b,c,d,e,f,bits) \
1219     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1220     np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1221 static const char *szFailOverflow = "Expected overflow, hres = %08lx\n";
1222 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1223 static const char *szFailOk = "Call failed, hres = %08lx\n";
1224 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1225   if (hres == (HRESULT)S_OK)
1226 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1227 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1228   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1229 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1230   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1231 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1232   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1233 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1234   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1235 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1236   ok(V_I4(&vOut) == val, "Expected i4 = %ld, got %ld\n", (LONG)val, V_I4(&vOut)); }
1237 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1238   ok(V_UI4(&vOut) == val, "Expected ui4 = %ld, got %ld\n", (ULONG)val, V_UI4(&vOut)); }
1239 #define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1240   ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %lx%08lx, got %lx%08lx\n", \
1241      (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
1242 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1243   ok(V_UI8(&vOut) == val, "Expected ui8 = %lld, got %lld\n", (ULONG64)val, V_UI8(&vOut)); }
1244 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1245   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1246 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1247   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1248 #define CY_MULTIPLIER 10000
1249 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1250   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = %lld, got %lld\n", (LONG64)val, V_CY(&vOut).int64); }
1251
1252 static void test_VarNumFromParseNum(void)
1253 {
1254   HRESULT hres;
1255   NUMPARSE np;
1256   BYTE rgb[128];
1257   VARIANT vOut;
1258
1259   CHECKPTR(VarNumFromParseNum);
1260
1261   /* Convert the number 1 to different types */
1262   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1263   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1264   /* Prefers a signed type to unsigned of the same size */
1265   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1266   /* But takes the smaller size if possible */
1267   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1268
1269   /* Try different integer sizes */
1270 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1271
1272   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1273   /* 127 */
1274   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1275   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1276   /* 128 */
1277   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1278   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1279   /* 255 */
1280   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1281   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1282   /* 256 */
1283   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1284   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1285   /* 32767 */
1286   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1287   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1288   /* 32768 */
1289   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1290   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1291
1292   /* Assume the above pattern holds for remaining positive integers; test negative */
1293
1294   /* -128 */
1295   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1296   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1297   /* -129 */
1298   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1299   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1300   /* -32768 */
1301   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1302   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1303   /* -32768 */
1304   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1305   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1306
1307   /* Assume the above pattern holds for remaining negative integers */
1308
1309   /* Test hexadecimal conversions */
1310   SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
1311   /* 0x7f */
1312   SETRGB(0, 7); SETRGB(1, 0xf);
1313   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
1314   /* 0x7fff */
1315   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1316   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
1317   /* 0x7fffffff */
1318   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1319   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1320   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
1321   /* 0x7fffffffffffffff (64 bits) */
1322   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1323   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1324   SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
1325   SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
1326   if (HAVE_OLEAUT32_I8)
1327   {
1328     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1329        truncate the number to the smallest integer size requested:
1330        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
1331     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffff,0xffffffff);
1332   }
1333
1334   /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
1335   /* 0x82 */
1336   SETRGB(0, 8); SETRGB(1, 2);
1337   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
1338   EXPECT_I1((signed char)0x82);
1339   /* 0x8002 */
1340   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1341   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
1342   EXPECT_I2((signed short)0x8002);
1343   /* 0x80000002 */
1344   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1345   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1346   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
1347   /* 0x8000000000000002 (64 bits) */
1348   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1349   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1350   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1351   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1352   if (HAVE_OLEAUT32_I8)
1353   {
1354     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1355        truncate the number to the smallest integer size requested:
1356        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
1357        EXPECT_I2((signed short)0x0002); */
1358     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1359   }
1360
1361   /* Test (preservation of) hi-bit with STRICT type requesting */
1362   /* 0x82 */
1363   SETRGB(0, 8); SETRGB(1, 2);
1364   CONVERT(2,0,0,2,4,0, VTBIT_I1);
1365   EXPECT_I1((signed char)0x82);
1366   /* 0x8002 */
1367   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1368   CONVERT(4,0,0,4,4,0, VTBIT_I2);
1369   EXPECT_I2((signed short)0x8002);
1370   /* 0x80000002 */
1371   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1372   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1373   CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
1374   /* 0x8000000000000002 (64 bits) */
1375   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1376   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1377   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1378   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1379   if (HAVE_OLEAUT32_I8)
1380   {
1381     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1382   }
1383   /* Assume the above pattern holds for numbers with hi-bit set */
1384
1385   /* Negative numbers overflow if we have only unsigned outputs */
1386   /* -1 */
1387   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1388   /* -0.6 */
1389   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1390
1391   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1392   /* -0.5 */
1393   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1394
1395   /* Floating point zero is OK */
1396   /* 0.00000000E0 */
1397   SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
1398   EXPECT_R8(0.0);
1399
1400   /* Float is acceptable for an integer input value */
1401   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1402   /* As is double */
1403   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1404   /* As is currency */
1405   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1406
1407   /* Float is preferred over double */
1408   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1409
1410   /* Double is preferred over currency */
1411   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1412
1413   /* Currency is preferred over decimal */
1414   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1415 }
1416
1417 static const char* szUdateFromDateFail = "%.16g expected %lx, %d,%d,%d,%d,%d,%d,%d  %d %d"
1418                                          ", got %lx, %d,%d,%d,%d,%d,%d,%d  %d %d\n";
1419 #define DT2UD(dt,flags,r,d,m,y,h,mn,s,ms,dw,dy) \
1420   memset(&ud, 0, sizeof(ud)); \
1421   res = pVarUdateFromDate(dt, flags, &ud); \
1422   ok(r == res && (FAILED(r) || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d && \
1423      ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s && \
1424      ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)), \
1425      szUdateFromDateFail, dt, r, d, m, y, h, mn, s, ms, dw, dy, res, ud.st.wDay, ud.st.wMonth, \
1426      ud.st.wYear, ud.st.wHour, ud.st.wMinute, ud.st.wSecond, \
1427      ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear)
1428
1429 static void test_VarUdateFromDate(void)
1430 {
1431   UDATE ud;
1432   HRESULT res;
1433
1434   CHECKPTR(VarUdateFromDate);
1435   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
1436   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
1437   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
1438   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
1439   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
1440   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1441   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
1442   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
1443
1444   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1445   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1446   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1447
1448   /* Times */
1449   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
1450   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
1451   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
1452   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1453   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1454 }
1455
1456 #define UD2T(d,m,y,h,mn,s,ms,dw,dy,flags,r,dt) \
1457   ud.st.wYear = (y); ud.st.wMonth = (m); ud.st.wDay = (d); ud.st.wHour = (h); \
1458   ud.st.wMinute = (mn); ud.st.wSecond = (s); ud.st.wMilliseconds = (ms); \
1459   ud.st.wDayOfWeek = (dw); ud.wDayOfYear = (dy); \
1460   res = pVarDateFromUdate(&ud, (flags), &out); \
1461   ok((r) == res && (FAILED(r) || fabs(out-(dt)) < 1.0e-11), \
1462      "expected %lx, %.16g, got %lx, %.16g\n", r, dt, res, out)
1463
1464 static void test_VarDateFromUdate(void)
1465 {
1466   UDATE ud;
1467   double out;
1468   HRESULT res;
1469
1470   CHECKPTR(VarDateFromUdate);
1471   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
1472   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
1473   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
1474   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
1475   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
1476   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
1477   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
1478   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
1479
1480   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963); /* 6:18:02 PM */
1481
1482   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);      /* Rolls back to 31 Dec 1899 */
1483   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);     /* Rolls fwd to 1/1/1981 */
1484 }
1485
1486 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) \
1487   st.wYear = y; st.wMonth = m; st.wDay = d; st.wHour = h; st.wMinute = mn; \
1488   st.wSecond = s; st.wMilliseconds = ms; st.wDayOfWeek = 0; \
1489   res = pSystemTimeToVariantTime(&st, &out); \
1490   ok(r == res && (!r || fabs(out-dt) < 1.0e-11), \
1491      "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out)
1492
1493 static void test_SystemTimeToVariantTime(void)
1494 {
1495   SYSTEMTIME st;
1496   double out;
1497   int res;
1498
1499   CHECKPTR(SystemTimeToVariantTime);
1500   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1501   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1502   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
1503   ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1504   ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* year < 100 is 1900+year! */
1505 }
1506
1507 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) \
1508   memset(&st, 0, sizeof(st)); \
1509   res = pVariantTimeToSystemTime(dt, &st); \
1510   ok(r == res && (!r || (st.wYear == y && st.wMonth == m && st.wDay == d && \
1511      st.wHour == h && st.wMinute == mn && st.wSecond == s && \
1512      st.wMilliseconds == ms)), \
1513      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n", \
1514      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth, st.wYear, \
1515      st.wHour, st.wMinute, st.wSecond, st.wMilliseconds)
1516
1517 static void test_VariantTimeToSystemTime(void)
1518 {
1519   SYSTEMTIME st;
1520   int res;
1521
1522   CHECKPTR(VariantTimeToSystemTime);
1523   DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1524   DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1525 }
1526
1527 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1528 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1529
1530 static const char *szDosDateToVarTimeFail = "expected %d, %.16g, got %d, %.16g\n";
1531 #define DOS2DT(d,m,y,h,mn,s,r,dt) out = 0.0; \
1532   dosDate = MKDOSDATE(d,m,y); \
1533   dosTime = MKDOSTIME(h,mn,s); \
1534   res = pDosDateTimeToVariantTime(dosDate, dosTime, &out); \
1535   ok(r == res && (!r || fabs(out-dt) < 1.0e-11), \
1536      szDosDateToVarTimeFail, r, dt, res, out)
1537
1538 static void test_DosDateTimeToVariantTime(void)
1539 {
1540   USHORT dosDate, dosTime;
1541   double out;
1542   INT res;
1543
1544   CHECKPTR(DosDateTimeToVariantTime);
1545
1546   /* Date */
1547   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1548   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1549   /* Dates are limited to the dos date max of 31/12/2099 */
1550   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1551   /* Days and months of 0 cause date to roll back 1 day or month */
1552   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1553   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
1554   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1555   /* Days > days in the month cause date to roll forward 1 month */
1556   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1557   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1558   /* Takes leap years into account when rolling forward */
1559   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1560   /* Months > 12 cause an error */
1561   DOS2DT(2,13,1980,0,0,0,0,0.0);
1562
1563   /* Time */
1564   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1565   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1566   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1567   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid seconds */
1568   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1569   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
1570 }
1571
1572 #define DT2DOS(dt,r,d,m,y,h,mn,s) dosTime = dosDate = 0; \
1573   expDosDate = MKDOSDATE(d,m,y); \
1574   expDosTime = MKDOSTIME(h,mn,s); \
1575   res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime); \
1576   ok(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)), \
1577      "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n", \
1578      dt, r, expDosDate, expDosDate & 0x1f, (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9), \
1579      expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f, (expDosTime & 0x1f), \
1580      res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf, 1980 + (dosDate >> 9), \
1581      dosTime, dosTime >> 11, (dosTime >> 5) & 0x3f, (dosTime & 0x1f))
1582
1583 static void test_VariantTimeToDosDateTime(void)
1584 {
1585   USHORT dosDate, dosTime, expDosDate, expDosTime;
1586   INT res;
1587
1588   CHECKPTR(VariantTimeToDosDateTime);
1589
1590   /* Date */
1591   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
1592   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1593   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
1594   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
1595
1596   /* Time */
1597   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1598   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1599   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1600   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1601 }
1602
1603 #define FMT_NUMBER(vt,val) \
1604   VariantInit(&v); V_VT(&v) = vt; val(&v) = 1; \
1605   hres = pVarFormatNumber(&v,2,0,0,0,0,&str); \
1606   ok(hres == S_OK, "VarFormatNumber (vt %d): returned %8lx\n", vt, hres); \
1607   if (hres == S_OK) \
1608     ok(str && strcmpW(str,szResult1) == 0, \
1609        "VarFormatNumber (vt %d): string different\n", vt)
1610
1611 static void test_VarFormatNumber(void)
1612 {
1613   static const WCHAR szSrc1[] = { '1','\0' };
1614   static const WCHAR szResult1[] = { '1','.','0','0','\0' };
1615   static const WCHAR szSrc2[] = { '-','1','\0' };
1616   static const WCHAR szResult2[] = { '(','1','.','0','0',')','\0' };
1617   char buff[8];
1618   HRESULT hres;
1619   VARIANT v;
1620   BSTR str = NULL;
1621
1622   CHECKPTR(VarFormatNumber);
1623
1624   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1625   if (buff[0] != '.' || buff[1])
1626   {
1627     trace("Skipping VarFormatNumber tests as decimal separator is '%s'\n", buff);
1628     return;
1629   }
1630
1631   FMT_NUMBER(VT_I1, V_I1);
1632   FMT_NUMBER(VT_UI1, V_UI1);
1633   FMT_NUMBER(VT_I2, V_I2);
1634   FMT_NUMBER(VT_UI2, V_UI2);
1635   FMT_NUMBER(VT_I4, V_I4);
1636   FMT_NUMBER(VT_UI4, V_UI4);
1637   if (HAVE_OLEAUT32_I8)
1638   {
1639     FMT_NUMBER(VT_I8, V_I8);
1640     FMT_NUMBER(VT_UI8, V_UI8);
1641   }
1642   FMT_NUMBER(VT_R4, V_R4);
1643   FMT_NUMBER(VT_R8, V_R8);
1644   FMT_NUMBER(VT_BOOL, V_BOOL);
1645
1646   V_VT(&v) = VT_BSTR;
1647   V_BSTR(&v) = SysAllocString(szSrc1);
1648
1649   hres = pVarFormatNumber(&v,2,0,0,0,0,&str);
1650   ok(hres == S_OK, "VarFormatNumber (bstr): returned %8lx\n", hres);
1651   if (hres == S_OK)
1652     ok(str && strcmpW(str, szResult1) == 0, "VarFormatNumber (bstr): string different\n");
1653   SysFreeString(V_BSTR(&v));
1654   SysFreeString(str);
1655
1656   V_BSTR(&v) = SysAllocString(szSrc2);
1657   hres = pVarFormatNumber(&v,2,0,-1,0,0,&str);
1658   ok(hres == S_OK, "VarFormatNumber (bstr): returned %8lx\n", hres);
1659   if (hres == S_OK)
1660     ok(str && strcmpW(str, szResult2) == 0, "VarFormatNumber (-bstr): string different\n");
1661   SysFreeString(V_BSTR(&v));
1662   SysFreeString(str);
1663 }
1664
1665 #define SIGNED_VTBITS (VTBIT_I1|VTBIT_I2|VTBIT_I4|VTBIT_I8|VTBIT_R4|VTBIT_R8)
1666
1667 static const char *szVarFmtFail = "VT %d|0x%04x Format %s: expected 0x%08lx, '%s', got 0x%08lx, '%s'\n";
1668 #define VARFMT(vt,v,val,fmt,ret,str) do { \
1669   if (out) SysFreeString(out); out = NULL; \
1670   V_VT(&in) = (vt); v(&in) = val; \
1671   if (fmt) MultiByteToWideChar(CP_ACP, 0, fmt, -1, buffW, sizeof(buffW)/sizeof(WCHAR)); \
1672   hres = pVarFormat(&in,fmt ? buffW : NULL,fd,fw,flags,&out); \
1673   if (SUCCEEDED(hres)) WideCharToMultiByte(CP_ACP, 0, out, -1, buff, sizeof(buff),0,0); \
1674   else buff[0] = '\0'; \
1675   ok(hres == ret && (FAILED(ret) || !strcmp(buff, str)), \
1676      szVarFmtFail, \
1677      (vt)&VT_TYPEMASK,(vt)&~VT_TYPEMASK,fmt?fmt:"<null>",ret,str,hres,buff); \
1678   } while(0)
1679
1680 typedef struct tagFMTRES
1681 {
1682   LPCSTR fmt;
1683   LPCSTR one_res;
1684   LPCSTR zero_res;
1685 } FMTRES;
1686
1687 static const FMTRES VarFormat_results[] =
1688 {
1689   { NULL, "1", "0" },
1690   { "", "1", "0" },
1691   { "General Number", "1", "0" },
1692   { "Percent", "100.00%", "0.00%" },
1693   { "Standard", "1.00", "0.00" },
1694   { "Scientific","1.00E+00", "0.00E+00" },
1695   { "True/False", "True", "False" },
1696   { "On/Off", "On", "Off" },
1697   { "Yes/No", "Yes", "No" },
1698   { "#", "1", "" },
1699   { "##", "1", "" },
1700   { "#.#", "1.", "." },
1701   { "0", "1", "0" },
1702   { "00", "01", "00" },
1703   { "0.0", "1.0", "0.0" },
1704   { "00\\c\\o\\p\\y", "01copy","00copy" },
1705   { "\"pos\";\"neg\"", "pos", "pos" },
1706   { "\"pos\";\"neg\";\"zero\"","pos", "zero" }
1707 };
1708
1709 typedef struct tagFMTDATERES
1710 {
1711   DATE   val;
1712   LPCSTR fmt;
1713   LPCSTR res;
1714 } FMTDATERES;
1715
1716 static const FMTDATERES VarFormat_date_results[] =
1717 {
1718   { 0.0, "w", "7" },
1719   { 0.0, "w", "6" },
1720   { 0.0, "w", "5" },
1721   { 0.0, "w", "4" },
1722   { 0.0, "w", "3" },
1723   { 0.0, "w", "2" },
1724   { 0.0, "w", "1" }, /* First 7 entries must remain in this order! */
1725   { 2.525, "am/pm", "pm" },
1726   { 2.525, "AM/PM", "PM" },
1727   { 2.525, "A/P", "P" },
1728   { 2.525, "a/p", "p" },
1729   { 2.525, "q", "1" },
1730   { 2.525, "d", "1" },
1731   { 2.525, "dd", "01" },
1732   { 2.525, "ddd", "Mon" },
1733   { 2.525, "dddd", "Monday" },
1734   { 2.525, "mmm", "Jan" },
1735   { 2.525, "mmmm", "January" },
1736   { 2.525, "y", "1" },
1737   { 2.525, "yy", "00" },
1738   { 2.525, "yyy", "001" },
1739   { 2.525, "yyyy", "1900" },
1740   { 2.525, "dd mm yyyy hh:mm:ss", "01 01 1900 12:36:00" },
1741   { 2.525, "dd mm yyyy mm", "01 01 1900 01" },
1742   { 2.525, "dd mm yyyy :mm", "01 01 1900 :01" },
1743   { 2.525, "dd mm yyyy hh:mm", "01 01 1900 12:36" },
1744   { 2.525, "mm mm", "01 01" },
1745   { 2.525, "mm :mm:ss", "01 :01:00" },
1746   { 2.525, "mm :ss:mm", "01 :00:01" },
1747   { 2.525, "hh:mm :ss:mm", "12:36 :00:01" },
1748   { 2.525, "hh:dd :mm:mm", "12:01 :01:01" },
1749   { 2.525, "dd:hh :mm:mm", "01:12 :36:01" },
1750   { 2.525, "hh :mm:mm", "12 :36:01" },
1751   { 2.525, "dd :mm:mm", "01 :01:01" },
1752   { 2.525, "dd :mm:nn", "01 :01:36" },
1753   { 2.725, "hh:nn:ss A/P", "05:24:00 P" }
1754 };
1755
1756 #define VNUMFMT(vt,v) \
1757   for (i = 0; i < sizeof(VarFormat_results)/sizeof(FMTRES); i++) \
1758   { \
1759     VARFMT(vt,v,1,VarFormat_results[i].fmt,S_OK,VarFormat_results[i].one_res); \
1760     VARFMT(vt,v,0,VarFormat_results[i].fmt,S_OK,VarFormat_results[i].zero_res); \
1761   } \
1762   if ((1 << vt) & SIGNED_VTBITS) \
1763   { \
1764     VARFMT(vt,v,-1,"\"pos\";\"neg\"",S_OK,"neg"); \
1765     VARFMT(vt,v,-1,"\"pos\";\"neg\";\"zero\"",S_OK,"neg"); \
1766   }
1767
1768 static void test_VarFormat(void)
1769 {
1770   static const WCHAR szTesting[] = { 't','e','s','t','i','n','g','\0' };
1771   size_t i;
1772   WCHAR buffW[256];
1773   char buff[256];
1774   VARIANT in;
1775   VARIANT_BOOL bTrue = VARIANT_TRUE, bFalse = VARIANT_FALSE;
1776   int fd = 0, fw = 0;
1777   ULONG flags = 0;
1778   BSTR bstrin, out = NULL;
1779   HRESULT hres;
1780
1781   CHECKPTR(VarFormat);
1782
1783   if (PRIMARYLANGID(LANGIDFROMLCID(GetUserDefaultLCID())) != LANG_ENGLISH)
1784   {
1785     trace("Skipping VarFormat tests for non english language\n");
1786     return;
1787   }
1788   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1789   if (buff[0] != '.' || buff[1])
1790   {
1791     trace("Skipping VarFormat tests as decimal separator is '%s'\n", buff);
1792     return;
1793   }
1794   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IDIGITS, buff, sizeof(buff)/sizeof(char));
1795   if (buff[0] != '2' || buff[1])
1796   {
1797     trace("Skipping VarFormat tests as decimal places is '%s'\n", buff);
1798     return;
1799   }
1800
1801   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"True/False",S_OK,"True");
1802   VARFMT(VT_BOOL,V_BOOL,VARIANT_FALSE,"True/False",S_OK,"False");
1803
1804   VNUMFMT(VT_I1,V_I1);
1805   VNUMFMT(VT_I2,V_I2);
1806   VNUMFMT(VT_I4,V_I4);
1807   if (HAVE_OLEAUT32_I8)
1808   {
1809     VNUMFMT(VT_I8,V_I8);
1810   }
1811   VNUMFMT(VT_INT,V_INT);
1812   VNUMFMT(VT_UI1,V_UI1);
1813   VNUMFMT(VT_UI2,V_UI2);
1814   VNUMFMT(VT_UI4,V_UI4);
1815   if (HAVE_OLEAUT32_I8)
1816   {
1817     VNUMFMT(VT_UI8,V_UI8);
1818   }
1819   VNUMFMT(VT_UINT,V_UINT);
1820   VNUMFMT(VT_R4,V_R4);
1821   VNUMFMT(VT_R8,V_R8);
1822
1823   /* Reference types are dereferenced */
1824   VARFMT(VT_BOOL|VT_BYREF,V_BOOLREF,&bTrue,"True/False",S_OK,"True");
1825   VARFMT(VT_BOOL|VT_BYREF,V_BOOLREF,&bFalse,"True/False",S_OK,"False");
1826
1827   /* Dates */
1828   for (i = 0; i < sizeof(VarFormat_date_results)/sizeof(FMTDATERES); i++)
1829   {
1830     if (i < 7)
1831       fd = i + 1; /* Test first day */
1832     else
1833       fd = 0;
1834     VARFMT(VT_DATE,V_DATE,VarFormat_date_results[i].val,
1835            VarFormat_date_results[i].fmt,S_OK,
1836            VarFormat_date_results[i].res);
1837   }
1838
1839   /* Strings */
1840   bstrin = SysAllocString(szTesting);
1841   VARFMT(VT_BSTR,V_BSTR,bstrin,"",S_OK,"testing");
1842   VARFMT(VT_BSTR,V_BSTR,bstrin,"@",S_OK,"testing");
1843   VARFMT(VT_BSTR,V_BSTR,bstrin,"&",S_OK,"testing");
1844   VARFMT(VT_BSTR,V_BSTR,bstrin,"\\x@\\x@",S_OK,"xtxesting");
1845   VARFMT(VT_BSTR,V_BSTR,bstrin,"\\x&\\x&",S_OK,"xtxesting");
1846   VARFMT(VT_BSTR,V_BSTR,bstrin,"@\\x",S_OK,"txesting");
1847   VARFMT(VT_BSTR,V_BSTR,bstrin,"@@@@@@@@",S_OK," testing");
1848   VARFMT(VT_BSTR,V_BSTR,bstrin,"@\\x@@@@@@@",S_OK," xtesting");
1849   VARFMT(VT_BSTR,V_BSTR,bstrin,"&&&&&&&&",S_OK,"testing");
1850   VARFMT(VT_BSTR,V_BSTR,bstrin,"!&&&&&&&",S_OK,"testing");
1851   VARFMT(VT_BSTR,V_BSTR,bstrin,"&&&&&&&!",S_OK,"testing");
1852   VARFMT(VT_BSTR,V_BSTR,bstrin,">&&",S_OK,"TESTING");
1853   VARFMT(VT_BSTR,V_BSTR,bstrin,"<&&",S_OK,"testing");
1854   VARFMT(VT_BSTR,V_BSTR,bstrin,"<&>&",S_OK,"testing");
1855   SysFreeString(bstrin);
1856   /* Numeric values are converted to strings then output */
1857   VARFMT(VT_I1,V_I1,1,"<&>&",S_OK,"1");
1858
1859   /* Number formats */
1860   VARFMT(VT_I4,V_I4,1,"#00000000",S_OK,"00000001");
1861   VARFMT(VT_I4,V_I4,1,"000###",S_OK,"000001");
1862   VARFMT(VT_I4,V_I4,1,"#00##00#0",S_OK,"00000001");
1863   VARFMT(VT_I4,V_I4,1,"1#####0000",S_OK,"10001");
1864   todo_wine {
1865   VARFMT(VT_I4,V_I4,100000,"#,###,###,###",S_OK,"100,000");
1866   }
1867   VARFMT(VT_R8,V_R8,1.23456789,"0#.0#0#0#0#0",S_OK,"01.234567890");
1868   VARFMT(VT_R8,V_R8,1.2,"0#.0#0#0#0#0",S_OK,"01.200000000");
1869   VARFMT(VT_R8,V_R8,9.87654321,"#0.#0#0#0#0#",S_OK,"9.87654321");
1870   VARFMT(VT_R8,V_R8,9.8,"#0.#0#0#0#0#",S_OK,"9.80000000");
1871   VARFMT(VT_R8,V_R8,0.00000008,"#0.#0#0#0#0#0",S_OK,"0.0000000800");
1872   VARFMT(VT_R8,V_R8,0.00010705,"#0.##########",S_OK,"0.00010705");
1873   VARFMT(VT_I4,V_I4,17,"#0",S_OK,"17");
1874   VARFMT(VT_I4,V_I4,4711,"#0",S_OK,"4711");
1875   VARFMT(VT_I4,V_I4,17,"#00",S_OK,"17");
1876   VARFMT(VT_I4,V_I4,100,"0##",S_OK,"100");
1877   VARFMT(VT_I4,V_I4,17,"#000",S_OK,"017");
1878   VARFMT(VT_I4,V_I4,17,"#0.00",S_OK,"17.00");
1879   VARFMT(VT_I4,V_I4,17,"#0000.00",S_OK,"0017.00");
1880   VARFMT(VT_I4,V_I4,17,"#.00",S_OK,"17.00");
1881   VARFMT(VT_R8,V_R8,1.7,"#.00",S_OK,"1.70");
1882   VARFMT(VT_R8,V_R8,.17,"#.00",S_OK,".17");
1883   VARFMT(VT_I4,V_I4,17,"#3",S_OK,"173");
1884   VARFMT(VT_I4,V_I4,17,"#33",S_OK,"1733");
1885   VARFMT(VT_I4,V_I4,17,"#3.33",S_OK,"173.33");
1886   VARFMT(VT_I4,V_I4,17,"#3333.33",S_OK,"173333.33");
1887   VARFMT(VT_I4,V_I4,17,"#.33",S_OK,"17.33");
1888   VARFMT(VT_R8,V_R8,.17,"#.33",S_OK,".33");
1889   VARFMT(VT_R8,V_R8,1.7,"0.0000E-000",S_OK,"1.7000E000");
1890   VARFMT(VT_R8,V_R8,1.7,"0.0000e-1",S_OK,"1.7000e01");
1891   VARFMT(VT_R8,V_R8,86.936849,"#0.000000000000e-000",S_OK,"86.936849000000e000");
1892   VARFMT(VT_R8,V_R8,1.7,"#0",S_OK,"2");
1893   VARFMT(VT_R8,V_R8,1.7,"#.33",S_OK,"2.33");
1894   VARFMT(VT_R8,V_R8,1.7,"#3",S_OK,"23");
1895   VARFMT(VT_R8,V_R8,1.73245,"0.0000E+000",S_OK,"1.7325E+000");
1896   VARFMT(VT_R8,V_R8,9.9999999,"#0.000000",S_OK,"10.000000");
1897   VARFMT(VT_R8,V_R8,1.7,"0.0000e+0#",S_OK,"1.7000e+0");
1898   VARFMT(VT_R8,V_R8,100.0001e+0,"0.0000E+0",S_OK,"1.0000E+2");
1899   VARFMT(VT_R8,V_R8,1000001,"0.0000e+1",S_OK,"1.0000e+61");
1900   VARFMT(VT_R8,V_R8,100.0001e+25,"0.0000e+0",S_OK,"1.0000e+27");
1901   VARFMT(VT_R8,V_R8,450.0001e+43,"#000.0000e+0",S_OK,"4500.0010e+42");
1902   VARFMT(VT_R8,V_R8,0.0001e-11,"##00.0000e-0",S_OK,"1000.0000e-18");
1903   VARFMT(VT_R8,V_R8,0.0317e-11,"0000.0000e-0",S_OK,"3170.0000e-16");
1904   VARFMT(VT_R8,V_R8,0.0021e-11,"00##.0000e-0",S_OK,"2100.0000e-17");
1905   VARFMT(VT_R8,V_R8,1.0001e-27,"##00.0000e-0",S_OK,"1000.1000e-30");
1906   VARFMT(VT_R8,V_R8,47.11,".0000E+0",S_OK,".4711E+2");
1907   VARFMT(VT_R8,V_R8,3.0401e-13,"#####.####e-0%",S_OK,"30401.e-15%");
1908
1909
1910   /* 'out' is not cleared */
1911   out = (BSTR)0x1;
1912   pVarFormat(&in,NULL,fd,fw,flags,&out); /* Would crash if out is cleared */
1913   out = NULL;
1914
1915   /* VT_NULL */
1916   V_VT(&in) = VT_NULL;
1917   hres = pVarFormat(&in,NULL,fd,fw,0,&out);
1918   ok(hres == S_OK, "VarFormat failed with 0x%08lx\n", hres);
1919   ok(out == NULL, "expected NULL formatted string\n");
1920
1921   /* Invalid args */
1922   hres = pVarFormat(&in,NULL,fd,fw,flags,NULL);
1923   ok(hres == E_INVALIDARG, "Null out: expected E_INVALIDARG, got 0x%08lx\n", hres);
1924   hres = pVarFormat(NULL,NULL,fd,fw,flags,&out);
1925   ok(hres == E_INVALIDARG, "Null in: expected E_INVALIDARG, got 0x%08lx\n", hres);
1926   fd = -1;
1927   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1928   fd = 8;
1929   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1930   fd = 0; fw = -1;
1931   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1932   fw = 4;
1933   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1934 }
1935
1936 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1937
1938 static const char *szVarAbsFail = "VarAbs: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
1939 #define VARABS(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
1940         memset(&vDst,0,sizeof(vDst)); hres = pVarAbs(&v,&vDst); \
1941         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
1942            szVarAbsFail, VT_##rvt, (int)(rval), \
1943            hres, V_VT(&vDst), (int)V_##rvt(&vDst))
1944
1945 static void test_VarAbs(void)
1946 {
1947     static const WCHAR szNum[] = {'-','1','.','1','\0' };
1948     char buff[8];
1949     HRESULT hres;
1950     VARIANT v, vDst;
1951     size_t i;
1952
1953     CHECKPTR(VarAbs);
1954
1955     /* Test all possible V_VT values.
1956      */
1957     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1958     {
1959         VARTYPE vt;
1960
1961         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1962         {
1963             HRESULT hExpected = DISP_E_BADVARTYPE;
1964
1965             SKIPTESTS(vt);
1966
1967             memset(&v, 0, sizeof(v));
1968             V_VT(&v) = vt | ExtraFlags[i];
1969             V_VT(&vDst) = VT_EMPTY;
1970
1971             hres = pVarAbs(&v,&vDst);
1972             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1973                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1974                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1975             {
1976                 hExpected = DISP_E_TYPEMISMATCH;
1977             }
1978             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1979             {
1980                 hExpected = DISP_E_BADVARTYPE;
1981             }
1982             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1983                 hExpected = S_OK;
1984
1985             /* Native always fails on some vartypes that should be valid. don't
1986              * check that Wine does the same; these are bugs in native.
1987              */
1988             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1989                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1990                 continue;
1991             ok(hres == hExpected, "VarAbs: expected 0x%lX, got 0x%lX for vt %d | 0x%X\n",
1992                hExpected, hres, vt, ExtraFlags[i]);
1993         }
1994     }
1995
1996     /* BOOL->I2, BSTR->R8, all others remain the same */
1997     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1998     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1999     VARABS(EMPTY,0,I2,0);
2000     VARABS(EMPTY,1,I2,0);
2001     VARABS(NULL,0,NULL,0);
2002     VARABS(NULL,1,NULL,0);
2003     VARABS(I2,1,I2,1);
2004     VARABS(I2,-1,I2,1);
2005     VARABS(I4,1,I4,1);
2006     VARABS(I4,-1,I4,1);
2007     VARABS(UI1,1,UI1,1);
2008     VARABS(R4,1,R4,1);
2009     VARABS(R4,-1,R4,1);
2010     VARABS(R8,1,R8,1);
2011     VARABS(R8,-1,R8,1);
2012     VARABS(DATE,1,DATE,1);
2013     VARABS(DATE,-1,DATE,1);
2014     V_VT(&v) = VT_CY;
2015     V_CY(&v).int64 = -10000;
2016     memset(&vDst,0,sizeof(vDst));
2017     hres = pVarAbs(&v,&vDst);
2018     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
2019        "VarAbs(CY): expected 0x0 got 0x%lX\n", hres);
2020     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
2021     if (buff[0] != '.' || buff[1])
2022     {
2023         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
2024         return;
2025     }
2026     V_VT(&v) = VT_BSTR;
2027     V_BSTR(&v) = (BSTR)szNum;
2028     memset(&vDst,0,sizeof(vDst));
2029     hres = pVarAbs(&v,&vDst);
2030     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
2031        "VarAbs: expected 0x0,%d,%g, got 0x%lX,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
2032 }
2033
2034 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
2035
2036 static const char *szVarNotFail = "VarNot: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2037 #define VARNOT(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2038         memset(&vDst,0,sizeof(vDst)); hres = pVarNot(&v,&vDst); \
2039         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2040         szVarNotFail, VT_##rvt, (int)(rval), \
2041         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2042
2043 static void test_VarNot(void)
2044 {
2045     static const WCHAR szNum0[] = {'0','\0' };
2046     static const WCHAR szNum1[] = {'1','\0' };
2047     HRESULT hres;
2048     VARIANT v, vDst;
2049     DECIMAL *pdec = &V_DECIMAL(&v);
2050     CY *pcy = &V_CY(&v);
2051     size_t i;
2052
2053     CHECKPTR(VarNot);
2054
2055     /* Test all possible V_VT values */
2056     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2057     {
2058         VARTYPE vt;
2059
2060         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2061         {
2062             HRESULT hExpected = DISP_E_BADVARTYPE;
2063
2064             SKIPTESTS(vt);
2065
2066             memset(&v, 0, sizeof(v));
2067             V_VT(&v) = vt | ExtraFlags[i];
2068             V_VT(&vDst) = VT_EMPTY;
2069
2070             switch (V_VT(&v))
2071             {
2072             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
2073             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
2074             case VT_R4:  case VT_R8:
2075             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2076             case VT_DATE: case VT_CY:
2077                 hExpected = S_OK;
2078                 break;
2079             case VT_I8: case VT_UI8:
2080                 if (HAVE_OLEAUT32_I8)
2081                     hExpected = S_OK;
2082                 break;
2083             case VT_RECORD:
2084                 if (HAVE_OLEAUT32_RECORD)
2085                     hExpected = DISP_E_TYPEMISMATCH;
2086                 break;
2087             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
2088                 hExpected = DISP_E_TYPEMISMATCH;
2089                 break;
2090             default:
2091                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
2092                    hExpected = DISP_E_TYPEMISMATCH;
2093                 break;
2094             }
2095
2096             hres = pVarNot(&v,&vDst);
2097             ok(hres == hExpected, "VarNot: expected 0x%lX, got 0x%lX vt %d|0x%X\n",
2098                hExpected, hres, vt, ExtraFlags[i]);
2099         }
2100     }
2101     /* Test the values returned by all cases that can succeed */
2102     VARNOT(EMPTY,0,I2,-1);
2103     VARNOT(EMPTY,1,I2,-1);
2104     VARNOT(NULL,0,NULL,0);
2105     VARNOT(NULL,1,NULL,0);
2106     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
2107     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
2108     VARNOT(I1,-1,I4,0);
2109     VARNOT(I1,0,I4,-1);
2110     VARNOT(I2,-1,I2,0);
2111     VARNOT(I2,0,I2,-1);
2112     VARNOT(I2,1,I2,-2);
2113     VARNOT(I4,1,I4,-2);
2114     VARNOT(I4,0,I4,-1);
2115     VARNOT(UI1,1,UI1,254);
2116     VARNOT(UI1,0,UI1,255);
2117     VARNOT(UI2,0,I4,-1);
2118     VARNOT(UI2,1,I4,-2);
2119     VARNOT(UI4,0,I4,-1);
2120     VARNOT(UI4,1,I4,-2);
2121     VARNOT(INT,0,I4,-1);
2122     VARNOT(INT,1,I4,-2);
2123     VARNOT(UINT,0,I4,-1);
2124     VARNOT(UINT,1,I4,-2);
2125     if (HAVE_OLEAUT32_I8)
2126     {
2127         VARNOT(I8,1,I8,-2);
2128         VARNOT(I8,0,I8,-1);
2129         VARNOT(UI8,0,I4,-1);
2130         VARNOT(UI8,1,I4,-2);
2131     }
2132     VARNOT(R4,1,I4,-2);
2133     VARNOT(R4,0,I4,-1);
2134     VARNOT(R8,1,I4,-2);
2135     VARNOT(R8,0,I4,-1);
2136     VARNOT(DATE,1,I4,-2);
2137     VARNOT(DATE,0,I4,-1);
2138     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
2139     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
2140     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
2141     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
2142
2143     V_VT(&v) = VT_DECIMAL;
2144     S(U(*pdec)).sign = DECIMAL_NEG;
2145     S(U(*pdec)).scale = 0;
2146     pdec->Hi32 = 0;
2147     S1(U1(*pdec)).Mid32 = 0;
2148     S1(U1(*pdec)).Lo32 = 1;
2149     VARNOT(DECIMAL,*pdec,I4,0);
2150
2151     pcy->int64 = 10000;
2152     VARNOT(CY,*pcy,I4,-2);
2153
2154     pcy->int64 = 0;
2155     VARNOT(CY,*pcy,I4,-1);
2156
2157     pcy->int64 = -1;
2158     VARNOT(CY,*pcy,I4,-1);
2159 }
2160 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
2161
2162 static void test_VarSub(void)
2163 {
2164     VARIANT va, vb, vc;
2165     HRESULT hr;
2166
2167     CHECKPTR(VarSub);
2168
2169     V_VT(&va) = VT_DATE;
2170     V_DATE(&va) = 200000.0;
2171     V_VT(&vb) = VT_DATE;
2172     V_DATE(&vb) = 100000.0;
2173
2174     hr = pVarSub(&va, &vb, &vc);
2175     ok(hr == S_OK,"VarSub of VT_DATE - VT_DATE failed with %lx\n", hr);
2176     ok(V_VT(&vc) == VT_R8,"VarSub of VT_DATE - VT_DATE returned vt 0x%x\n", V_VT(&vc));
2177     ok(((V_R8(&vc) >  99999.9) && (V_R8(&vc) < 100000.1)),"VarSub of VT_DATE - VT_DATE  should return 100000.0, but returned %g\n", V_R8(&vc));
2178     /* fprintf(stderr,"VarSub of 10000-20000 returned: %g\n", V_R8(&vc)); */
2179 }
2180
2181 static const char *szVarModFail = "VarMod: expected 0x%lx,%d(%s),%d, got 0x%lX,%d(%s),%d\n";
2182 #define VARMOD(vt1,vt2,val1,val2,rvt,rval,hexpected) V_VT(&v1) = VT_##vt1; V_##vt1(&v1) = val1; \
2183         V_VT(&v2) = VT_##vt2; V_##vt2(&v2) = val2;                  \
2184         memset(&vDst,0,sizeof(vDst)); hres = pVarMod(&v1,&v2,&vDst);                    \
2185         ok(hres == hexpected && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2186         szVarModFail, hexpected, VT_##rvt, vtstr(VT_##rvt), (int)(rval), \
2187         hres, V_VT(&vDst), vtstr(V_VT(&vDst)), (int)V_##rvt(&vDst))
2188
2189 static const char *szVarMod2Fail = "VarMod: expected 0x%lx,%d(%s),%d, got 0x%lX,%d(%s),%d\n";
2190 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected) V_VT(&v1) = VT_##vt1; V_I4(&v1) = val1; \
2191         V_VT(&v2) = VT_##vt2; V_I4(&v2) = val2;                                \
2192         memset(&vDst,0,sizeof(vDst)); hres = pVarMod(&v1,&v2,&vDst);                     \
2193         ok(hres == hexpected && V_VT(&vDst) == VT_##rvt && V_I4(&vDst) == (rval), \
2194         szVarMod2Fail, hexpected, VT_##rvt, vtstr(VT_##rvt), (int)(rval), \
2195         hres, V_VT(&vDst), vtstr(V_VT(&vDst)), (int)V_I4(&vDst))
2196
2197 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2198
2199 static void test_VarMod(void)
2200 {
2201   VARIANT v1, v2, vDst;
2202   HRESULT hres;
2203   HRESULT hexpected = 0;
2204   static const WCHAR szNum0[] = {'1','2','5','\0'};
2205   static const WCHAR szNum1[] = {'1','0','\0'};
2206   int l, r;
2207   BOOL lFound, rFound;
2208   BOOL lValid, rValid;
2209   BSTR strNum0, strNum1;
2210
2211   CHECKPTR(VarMod);
2212
2213   VARMOD(I1,BOOL,100,10,I4,0,S_OK);
2214   VARMOD(I1,I1,100,10,I4,0,S_OK);
2215   VARMOD(I1,UI1,100,10,I4,0,S_OK);
2216   VARMOD(I1,I2,100,10,I4,0,S_OK);
2217   VARMOD(I1,UI2,100,10,I4,0,S_OK);
2218   VARMOD(I1,I4,100,10,I4,0,S_OK);
2219   VARMOD(I1,UI4,100,10,I4,0,S_OK);
2220   VARMOD(I1,R4,100,10,I4,0,S_OK);
2221   VARMOD(I1,R8,100,10,I4,0,S_OK);
2222
2223   VARMOD(UI1,BOOL,100,10,I2,0,S_OK);
2224   VARMOD(UI1,I1,100,10,I4,0,S_OK);
2225   VARMOD(UI1,UI1,100,10,UI1,0,S_OK);
2226   VARMOD(UI1,I2,100,10,I2,0,S_OK);
2227   VARMOD(UI1,UI2,100,10,I4,0,S_OK);
2228   VARMOD(UI1,I4,100,10,I4,0,S_OK);
2229   VARMOD(UI1,UI4,100,10,I4,0,S_OK);
2230   VARMOD(UI1,R4,100,10,I4,0,S_OK);
2231   VARMOD(UI1,R8,100,10,I4,0,S_OK);
2232
2233   VARMOD(I2,BOOL,100,10,I2,0,S_OK);
2234   VARMOD(I2,I1,100,10,I4,0,S_OK);
2235   VARMOD(I2,UI1,100,10,I2,0,S_OK);
2236   VARMOD(I2,I2,100,10,I2,0,S_OK);
2237   VARMOD(I2,UI2,100,10,I4,0,S_OK);
2238   VARMOD(I2,I4,100,10,I4,0,S_OK);
2239   VARMOD(I2,UI4,100,10,I4,0,S_OK);
2240   VARMOD(I2,R4,100,10,I4,0,S_OK);
2241   VARMOD(I2,R8,100,10,I4,0,S_OK);
2242
2243   VARMOD(I4,BOOL,100,10,I4,0,S_OK);
2244   VARMOD(I4,I1,100,10,I4,0,S_OK);
2245   VARMOD(I4,UI1,100,10,I4,0,S_OK);
2246   VARMOD(I4,I2,100,10,I4,0,S_OK);
2247   VARMOD(I4,UI2,100,10,I4,0,S_OK);
2248   VARMOD(I4,I4,100,10,I4,0,S_OK);
2249   VARMOD(I4,UI4,100,10,I4,0,S_OK);
2250   VARMOD(I4,R4,100,10,I4,0,S_OK);
2251   VARMOD(I4,R8,100,10,I4,0,S_OK);
2252   VARMOD(UI4,BOOL,100,10,I4,0,S_OK);
2253   VARMOD(UI4,I1,100,10,I4,0,S_OK);
2254   VARMOD(UI4,UI1,100,10,I4,0,S_OK);
2255   VARMOD(UI4,I2,100,10,I4,0,S_OK);
2256   VARMOD(UI4,UI2,100,10,I4,0,S_OK);
2257   VARMOD(UI4,I4,100,10,I4,0,S_OK);
2258   VARMOD(UI4,UI4,100,10,I4,0,S_OK);
2259   VARMOD(UI4,R4,100,10,I4,0,S_OK);
2260   VARMOD(UI4,R8,100,10,I4,0,S_OK);
2261   VARMOD(R4,BOOL,100,10,I4,0,S_OK);
2262   VARMOD(R4,I1,100,10,I4,0,S_OK);
2263   VARMOD(R4,UI1,100,10,I4,0,S_OK);
2264   VARMOD(R4,I2,100,10,I4,0,S_OK);
2265   VARMOD(R4,UI2,100,10,I4,0,S_OK);
2266   VARMOD(R4,I4,100,10,I4,0,S_OK);
2267   VARMOD(R4,UI4,100,10,I4,0,S_OK);
2268   VARMOD(R4,R4,100,10,I4,0,S_OK);
2269   VARMOD(R4,R8,100,10,I4,0,S_OK);
2270   VARMOD(R8,BOOL,100,10,I4,0,S_OK);
2271   VARMOD(R8,I1,100,10,I4,0,S_OK);
2272   VARMOD(R8,UI1,100,10,I4,0,S_OK);
2273   VARMOD(R8,I2,100,10,I4,0,S_OK);
2274   VARMOD(R8,UI2,100,10,I4,0,S_OK);
2275   VARMOD(R8,I4,100,10,I4,0,S_OK);
2276   VARMOD(R8,UI4,100,10,I4,0,S_OK);
2277   VARMOD(R8,R4,100,10,I4,0,S_OK);
2278   VARMOD(R8,R8,100,10,I4,0,S_OK);
2279
2280   VARMOD(INT,INT,100,10,I4,0,S_OK);
2281   VARMOD(INT,UINT,100,10,I4,0,S_OK);
2282
2283   VARMOD(BOOL,BOOL,100,10,I2,0,S_OK);
2284   VARMOD(BOOL,I1,100,10,I4,0,S_OK);
2285   VARMOD(BOOL,UI1,100,10,I2,0,S_OK);
2286   VARMOD(BOOL,I2,100,10,I2,0,S_OK);
2287   VARMOD(BOOL,UI2,100,10,I4,0,S_OK);
2288   VARMOD(BOOL,I4,100,10,I4,0,S_OK);
2289   VARMOD(BOOL,UI4,100,10,I4,0,S_OK);
2290   VARMOD(BOOL,R4,100,10,I4,0,S_OK);
2291   VARMOD(BOOL,R8,100,10,I4,0,S_OK);
2292   VARMOD(BOOL,DATE,100,10,I4,0,S_OK);
2293
2294   VARMOD(DATE,BOOL,100,10,I4,0,S_OK);
2295   VARMOD(DATE,I1,100,10,I4,0,S_OK);
2296   VARMOD(DATE,UI1,100,10,I4,0,S_OK);
2297   VARMOD(DATE,I2,100,10,I4,0,S_OK);
2298   VARMOD(DATE,UI2,100,10,I4,0,S_OK);
2299   VARMOD(DATE,I4,100,10,I4,0,S_OK);
2300   VARMOD(DATE,UI4,100,10,I4,0,S_OK);
2301   VARMOD(DATE,R4,100,10,I4,0,S_OK);
2302   VARMOD(DATE,R8,100,10,I4,0,S_OK);
2303   VARMOD(DATE,DATE,100,10,I4,0,S_OK);
2304
2305   strNum0 = SysAllocString(szNum0);
2306   strNum1 = SysAllocString(szNum1);
2307   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5,S_OK);
2308   VARMOD(BSTR,I1,strNum0,10,I4,5,S_OK);
2309   VARMOD(BSTR,I2,strNum0,10,I4,5,S_OK);
2310   VARMOD(BSTR,I4,strNum0,10,I4,5,S_OK);
2311   VARMOD(BSTR,R4,strNum0,10,I4,5,S_OK);
2312   VARMOD(BSTR,R8,strNum0,10,I4,5,S_OK);
2313   VARMOD(I4,BSTR,125,strNum1,I4,5,S_OK);
2314
2315   if (HAVE_OLEAUT32_I8)
2316   {
2317     VARMOD(BOOL,I8,100,10,I8,0,S_OK);
2318     VARMOD(I1,I8,100,10,I8,0,S_OK);
2319     VARMOD(UI1,I8,100,10,I8,0,S_OK);
2320     VARMOD(I2,I8,100,10,I8,0,S_OK);
2321     VARMOD(I4,I8,100,10,I8,0,S_OK);
2322     VARMOD(UI4,I8,100,10,I8,0,S_OK);
2323     VARMOD(R4,I8,100,10,I8,0,S_OK);
2324     VARMOD(R8,I8,100,10,I8,0,S_OK);
2325     VARMOD(DATE,I8,100,10,I8,0,S_OK);
2326
2327     VARMOD(I8,BOOL,100,10,I8,0,S_OK);
2328     VARMOD(I8,I1,100,10,I8,0,S_OK);
2329     VARMOD(I8,UI1,100,10,I8,0,S_OK);
2330     VARMOD(I8,I2,100,10,I8,0,S_OK);
2331     VARMOD(I8,UI2,100,10,I8,0,S_OK);
2332     VARMOD(I8,I4,100,10,I8,0,S_OK);
2333     VARMOD(I8,UI4,100,10,I8,0,S_OK);
2334     VARMOD(I8,R4,100,10,I8,0,S_OK);
2335     VARMOD(I8,R8,100,10,I8,0,S_OK);
2336     VARMOD(I8,I8,100,10,I8,0,S_OK);
2337
2338     VARMOD(BSTR,I8,strNum0,10,I8,5,S_OK);
2339   }
2340
2341   /* test all combinations of types */
2342   for(l = 0; l < VT_BSTR_BLOB; l++)
2343   {
2344     SKIPTESTS(l);
2345
2346     for(r = 0; r < VT_BSTR_BLOB; r++)
2347     {
2348       SKIPTESTS(r);
2349
2350       if(l == VT_BSTR) continue;
2351       if(l == VT_DISPATCH) continue;
2352       if(r == VT_BSTR) continue;
2353       if(r == VT_DISPATCH) continue;
2354
2355       lFound = TRUE;
2356       lValid = TRUE;
2357       switch(l)
2358         {
2359         case VT_EMPTY:
2360         case VT_NULL:
2361         case VT_I1:
2362         case VT_UI1:
2363         case VT_I2:
2364         case VT_UI2:
2365         case VT_I4:
2366         case VT_I8:
2367         case VT_UI4:
2368         case VT_UI8:
2369         case VT_INT:
2370         case VT_UINT:
2371         case VT_R4:
2372         case VT_R8:
2373         case VT_BOOL:
2374         case VT_DATE:
2375         case VT_CY:
2376           hexpected = S_OK;
2377           break;
2378         case VT_ERROR:
2379         case VT_VARIANT:
2380         case VT_UNKNOWN:
2381         case VT_DECIMAL:
2382         case VT_RECORD:
2383           lValid = FALSE;
2384           break;
2385         default:
2386           lFound = FALSE;
2387           hexpected = DISP_E_BADVARTYPE;
2388           break;
2389         }
2390
2391       rFound = TRUE;
2392       rValid = TRUE;
2393       switch(r)
2394         {
2395         case VT_EMPTY:
2396         case VT_NULL:
2397         case VT_I1:
2398         case VT_UI1:
2399         case VT_I2:
2400         case VT_UI2:
2401         case VT_I4:
2402         case VT_I8:
2403         case VT_UI4:
2404         case VT_UI8:
2405         case VT_INT:
2406         case VT_UINT:
2407         case VT_R4:
2408         case VT_R8:
2409         case VT_BOOL:
2410         case VT_DATE:
2411         case VT_CY:
2412           hexpected = S_OK;
2413           break;
2414         case VT_ERROR:
2415         case VT_VARIANT:
2416         case VT_UNKNOWN:
2417         case VT_DECIMAL:
2418         case VT_RECORD:
2419           rValid = FALSE;
2420           break;
2421         default:
2422           rFound = FALSE;
2423           break;
2424         }
2425
2426       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2427       {
2428         hexpected = DISP_E_TYPEMISMATCH;
2429       } else if((l == VT_EMPTY) && (r == VT_NULL))
2430       {
2431         hexpected = S_OK;
2432       } else if((l == VT_NULL) && (r == VT_EMPTY))
2433       {
2434         hexpected = S_OK;
2435       } else if((l == VT_EMPTY) && (r == VT_CY))
2436       {
2437         hexpected = S_OK;
2438       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2439       {
2440         hexpected = DISP_E_TYPEMISMATCH;
2441       } else if((r == VT_EMPTY) && lFound && lValid)
2442       {
2443         hexpected = DISP_E_DIVBYZERO;
2444       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2445       {
2446         hexpected = DISP_E_TYPEMISMATCH;
2447       } else if((l == VT_NULL) && (r == VT_NULL))
2448       {
2449         hexpected = S_OK;
2450       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2451       {
2452         hexpected = DISP_E_TYPEMISMATCH;
2453       } else if((l == VT_NULL) && (r == VT_RECORD))
2454       {
2455         hexpected = DISP_E_TYPEMISMATCH;
2456       } else if((l == VT_NULL) && (r == VT_DECIMAL))
2457       {
2458         hexpected = DISP_E_OVERFLOW;
2459       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2460       {
2461         hexpected = DISP_E_TYPEMISMATCH;
2462       } else if((l == VT_NULL) && rFound)
2463       {
2464         hexpected = S_OK;
2465       } else if((l == VT_DECIMAL) || ((r == VT_DECIMAL) && lFound && lValid))
2466       {
2467         hexpected = DISP_E_OVERFLOW;
2468       } else if(l == VT_RECORD)
2469       {
2470         hexpected = DISP_E_TYPEMISMATCH;
2471       } else if((r == VT_RECORD) && lValid && lFound)
2472       {
2473         hexpected = DISP_E_TYPEMISMATCH;
2474       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2475       {
2476         hexpected = DISP_E_DIVBYZERO;
2477       } else if((l == VT_CY) && !rFound)
2478       {
2479         hexpected = DISP_E_BADVARTYPE;
2480       } else if(lFound && !rFound)
2481       {
2482         hexpected = DISP_E_BADVARTYPE;
2483       } else if(!lFound && rFound)
2484       {
2485         hexpected = DISP_E_BADVARTYPE;
2486       } else if((r == VT_NULL) && lFound && lValid)
2487       {
2488         hexpected = S_OK;
2489       } else if((l == VT_NULL) || (r == VT_NULL))
2490       {
2491         hexpected = DISP_E_BADVARTYPE;
2492       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2493       {
2494         hexpected = DISP_E_BADVARTYPE;
2495       } else if(lFound && !rFound)
2496       {
2497         hexpected = DISP_E_BADVARTYPE;
2498       } else if(!lFound && !rFound)
2499       {
2500         hexpected = DISP_E_BADVARTYPE;
2501       }
2502
2503       V_VT(&v1) = l;
2504       V_VT(&v2) = r;
2505
2506       if(l == VT_CY)
2507         V_CY(&v1).int64 = 1000000;
2508       else if(l == VT_R4)
2509         V_R4(&v1) = 100;
2510       else if(l == VT_R8)
2511         V_R8(&v1) = 100;
2512       else if(l == VT_UI8)
2513         V_UI8(&v1) = 100;
2514       else if(l == VT_DATE)
2515         V_DATE(&v1) = 1000;
2516       else
2517         V_I4(&v1) = 10000;
2518
2519       if(r == VT_CY)
2520         V_CY(&v2).int64 = 10000;
2521       else if(r == VT_R4)
2522         V_R4(&v2) = 100;
2523       else if(r == VT_R8)
2524         V_R8(&v2) = 100;
2525       else if(r == VT_UI8)
2526         V_UI8(&v2) = 100;
2527       else if(r == VT_DATE)
2528         V_DATE(&v2) = 1000;
2529       else
2530         V_I4(&v2) = 10000;
2531
2532       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2533       {
2534         hres = pVarMod(&v1,&v2,&vDst);
2535         ok(hres == hexpected,
2536            "VarMod: expected 0x%lx, got 0x%lX for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2537       }
2538     }
2539   }
2540
2541
2542   /****************************/
2543   /* test some bad parameters */
2544   VARMOD(I4,I4,-1,-1,I4,0,S_OK);
2545
2546   /* test modulus with zero */
2547   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2548
2549   VARMOD(I4,I4,0,10,I4,0,S_OK); /* test 0 mod 10 */
2550
2551   /* right parameter is type empty */
2552   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2553
2554   /* left parameter is type empty */
2555   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2556
2557   /* mod with a null left value */
2558   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2559
2560   /* mod with a null right value */
2561   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2562
2563   /* void left value */
2564   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2565
2566   /* void right value */
2567   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2568
2569   /* null left value, void right value */
2570   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2571
2572   /* void left value, null right value */
2573   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2574
2575   /* some currencies */
2576   V_VT(&v1) = VT_CY;
2577   V_VT(&v2) = VT_CY;
2578   V_CY(&v1).int64 = 100000;
2579   V_CY(&v2).int64 = 100000;
2580   hres = pVarMod(&v1,&v2,&vDst);
2581   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2582      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2583
2584   V_VT(&v1) = VT_I4;
2585   V_VT(&v2) = VT_CY;
2586   V_I4(&v1) = 100;
2587   V_CY(&v2).int64 = 100000;
2588   hres = pVarMod(&v1,&v2,&vDst);
2589   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2590      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2591
2592   /* some decimals */
2593   todo_wine {
2594   V_VT(&v1) = VT_DECIMAL;
2595   V_VT(&v2) = VT_DECIMAL;
2596   VarDecFromI4(100, &V_DECIMAL(&v1));
2597   VarDecFromI4(10, &V_DECIMAL(&v2));
2598   hres = pVarMod(&v1,&v2,&vDst);
2599   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2600      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2601
2602   V_VT(&v1) = VT_I4;
2603   V_VT(&v2) = VT_DECIMAL;
2604   V_I4(&v1) = 100;
2605   VarDecFromI4(10, &V_DECIMAL(&v2));
2606   hres = pVarMod(&v1,&v2,&vDst);
2607   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2608      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2609   }
2610
2611   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2612
2613   /* test that an error results in the type of the result changing but not its value */
2614   V_VT(&v1) = VT_UNKNOWN;
2615   V_VT(&v2) = VT_EMPTY;
2616   V_I4(&v1) = 100;
2617   V_CY(&v2).int64 = 100000;
2618   V_VT(&vDst) = VT_I4;
2619   V_I4(&vDst) = 1231;
2620   hres = pVarMod(&v1,&v2,&vDst);
2621   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2622      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", DISP_E_TYPEMISMATCH, VT_EMPTY, 1231, hres, V_VT(&vDst), V_I4(&vDst));
2623
2624
2625   /* test some invalid types */
2626   /*TODO: not testing VT_DISPATCH */
2627   if (HAVE_OLEAUT32_I8)
2628   {
2629     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2630   }
2631   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2632   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2633   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2634   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2635   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2636   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2637   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2638   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2639   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2640   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2641   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2642   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2643   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2644   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2645   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2646   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2647   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2648   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2649   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2650   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2651   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2652   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2653   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2654   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2655
2656   /* test some more invalid types */
2657   V_VT(&v1) = 456;
2658   V_VT(&v2) = 234;
2659   V_I4(&v1) = 100;
2660   V_I4(&v2)=  10;
2661   hres = pVarMod(&v1,&v2,&vDst);
2662   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 0,
2663      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", DISP_E_BADVARTYPE, VT_EMPTY, 0, hres, V_VT(&vDst), V_I4(&vDst));
2664 }
2665
2666 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2667
2668 static const char *szVarFixFail = "VarFix: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2669 #define VARFIX(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2670         memset(&vDst,0,sizeof(vDst)); hres = pVarFix(&v,&vDst); \
2671         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2672         szVarFixFail, VT_##rvt, (int)(rval), \
2673         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2674
2675 static void test_VarFix(void)
2676 {
2677     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2678     HRESULT hres;
2679     VARIANT v, vDst;
2680     DECIMAL *pdec = &V_DECIMAL(&v);
2681     CY *pcy = &V_CY(&v);
2682     size_t i;
2683
2684     CHECKPTR(VarFix);
2685
2686     /* Test all possible V_VT values */
2687     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2688     {
2689         VARTYPE vt;
2690
2691         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2692         {
2693             HRESULT bFail = TRUE;
2694
2695             SKIPTESTS(vt);
2696
2697             memset(&v, 0, sizeof(v));
2698             V_VT(&v) = vt | ExtraFlags[i];
2699             V_VT(&vDst) = VT_EMPTY;
2700
2701             switch (V_VT(&v))
2702             {
2703               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2704               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2705               case VT_DATE: case VT_CY:
2706                 bFail = FALSE;
2707                 break;
2708               case VT_I8:
2709                 if (HAVE_OLEAUT32_I8)
2710                   bFail = FALSE;
2711                 break;
2712             }
2713
2714             hres = pVarFix(&v,&vDst);
2715             if (bFail)
2716               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2717                  "VarFix: expected failure, got 0x%lX vt %d|0x%X\n",
2718                  hres, vt, ExtraFlags[i]);
2719             else
2720                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%lX vt %d|0x%X\n",
2721                     hres, vt, ExtraFlags[i]);
2722         }
2723     }
2724
2725     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2726     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2727     VARFIX(BOOL,1,I2,1);
2728     VARFIX(UI1,1,UI1,1);
2729     VARFIX(I2,-1,I2,-1);
2730     VARFIX(I4,-1,I4,-1);
2731     if (HAVE_OLEAUT32_I8)
2732     {
2733         VARFIX(I8,-1,I8,-1);
2734     }
2735     VARFIX(R4,1.4,R4,1);
2736     VARFIX(R4,1.5,R4,1);
2737     VARFIX(R4,1.6,R4,1);
2738     VARFIX(R4,-1.4,R4,-1);
2739     VARFIX(R4,-1.5,R4,-1);
2740     VARFIX(R4,-1.6,R4,-1);
2741     /* DATE & R8 round as for R4 */
2742     VARFIX(DATE,-1,DATE,-1);
2743     VARFIX(R8,-1,R8,-1);
2744     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2745
2746     V_VT(&v) = VT_EMPTY;
2747     hres = pVarFix(&v,&vDst);
2748     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2749        "VarFix: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2750        hres, V_VT(&vDst), V_I2(&vDst));
2751
2752     V_VT(&v) = VT_NULL;
2753     hres = pVarFix(&v,&vDst);
2754     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2755        "VarFix: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2756
2757     V_VT(&v) = VT_DECIMAL;
2758     S(U(*pdec)).sign = DECIMAL_NEG;
2759     S(U(*pdec)).scale = 0;
2760     pdec->Hi32 = 0;
2761     S1(U1(*pdec)).Mid32 = 0;
2762     S1(U1(*pdec)).Lo32 = 1;
2763     hres = pVarFix(&v,&vDst);
2764     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2765        "VarFix: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
2766        hres, V_VT(&vDst));
2767
2768     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2769
2770     V_VT(&v) = VT_CY;
2771     pcy->int64 = -10000;
2772     hres = pVarFix(&v,&vDst);
2773     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2774        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
2775
2776     V_VT(&v) = VT_CY;
2777     pcy->int64 = -16000;
2778     hres = pVarFix(&v,&vDst);
2779     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2780        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
2781 }
2782
2783 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2784
2785 static const char *szVarIntFail = "VarInt: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2786 #define VARINT(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2787         memset(&vDst,0,sizeof(vDst)); hres = pVarInt(&v,&vDst); \
2788         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2789         szVarIntFail, VT_##rvt, (int)(rval), \
2790         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2791
2792 static void test_VarInt(void)
2793 {
2794     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2795     HRESULT hres;
2796     VARIANT v, vDst;
2797     DECIMAL *pdec = &V_DECIMAL(&v);
2798     CY *pcy = &V_CY(&v);
2799     size_t i;
2800
2801     CHECKPTR(VarInt);
2802
2803     /* Test all possible V_VT values */
2804     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2805     {
2806         VARTYPE vt;
2807
2808         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2809         {
2810             HRESULT bFail = TRUE;
2811
2812             SKIPTESTS(vt);
2813
2814             memset(&v, 0, sizeof(v));
2815             V_VT(&v) = vt | ExtraFlags[i];
2816             V_VT(&vDst) = VT_EMPTY;
2817
2818             switch (V_VT(&v))
2819             {
2820               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2821               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2822               case VT_DATE: case VT_CY:
2823                 bFail = FALSE;
2824                 break;
2825               case VT_I8:
2826                 if (HAVE_OLEAUT32_I8)
2827                   bFail = FALSE;
2828                 break;
2829             }
2830
2831             hres = pVarInt(&v,&vDst);
2832             if (bFail)
2833               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2834                  "VarInt: expected failure, got 0x%lX vt %d|0x%X\n",
2835                  hres, vt, ExtraFlags[i]);
2836             else
2837                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%lX vt %d|0x%X\n",
2838                     hres, vt, ExtraFlags[i]);
2839         }
2840     }
2841
2842     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2843     VARINT(BOOL,VARIANT_FALSE,I2,0);
2844     VARINT(BOOL,1,I2,1);
2845     VARINT(UI1,1,UI1,1);
2846     VARINT(I2,-1,I2,-1);
2847     VARINT(I4,-1,I4,-1);
2848     if (HAVE_OLEAUT32_I8)
2849     {
2850         VARINT(I8,-1,I8,-1);
2851     }
2852     VARINT(R4,1.4,R4,1);
2853     VARINT(R4,1.5,R4,1);
2854     VARINT(R4,1.6,R4,1);
2855     VARINT(R4,-1.4,R4,-2); /* Note these 3 are different from VarFix */
2856     VARINT(R4,-1.5,R4,-2);
2857     VARINT(R4,-1.6,R4,-2);
2858     /* DATE & R8 round as for R4 */
2859     VARINT(DATE,-1,DATE,-1);
2860     VARINT(R8,-1,R8,-1);
2861     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
2862
2863     V_VT(&v) = VT_EMPTY;
2864     hres = pVarInt(&v,&vDst);
2865     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2866        "VarInt: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2867        hres, V_VT(&vDst), V_I2(&vDst));
2868
2869     V_VT(&v) = VT_NULL;
2870     hres = pVarInt(&v,&vDst);
2871     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2872        "VarInt: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2873
2874     V_VT(&v) = VT_DECIMAL;
2875     S(U(*pdec)).sign = DECIMAL_NEG;
2876     S(U(*pdec)).scale = 0;
2877     pdec->Hi32 = 0;
2878     S1(U1(*pdec)).Mid32 = 0;
2879     S1(U1(*pdec)).Lo32 = 1;
2880     hres = pVarInt(&v,&vDst);
2881     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2882        "VarInt: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
2883        hres, V_VT(&vDst));
2884
2885     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
2886
2887     V_VT(&v) = VT_CY;
2888     pcy->int64 = -10000;
2889     hres = pVarInt(&v,&vDst);
2890     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2891        "VarInt: VT_CY wrong, hres=0x%lX\n", hres);
2892
2893     V_VT(&v) = VT_CY;
2894     pcy->int64 = -11000;
2895     hres = pVarInt(&v,&vDst);
2896     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
2897        "VarInt: VT_CY wrong, hres=0x%lX %lld\n", hres,V_CY(&vDst).int64);
2898 }
2899
2900 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
2901
2902 static const char *szVarNegFail = "VarNeg: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2903 #define VARNEG(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2904         memset(&vDst,0,sizeof(vDst)); hres = pVarNeg(&v,&vDst); \
2905         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2906         szVarNegFail, VT_##rvt, (int)(rval), \
2907         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2908
2909 static void test_VarNeg(void)
2910 {
2911     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2912     static const WCHAR szNum1[] = {'1','\0' };
2913     HRESULT hres;
2914     VARIANT v, vDst;
2915     DECIMAL *pdec = &V_DECIMAL(&v);
2916     CY *pcy = &V_CY(&v);
2917     size_t i;
2918
2919     CHECKPTR(VarNeg);
2920
2921     /* Test all possible V_VT values. But don't test the exact return values
2922      * except for success/failure, since M$ made a hash of them in the
2923      * native version. This at least ensures (as with all tests here) that
2924      * we will notice if/when new vtypes/flags are added in native.
2925      */
2926     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2927     {
2928         VARTYPE vt;
2929
2930         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2931         {
2932             HRESULT bFail = TRUE;
2933
2934             SKIPTESTS(vt);
2935
2936             memset(&v, 0, sizeof(v));
2937             V_VT(&v) = vt | ExtraFlags[i];
2938             V_VT(&vDst) = VT_EMPTY;
2939
2940             switch (V_VT(&v))
2941             {
2942             case VT_UI1: case VT_I2: case VT_I4:
2943             case VT_R4:  case VT_R8:
2944             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2945             case VT_DATE: case VT_CY:
2946                 bFail = FALSE;
2947                 break;
2948             case VT_I8:
2949                 if (HAVE_OLEAUT32_I8)
2950                     bFail = FALSE;
2951             }
2952
2953             hres = pVarNeg(&v,&vDst);
2954             if (bFail)
2955                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2956                    "VarNeg: expected failure, got 0x%lX vt %d|0x%X\n",
2957                    hres, vt, ExtraFlags[i]);
2958             else
2959                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%lX vt %d|0x%X\n",
2960                     hres, vt, ExtraFlags[i]);
2961         }
2962     }
2963
2964     VARNEG(BOOL,VARIANT_TRUE,I2,1);
2965     VARNEG(BOOL,VARIANT_FALSE,I2,0);
2966     VARNEG(BOOL,1,I2,-1);
2967     VARNEG(UI1,1,I2,-1);
2968     VARNEG(UI1,254,I2,-254);
2969     VARNEG(I2,-32768,I4,32768);
2970     VARNEG(I2,-1,I2,1);
2971     VARNEG(I2,1,I2,-1);
2972     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
2973     VARNEG(I4,-1,I4,1);
2974     VARNEG(I4,1,I4,-1);
2975     if (HAVE_OLEAUT32_I8)
2976     {
2977         VARNEG(I8,1,I8,-1);
2978         VARNEG(I8,-1,I8,1);
2979     }
2980     VARNEG(R4,1,R4,-1);
2981     VARNEG(R4,-1,R4,1);
2982     VARNEG(DATE,1,DATE,-1);
2983     VARNEG(DATE,-1,DATE,1);
2984     VARNEG(R8,1,R8,-1);
2985     VARNEG(R8,-1,R8,1);
2986     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
2987     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
2988
2989     V_VT(&v) = VT_EMPTY;
2990     hres = pVarNeg(&v,&vDst);
2991     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2992        "VarNeg: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2993        hres, V_VT(&vDst), V_I2(&vDst));
2994
2995     V_VT(&v) = VT_NULL;
2996     hres = pVarNeg(&v,&vDst);
2997     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2998        "VarNeg: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2999
3000     V_VT(&v) = VT_DECIMAL;
3001     S(U(*pdec)).sign = DECIMAL_NEG;
3002     S(U(*pdec)).scale = 0;
3003     pdec->Hi32 = 0;
3004     S1(U1(*pdec)).Mid32 = 0;
3005     S1(U1(*pdec)).Lo32 = 1;
3006     hres = pVarNeg(&v,&vDst);
3007     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3008        S(U(V_DECIMAL(&vDst))).sign == 0,
3009        "VarNeg: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
3010        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3011
3012     S(U(*pdec)).sign = 0;
3013     hres = pVarNeg(&v,&vDst);
3014     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3015        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3016        "VarNeg: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
3017        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3018
3019     V_VT(&v) = VT_CY;
3020     pcy->int64 = -10000;
3021     hres = pVarNeg(&v,&vDst);
3022     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3023        "VarNeg: VT_CY wrong, hres=0x%lX\n", hres);
3024 }
3025
3026 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
3027
3028 #define VARROUND(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
3029         memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \
3030         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
3031         "VarRound: expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##rvt, (int)(rval), \
3032         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
3033
3034 #define VARROUNDF(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
3035         memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \
3036         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
3037         "VarRound: expected 0x0,%d,%f, got 0x%lX,%d,%f\n", VT_##rvt, rval, \
3038         hres, V_VT(&vDst), V_##rvt(&vDst))
3039
3040 static void test_VarRound(void)
3041 {
3042     /* static const WCHAR szNumMin[] = {'-','1','.','4','5','\0' };
3043        static const WCHAR szNum[] = {'1','.','4','5','\0' }; */
3044     HRESULT hres;
3045     VARIANT v, vDst;
3046     CY *pcy = &V_CY(&v);
3047
3048     CHECKPTR(VarRound);
3049
3050     /* first check valid integer types */
3051     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
3052     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
3053     VARROUND(BOOL,1,0,I2,1);
3054     VARROUND(UI1,1,0,UI1,1);
3055     VARROUND(UI1,254,0,UI1,254);
3056     VARROUND(I2,-32768,0,I2,-32768);
3057     VARROUND(I2,-1,0,I2,-1);
3058     VARROUND(I2,1,0,I2,1);
3059     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
3060     VARROUND(I4,-1,0,I4,-1);
3061     VARROUND(I4,1,0,I4,1);
3062
3063
3064     /* MSDN states that rounding of R4/R8 is dependent on the underlying
3065      * bit pattern of the number and so is architecture dependent. In this
3066      * case Wine returns .2 (which is more correct) and Native returns .3
3067      */
3068
3069     VARROUNDF(R4,1.0,0,R4,1.0);
3070     VARROUNDF(R4,-1.0,0,R4,-1.0);
3071     VARROUNDF(R8,1.0,0,R8,1.0);
3072     VARROUNDF(R8,-1.0,0,R8,-1.0);
3073
3074     /* floating point numbers aren't exactly equal and we can't just
3075      * compare the first few digits.
3076     todo_wine {
3077         VARROUNDF(DATE,1.451,1,DATE,1.5);
3078         VARROUNDF(DATE,-1.45,1,DATE,-1.4);
3079         VARROUNDF(BSTR,(BSTR)szNumMin,1,R8,-1.40);
3080         VARROUNDF(BSTR,(BSTR)szNum,1,R8,1.50);
3081
3082         VARROUNDF(R4,1.23456,0,R4,1.0);
3083         VARROUNDF(R4,1.23456,1,R4,1.2);
3084         VARROUNDF(R4,1.23456,2,R4,1.23);
3085         VARROUNDF(R4,1.23456,3,R4,1.235);
3086         VARROUNDF(R4,1.23456,4,R4,1.2346);
3087         VARROUNDF(R4,-1.23456,0,R4,-1.0);
3088         VARROUNDF(R4,-1.23456,1,R4,-1.2);
3089         VARROUNDF(R4,-1.23456,2,R4,-1.23);
3090         VARROUNDF(R4,-1.23456,3,R4,-1.235);
3091         VARROUNDF(R4,-1.23456,4,R4,-1.2346);
3092
3093         VARROUNDF(R8,1.23456,0,R8,1.0);
3094         VARROUNDF(R8,1.23456,1,R8,1.2);
3095         VARROUNDF(R8,1.23456,2,R8,1.23);
3096         VARROUNDF(R8,1.23456,3,R8,1.235);
3097         VARROUNDF(R8,1.23456,4,R8,1.2346);
3098         VARROUNDF(R8,-1.23456,0,R8,-1.0);
3099         VARROUNDF(R8,-1.23456,1,R8,-1.2);
3100         VARROUNDF(R8,-1.23456,2,R8,-1.23);
3101         VARROUNDF(R8,-1.23456,3,R8,-1.235);
3102         VARROUNDF(R8,-1.23456,4,R8,-1.2346);
3103     }
3104     */
3105
3106     V_VT(&v) = VT_EMPTY;
3107     hres = pVarRound(&v,0,&vDst);
3108     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3109         "VarRound: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
3110         hres, V_VT(&vDst), V_I2(&vDst));
3111
3112     V_VT(&v) = VT_NULL;
3113     hres = pVarRound(&v,0,&vDst);
3114     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3115         "VarRound: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
3116
3117     /* not yet implemented so no use testing yet
3118     todo_wine {
3119         DECIMAL *pdec = &V_DECIMAL(&v);
3120         V_VT(&v) = VT_DECIMAL;
3121         S(U(*pdec)).sign = DECIMAL_NEG;
3122         S(U(*pdec)).scale = 0;
3123         pdec->Hi32 = 0;
3124         S1(U1(*pdec)).Mid32 = 0;
3125         S1(U1(*pdec)).Lo32 = 1;
3126         hres = pVarRound(&v,0,&vDst);
3127         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3128             S(U(V_DECIMAL(&vDst))).sign == 0,
3129             "VarRound: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
3130             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3131
3132         S(U(*pdec)).sign = 0;
3133         hres = pVarRound(&v,0,&vDst);
3134         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3135             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3136             "VarRound: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
3137             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3138     }
3139     */
3140
3141     V_VT(&v) = VT_CY;
3142     pcy->int64 = 10000;
3143     hres = pVarRound(&v,0,&vDst);
3144     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3145         "VarRound: VT_CY wrong, hres=0x%lX\n", hres);
3146
3147 }
3148
3149 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
3150
3151 static const char *szVarXorFail = "VarXor(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
3152 #define VARXOR(vt1,val1,vt2,val2,rvt,rval) \
3153         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3154         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3155         memset(&result,0,sizeof(result)); hres = pVarXor(&left,&right,&result); \
3156         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3157         szVarXorFail, VT_##vt1, VT_##vt2, \
3158         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3159         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3160            V_VT(&right) == VT_##vt2 && V_##vt2(&right) == val2, \
3161            "VarXor(%d,%d): Modified input arguments\n",VT_##vt1,VT_##vt2)
3162 #define VARXORCY(vt1,val1,val2,rvt,rval) \
3163         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3164         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3165         memset(&result,0,sizeof(result)); hres = pVarXor(&left,&right,&result); \
3166         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3167         "VarXor(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##vt1, VT_CY, \
3168         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3169         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3170            V_VT(&right) == VT_CY && V_CY(&right).int64 == val2, \
3171            "VarXor(%d,%d): Modified input arguments\n",VT_##vt1,VT_CY)
3172
3173 static void test_VarXor(void)
3174 {
3175     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3176     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3177     VARIANT left, right, result;
3178     BSTR lbstr, rbstr;
3179     VARTYPE i;
3180     HRESULT hres;
3181
3182     CHECKPTR(VarXor);
3183
3184     /* Test all possible flag/vt combinations & the resulting vt type */
3185     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3186     {
3187         VARTYPE leftvt, rightvt, resvt;
3188
3189         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3190         {
3191
3192             SKIPTESTS(leftvt);
3193
3194             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3195             {
3196                 BOOL bFail = FALSE;
3197
3198                 SKIPTESTS(rightvt);
3199
3200                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3201                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3202                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3203                     continue;
3204
3205                 memset(&left, 0, sizeof(left));
3206                 memset(&right, 0, sizeof(right));
3207                 V_VT(&left) = leftvt | ExtraFlags[i];
3208                 V_VT(&right) = rightvt | ExtraFlags[i];
3209                 V_VT(&result) = VT_EMPTY;
3210                 resvt = VT_I4;
3211
3212                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3213                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3214                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3215                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3216                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3217                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3218                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3219                 {
3220                     bFail = TRUE;
3221                 }
3222                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3223                 {
3224                     if (leftvt == rightvt ||
3225                         leftvt == VT_I2 || rightvt == VT_I2 ||
3226                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3227                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3228                         resvt = VT_I2;
3229                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3230                         resvt = VT_NULL;
3231                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3232                         resvt = VT_I8;
3233                 }
3234                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3235                 {
3236                     resvt = VT_NULL;
3237                 }
3238                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3239                 {
3240                     if (leftvt == rightvt)
3241                         resvt = VT_UI1;
3242                     else if (leftvt == rightvt ||
3243                         leftvt == VT_I2 || rightvt == VT_I2 ||
3244                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3245                     {
3246                         resvt = VT_I2;
3247                     }
3248                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3249                         resvt = VT_I8;
3250                 }
3251                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3252                 {
3253                     if (leftvt == rightvt ||
3254                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3255                         resvt = VT_I2;
3256                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3257                         resvt = VT_I8;
3258                 }
3259                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3260                 {
3261                     resvt = VT_BOOL;
3262                 }
3263                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3264                 {
3265                     if (leftvt == VT_INT || rightvt == VT_INT)
3266                         bFail = TRUE;
3267                     else
3268                         resvt = VT_I8;
3269                 }
3270                 hres = pVarXor(&left, &right, &result);
3271                 if (bFail)
3272                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3273                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
3274                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3275                        V_VT(&result));
3276                 else
3277                     ok(hres == S_OK && V_VT(&result) == resvt,
3278                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
3279                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3280                        V_VT(&result));
3281             }
3282         }
3283     }
3284
3285     /* Test returned values
3286      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3287      */
3288     VARXOR(EMPTY,0,EMPTY,0,I2,0);
3289     VARXOR(EMPTY,1,EMPTY,0,I2,0);
3290     VARXOR(EMPTY,0,NULL,0,NULL,0);
3291     VARXOR(EMPTY,0,I1,0,I4,0);
3292     VARXOR(EMPTY,0,I1,1,I4,1);
3293     VARXOR(EMPTY,0,UI1,0,I2,0);
3294     VARXOR(EMPTY,0,UI1,1,I2,1);
3295     VARXOR(EMPTY,0,I2,0,I2,0);
3296     VARXOR(EMPTY,0,I2,1,I2,1);
3297     VARXOR(EMPTY,0,UI2,0,I4,0);
3298     VARXOR(EMPTY,0,UI2,1,I4,1);
3299     VARXOR(EMPTY,0,I4,0,I4,0);
3300     VARXOR(EMPTY,0,I4,1,I4,1);
3301     VARXOR(EMPTY,0,UI4,0,I4,0);
3302     VARXOR(EMPTY,0,UI4,1,I4,1);
3303     if (HAVE_OLEAUT32_I8)
3304     {
3305         VARXOR(EMPTY,0,I8,0,I8,0);
3306         VARXOR(EMPTY,0,I8,1,I8,1);
3307         VARXOR(EMPTY,0,UI8,0,I4,0);
3308         VARXOR(EMPTY,0,UI8,1,I4,1);
3309     }
3310     VARXOR(EMPTY,0,INT,0,I4,0);
3311     VARXOR(EMPTY,0,INT,1,I4,1);
3312     VARXOR(EMPTY,0,UINT,0,I4,0);
3313     VARXOR(EMPTY,0,UINT,1,I4,1);
3314     VARXOR(EMPTY,0,BOOL,0,I2,0);
3315     VARXOR(EMPTY,0,BOOL,1,I2,1);
3316     VARXOR(EMPTY,0,R4,0,I4,0);
3317     VARXOR(EMPTY,0,R4,1,I4,1);
3318     VARXOR(EMPTY,0,R8,0,I4,0);
3319     VARXOR(EMPTY,0,R8,1,I4,1);
3320     rbstr = SysAllocString(szFalse);
3321     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3322     rbstr = SysAllocString(szTrue);
3323     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3324     VARXORCY(EMPTY,0,10000,I4,1);
3325
3326     /* NULL OR 0 = NULL. NULL OR n = n */
3327     VARXOR(NULL,0,NULL,0,NULL,0);
3328     VARXOR(NULL,1,NULL,0,NULL,0);
3329     VARXOR(NULL,0,I1,0,NULL,0);
3330     VARXOR(NULL,0,I1,1,NULL,0);
3331     VARXOR(NULL,0,UI1,0,NULL,0);
3332     VARXOR(NULL,0,UI1,1,NULL,0);
3333     VARXOR(NULL,0,I2,0,NULL,0);
3334     VARXOR(NULL,0,I2,1,NULL,0);
3335     VARXOR(NULL,0,UI2,0,NULL,0);
3336     VARXOR(NULL,0,UI2,1,NULL,0);
3337     VARXOR(NULL,0,I4,0,NULL,0);
3338     VARXOR(NULL,0,I4,1,NULL,0);
3339     VARXOR(NULL,0,UI4,0,NULL,0);
3340     VARXOR(NULL,0,UI4,1,NULL,0);
3341     if (HAVE_OLEAUT32_I8)
3342     {
3343         VARXOR(NULL,0,I8,0,NULL,0);
3344         VARXOR(NULL,0,I8,1,NULL,0);
3345         VARXOR(NULL,0,UI8,0,NULL,0);
3346         VARXOR(NULL,0,UI8,1,NULL,0);
3347     }
3348     VARXOR(NULL,0,INT,0,NULL,0);
3349     VARXOR(NULL,0,INT,1,NULL,0);
3350     VARXOR(NULL,0,UINT,0,NULL,0);
3351     VARXOR(NULL,0,UINT,1,NULL,0);
3352     VARXOR(NULL,0,BOOL,0,NULL,0);
3353     VARXOR(NULL,0,BOOL,1,NULL,0);
3354     VARXOR(NULL,0,R4,0,NULL,0);
3355     VARXOR(NULL,0,R4,1,NULL,0);
3356     VARXOR(NULL,0,R8,0,NULL,0);
3357     VARXOR(NULL,0,R8,1,NULL,0);
3358     rbstr = SysAllocString(szFalse);
3359     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3360     rbstr = SysAllocString(szTrue);
3361     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3362     VARXORCY(NULL,0,10000,NULL,0);
3363     VARXORCY(NULL,0,0,NULL,0);
3364
3365     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3366     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3367     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3368     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3369     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3370     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3371     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3372     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3373     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3374     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3375     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3376     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3377     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3378     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3379     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3380     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3381     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3382     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3383     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3384     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3385     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3386     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3387     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3388     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3389     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3390     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3391     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3392     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3393     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3394     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3395     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3396     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3397     if (HAVE_OLEAUT32_I8)
3398     {
3399         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3400         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3401         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3402         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3403          * to I4 is performed.
3404          */
3405         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3406         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3407         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3408     }
3409     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3410     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3411     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3412     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3413     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3414     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3415     rbstr = SysAllocString(szFalse);
3416     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3417     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3418     rbstr = SysAllocString(szTrue);
3419     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3420     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3421     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3422     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3423     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3424
3425     VARXOR(I1,-1,I1,-1,I4,0);
3426     VARXOR(I1,-1,I1,0,I4,-1);
3427     VARXOR(I1,0,I1,0,I4,0);
3428     VARXOR(I1,-1,UI1,255,I4,-256);
3429     VARXOR(I1,-1,UI1,0,I4,-1);
3430     VARXOR(I1,0,UI1,0,I4,0);
3431     VARXOR(I1,-1,I2,-1,I4,0);
3432     VARXOR(I1,-1,I2,0,I4,-1);
3433     VARXOR(I1,0,I2,0,I4,0);
3434     VARXOR(I1,-1,UI2,65535,I4,-65536);
3435     VARXOR(I1,-1,UI2,0,I4,-1);
3436     VARXOR(I1,0,UI2,0,I4,0);
3437     VARXOR(I1,-1,I4,-1,I4,0);
3438     VARXOR(I1,-1,I4,0,I4,-1);
3439     VARXOR(I1,0,I4,0,I4,0);
3440     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3441     VARXOR(I1,-1,UI4,0,I4,-1);
3442     VARXOR(I1,0,UI4,0,I4,0);
3443     VARXOR(I1,-1,R4,-1,I4,0);
3444     VARXOR(I1,-1,R4,0,I4,-1);
3445     VARXOR(I1,0,R4,0,I4,0);
3446     VARXOR(I1,-1,R8,-1,I4,0);
3447     VARXOR(I1,-1,R8,0,I4,-1);
3448     VARXOR(I1,0,R8,0,I4,0);
3449     VARXOR(I1,-1,DATE,-1,I4,0);
3450     VARXOR(I1,-1,DATE,0,I4,-1);
3451     VARXOR(I1,0,DATE,0,I4,0);
3452     if (HAVE_OLEAUT32_I8)
3453     {
3454         VARXOR(I1,-1,I8,-1,I8,0);
3455         VARXOR(I1,-1,I8,0,I8,-1);
3456         VARXOR(I1,0,I8,0,I8,0);
3457         VARXOR(I1,-1,UI8,0,I4,-1);
3458         VARXOR(I1,0,UI8,0,I4,0);
3459     }
3460     VARXOR(I1,-1,INT,-1,I4,0);
3461     VARXOR(I1,-1,INT,0,I4,-1);
3462     VARXOR(I1,0,INT,0,I4,0);
3463     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3464     VARXOR(I1,-1,UINT,0,I4,-1);
3465     VARXOR(I1,0,UINT,0,I4,0);
3466     rbstr = SysAllocString(szFalse);
3467     VARXOR(I1,0,BSTR,rbstr,I4,0);
3468     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3469     rbstr = SysAllocString(szTrue);
3470     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3471     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3472     VARXORCY(I1,-1,10000,I4,-2);
3473     VARXORCY(I1,-1,0,I4,-1);
3474     VARXORCY(I1,0,0,I4,0);
3475
3476     VARXOR(UI1,255,UI1,255,UI1,0);
3477     VARXOR(UI1,255,UI1,0,UI1,255);
3478     VARXOR(UI1,0,UI1,0,UI1,0);
3479     VARXOR(UI1,255,I2,-1,I2,-256);
3480     VARXOR(UI1,255,I2,0,I2,255);
3481     VARXOR(UI1,0,I2,0,I2,0);
3482     VARXOR(UI1,255,UI2,65535,I4,65280);
3483     VARXOR(UI1,255,UI2,0,I4,255);
3484     VARXOR(UI1,0,UI2,0,I4,0);
3485     VARXOR(UI1,255,I4,-1,I4,-256);
3486     VARXOR(UI1,255,I4,0,I4,255);
3487     VARXOR(UI1,0,I4,0,I4,0);
3488     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3489     VARXOR(UI1,255,UI4,0,I4,255);
3490     VARXOR(UI1,0,UI4,0,I4,0);
3491     VARXOR(UI1,255,R4,-1,I4,-256);
3492     VARXOR(UI1,255,R4,0,I4,255);
3493     VARXOR(UI1,0,R4,0,I4,0);
3494     VARXOR(UI1,255,R8,-1,I4,-256);
3495     VARXOR(UI1,255,R8,0,I4,255);
3496     VARXOR(UI1,0,R8,0,I4,0);
3497     VARXOR(UI1,255,DATE,-1,I4,-256);
3498     VARXOR(UI1,255,DATE,0,I4,255);
3499     VARXOR(UI1,0,DATE,0,I4,0);
3500     if (HAVE_OLEAUT32_I8)
3501     {
3502         VARXOR(UI1,255,I8,-1,I8,-256);
3503         VARXOR(UI1,255,I8,0,I8,255);
3504         VARXOR(UI1,0,I8,0,I8,0);
3505         VARXOR(UI1,255,UI8,0,I4,255);
3506         VARXOR(UI1,0,UI8,0,I4,0);
3507     }
3508     VARXOR(UI1,255,INT,-1,I4,-256);
3509     VARXOR(UI1,255,INT,0,I4,255);
3510     VARXOR(UI1,0,INT,0,I4,0);
3511     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3512     VARXOR(UI1,255,UINT,0,I4,255);
3513     VARXOR(UI1,0,UINT,0,I4,0);
3514     rbstr = SysAllocString(szFalse);
3515     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3516     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3517     rbstr = SysAllocString(szTrue);
3518     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3519     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3520     VARXORCY(UI1,255,10000,I4,254);
3521     VARXORCY(UI1,255,0,I4,255);
3522     VARXORCY(UI1,0,0,I4,0);
3523
3524     VARXOR(I2,-1,I2,-1,I2,0);
3525     VARXOR(I2,-1,I2,0,I2,-1);
3526     VARXOR(I2,0,I2,0,I2,0);
3527     VARXOR(I2,-1,UI2,65535,I4,-65536);
3528     VARXOR(I2,-1,UI2,0,I4,-1);
3529     VARXOR(I2,0,UI2,0,I4,0);
3530     VARXOR(I2,-1,I4,-1,I4,0);
3531     VARXOR(I2,-1,I4,0,I4,-1);
3532     VARXOR(I2,0,I4,0,I4,0);
3533     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3534     VARXOR(I2,-1,UI4,0,I4,-1);
3535     VARXOR(I2,0,UI4,0,I4,0);
3536     VARXOR(I2,-1,R4,-1,I4,0);
3537     VARXOR(I2,-1,R4,0,I4,-1);
3538     VARXOR(I2,0,R4,0,I4,0);
3539     VARXOR(I2,-1,R8,-1,I4,0);
3540     VARXOR(I2,-1,R8,0,I4,-1);
3541     VARXOR(I2,0,R8,0,I4,0);
3542     VARXOR(I2,-1,DATE,-1,I4,0);
3543     VARXOR(I2,-1,DATE,0,I4,-1);
3544     VARXOR(I2,0,DATE,0,I4,0);
3545     if (HAVE_OLEAUT32_I8)
3546     {
3547         VARXOR(I2,-1,I8,-1,I8,0);
3548         VARXOR(I2,-1,I8,0,I8,-1);
3549         VARXOR(I2,0,I8,0,I8,0);
3550         VARXOR(I2,-1,UI8,0,I4,-1);
3551         VARXOR(I2,0,UI8,0,I4,0);
3552     }
3553     VARXOR(I2,-1,INT,-1,I4,0);
3554     VARXOR(I2,-1,INT,0,I4,-1);
3555     VARXOR(I2,0,INT,0,I4,0);
3556     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3557     VARXOR(I2,-1,UINT,0,I4,-1);
3558     VARXOR(I2,0,UINT,0,I4,0);
3559     rbstr = SysAllocString(szFalse);
3560     VARXOR(I2,0,BSTR,rbstr,I2,0);
3561     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3562     rbstr = SysAllocString(szTrue);
3563     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3564     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3565     VARXORCY(I2,-1,10000,I4,-2);
3566     VARXORCY(I2,-1,0,I4,-1);
3567     VARXORCY(I2,0,0,I4,0);
3568
3569     VARXOR(UI2,65535,UI2,65535,I4,0);
3570     VARXOR(UI2,65535,UI2,0,I4,65535);
3571     VARXOR(UI2,0,UI2,0,I4,0);
3572     VARXOR(UI2,65535,I4,-1,I4,-65536);
3573     VARXOR(UI2,65535,I4,0,I4,65535);
3574     VARXOR(UI2,0,I4,0,I4,0);
3575     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3576     VARXOR(UI2,65535,UI4,0,I4,65535);
3577     VARXOR(UI2,0,UI4,0,I4,0);
3578     VARXOR(UI2,65535,R4,-1,I4,-65536);
3579     VARXOR(UI2,65535,R4,0,I4,65535);
3580     VARXOR(UI2,0,R4,0,I4,0);
3581     VARXOR(UI2,65535,R8,-1,I4,-65536);
3582     VARXOR(UI2,65535,R8,0,I4,65535);
3583     VARXOR(UI2,0,R8,0,I4,0);
3584     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3585     VARXOR(UI2,65535,DATE,0,I4,65535);
3586     VARXOR(UI2,0,DATE,0,I4,0);
3587     if (HAVE_OLEAUT32_I8)
3588     {
3589         VARXOR(UI2,65535,I8,-1,I8,-65536);
3590         VARXOR(UI2,65535,I8,0,I8,65535);
3591         VARXOR(UI2,0,I8,0,I8,0);
3592         VARXOR(UI2,65535,UI8,0,I4,65535);
3593         VARXOR(UI2,0,UI8,0,I4,0);
3594     }
3595     VARXOR(UI2,65535,INT,-1,I4,-65536);
3596     VARXOR(UI2,65535,INT,0,I4,65535);
3597     VARXOR(UI2,0,INT,0,I4,0);
3598     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3599     VARXOR(UI2,65535,UINT,0,I4,65535);
3600     VARXOR(UI2,0,UINT,0,I4,0);
3601     rbstr = SysAllocString(szFalse);
3602     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3603     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3604     rbstr = SysAllocString(szTrue);
3605     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3606     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3607     VARXORCY(UI2,65535,10000,I4,65534);
3608     VARXORCY(UI2,65535,0,I4,65535);
3609     VARXORCY(UI2,0,0,I4,0);
3610
3611     VARXOR(I4,-1,I4,-1,I4,0);
3612     VARXOR(I4,-1,I4,0,I4,-1);
3613     VARXOR(I4,0,I4,0,I4,0);
3614     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3615     VARXOR(I4,-1,UI4,0,I4,-1);
3616     VARXOR(I4,0,UI4,0,I4,0);
3617     VARXOR(I4,-1,R4,-1,I4,0);
3618     VARXOR(I4,-1,R4,0,I4,-1);
3619     VARXOR(I4,0,R4,0,I4,0);
3620     VARXOR(I4,-1,R8,-1,I4,0);
3621     VARXOR(I4,-1,R8,0,I4,-1);
3622     VARXOR(I4,0,R8,0,I4,0);
3623     VARXOR(I4,-1,DATE,-1,I4,0);
3624     VARXOR(I4,-1,DATE,0,I4,-1);
3625     VARXOR(I4,0,DATE,0,I4,0);
3626     if (HAVE_OLEAUT32_I8)
3627     {
3628         VARXOR(I4,-1,I8,-1,I8,0);
3629         VARXOR(I4,-1,I8,0,I8,-1);
3630         VARXOR(I4,0,I8,0,I8,0);
3631         VARXOR(I4,-1,UI8,0,I4,-1);
3632         VARXOR(I4,0,UI8,0,I4,0);
3633     }
3634     VARXOR(I4,-1,INT,-1,I4,0);
3635     VARXOR(I4,-1,INT,0,I4,-1);
3636     VARXOR(I4,0,INT,0,I4,0);
3637     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3638     VARXOR(I4,-1,UINT,0,I4,-1);
3639     VARXOR(I4,0,UINT,0,I4,0);
3640     rbstr = SysAllocString(szFalse);
3641     VARXOR(I4,0,BSTR,rbstr,I4,0);
3642     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3643     rbstr = SysAllocString(szTrue);
3644     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3645     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3646     VARXORCY(I4,-1,10000,I4,-2);
3647     VARXORCY(I4,-1,0,I4,-1);
3648     VARXORCY(I4,0,0,I4,0);
3649
3650     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3651     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3652     VARXOR(UI4,0,UI4,0,I4,0);
3653     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3654     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3655     VARXOR(UI4,0,R4,0,I4,0);
3656     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3657     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3658     VARXOR(UI4,0,R8,0,I4,0);
3659     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3660     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3661     VARXOR(UI4,0,DATE,0,I4,0);
3662     if (HAVE_OLEAUT32_I8)
3663     {
3664         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3665         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3666         VARXOR(UI4,0,I8,0,I8,0);
3667         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3668         VARXOR(UI4,0,UI8,0,I4,0);
3669     }
3670     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3671     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3672     VARXOR(UI4,0,INT,0,I4,0);
3673     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3674     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3675     VARXOR(UI4,0,UINT,0,I4,0);
3676     rbstr = SysAllocString(szFalse);
3677     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3678     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3679     rbstr = SysAllocString(szTrue);
3680     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3681     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3682     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3683     VARXORCY(UI4,0xffffffff,0,I4,-1);
3684     VARXORCY(UI4,0,0,I4,0);
3685
3686     VARXOR(R4,-1,R4,-1,I4,0);
3687     VARXOR(R4,-1,R4,0,I4,-1);
3688     VARXOR(R4,0,R4,0,I4,0);
3689     VARXOR(R4,-1,R8,-1,I4,0);
3690     VARXOR(R4,-1,R8,0,I4,-1);
3691     VARXOR(R4,0,R8,0,I4,0);
3692     VARXOR(R4,-1,DATE,-1,I4,0);
3693     VARXOR(R4,-1,DATE,0,I4,-1);
3694     VARXOR(R4,0,DATE,0,I4,0);
3695     if (HAVE_OLEAUT32_I8)
3696     {
3697         VARXOR(R4,-1,I8,-1,I8,0);
3698         VARXOR(R4,-1,I8,0,I8,-1);
3699         VARXOR(R4,0,I8,0,I8,0);
3700         VARXOR(R4,-1,UI8,0,I4,-1);
3701         VARXOR(R4,0,UI8,0,I4,0);
3702     }
3703     VARXOR(R4,-1,INT,-1,I4,0);
3704     VARXOR(R4,-1,INT,0,I4,-1);
3705     VARXOR(R4,0,INT,0,I4,0);
3706     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3707     VARXOR(R4,-1,UINT,0,I4,-1);
3708     VARXOR(R4,0,UINT,0,I4,0);
3709     rbstr = SysAllocString(szFalse);
3710     VARXOR(R4,0,BSTR,rbstr,I4,0);
3711     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3712     rbstr = SysAllocString(szTrue);
3713     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3714     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3715     VARXORCY(R4,-1,10000,I4,-2);
3716     VARXORCY(R4,-1,0,I4,-1);
3717     VARXORCY(R4,0,0,I4,0);
3718
3719     VARXOR(R8,-1,R8,-1,I4,0);
3720     VARXOR(R8,-1,R8,0,I4,-1);
3721     VARXOR(R8,0,R8,0,I4,0);
3722     VARXOR(R8,-1,DATE,-1,I4,0);
3723     VARXOR(R8,-1,DATE,0,I4,-1);
3724     VARXOR(R8,0,DATE,0,I4,0);
3725     if (HAVE_OLEAUT32_I8)
3726     {
3727         VARXOR(R8,-1,I8,-1,I8,0);
3728         VARXOR(R8,-1,I8,0,I8,-1);
3729         VARXOR(R8,0,I8,0,I8,0);
3730         VARXOR(R8,-1,UI8,0,I4,-1);
3731         VARXOR(R8,0,UI8,0,I4,0);
3732     }
3733     VARXOR(R8,-1,INT,-1,I4,0);
3734     VARXOR(R8,-1,INT,0,I4,-1);
3735     VARXOR(R8,0,INT,0,I4,0);
3736     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3737     VARXOR(R8,-1,UINT,0,I4,-1);
3738     VARXOR(R8,0,UINT,0,I4,0);
3739     rbstr = SysAllocString(szFalse);
3740     VARXOR(R8,0,BSTR,rbstr,I4,0);
3741     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3742     rbstr = SysAllocString(szTrue);
3743     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3744     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3745     VARXORCY(R8,-1,10000,I4,-2);
3746     VARXORCY(R8,-1,0,I4,-1);
3747     VARXORCY(R8,0,0,I4,0);
3748
3749     VARXOR(DATE,-1,DATE,-1,I4,0);
3750     VARXOR(DATE,-1,DATE,0,I4,-1);
3751     VARXOR(DATE,0,DATE,0,I4,0);
3752     if (HAVE_OLEAUT32_I8)
3753     {
3754         VARXOR(DATE,-1,I8,-1,I8,0);
3755         VARXOR(DATE,-1,I8,0,I8,-1);
3756         VARXOR(DATE,0,I8,0,I8,0);
3757         VARXOR(DATE,-1,UI8,0,I4,-1);
3758         VARXOR(DATE,0,UI8,0,I4,0);
3759     }
3760     VARXOR(DATE,-1,INT,-1,I4,0);
3761     VARXOR(DATE,-1,INT,0,I4,-1);
3762     VARXOR(DATE,0,INT,0,I4,0);
3763     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3764     VARXOR(DATE,-1,UINT,0,I4,-1);
3765     VARXOR(DATE,0,UINT,0,I4,0);
3766     rbstr = SysAllocString(szFalse);
3767     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3768     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3769     rbstr = SysAllocString(szTrue);
3770     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3771     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3772     VARXORCY(DATE,-1,10000,I4,-2);
3773     VARXORCY(DATE,-1,0,I4,-1);
3774     VARXORCY(DATE,0,0,I4,0);
3775
3776     if (HAVE_OLEAUT32_I8)
3777     {
3778         VARXOR(I8,-1,I8,-1,I8,0);
3779         VARXOR(I8,-1,I8,0,I8,-1);
3780         VARXOR(I8,0,I8,0,I8,0);
3781         VARXOR(I8,-1,UI8,0,I8,-1);
3782         VARXOR(I8,0,UI8,0,I8,0);
3783         VARXOR(I8,-1,UINT,0,I8,-1);
3784         VARXOR(I8,0,UINT,0,I8,0);
3785         rbstr = SysAllocString(szFalse);
3786         VARXOR(I8,0,BSTR,rbstr,I8,0);
3787         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
3788         rbstr = SysAllocString(szTrue);
3789         VARXOR(I8,0,BSTR,rbstr,I8,-1);
3790         VARXOR(I8,-1,BSTR,rbstr,I8,0);
3791         VARXORCY(I8,-1,10000,I8,-2);
3792         VARXORCY(I8,-1,0,I8,-1);
3793         VARXORCY(I8,0,0,I8,0);
3794
3795         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
3796         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
3797         VARXOR(UI8,0,UI8,0,I4,0);
3798         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
3799         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
3800         VARXOR(UI8,0,INT,0,I4,0);
3801         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
3802         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
3803         VARXOR(UI8,0,UINT,0,I4,0);
3804         rbstr = SysAllocString(szFalse);
3805         VARXOR(UI8,0,BSTR,rbstr,I4,0);
3806         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
3807         rbstr = SysAllocString(szTrue);
3808         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
3809         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
3810         VARXORCY(UI8,0xffff,10000,I4,65534);
3811         VARXORCY(UI8,0xffff,0,I4,0xffff);
3812         VARXORCY(UI8,0,0,I4,0);
3813     }
3814
3815     VARXOR(INT,-1,INT,-1,I4,0);
3816     VARXOR(INT,-1,INT,0,I4,-1);
3817     VARXOR(INT,0,INT,0,I4,0);
3818     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
3819     VARXOR(INT,-1,UINT,0,I4,-1);
3820     VARXOR(INT,0,UINT,0,I4,0);
3821     rbstr = SysAllocString(szFalse);
3822     VARXOR(INT,0,BSTR,rbstr,I4,0);
3823     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
3824     rbstr = SysAllocString(szTrue);
3825     VARXOR(INT,0,BSTR,rbstr,I4,-1);
3826     VARXOR(INT,-1,BSTR,rbstr,I4,0);
3827     VARXORCY(INT,-1,10000,I4,-2);
3828     VARXORCY(INT,-1,0,I4,-1);
3829     VARXORCY(INT,0,0,I4,0);
3830
3831     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
3832     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
3833     VARXOR(UINT,0,UINT,0,I4,0);
3834     rbstr = SysAllocString(szFalse);
3835     VARXOR(UINT,0,BSTR,rbstr,I4,0);
3836     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
3837     rbstr = SysAllocString(szTrue);
3838     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
3839     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
3840     VARXORCY(UINT,0xffff,10000,I4,65534);
3841     VARXORCY(UINT,0xffff,0,I4,0xffff);
3842     VARXORCY(UINT,0,0,I4,0);
3843
3844     lbstr = SysAllocString(szFalse);
3845     rbstr = SysAllocString(szFalse);
3846     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
3847     rbstr = SysAllocString(szTrue);
3848     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
3849     lbstr = SysAllocString(szTrue);
3850     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
3851     VARXORCY(BSTR,lbstr,10000,I4,-2);
3852     lbstr = SysAllocString(szFalse);
3853     VARXORCY(BSTR,lbstr,10000,I4,1);
3854 }
3855
3856 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
3857
3858 static const char *szVarOrFail = "VarOr(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
3859 static const char *szVarOrChanged = "VarOr(%d,%d): Modified input arguments\n";
3860 #define VAROR(vt1,val1,vt2,val2,rvt,rval) \
3861         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3862         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3863         memset(&result,0,sizeof(result)); hres = pVarOr(&left,&right,&result); \
3864         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3865         szVarOrFail, VT_##vt1, VT_##vt2, \
3866         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3867         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3868            V_VT(&right) == VT_##vt2 && V_##vt2(&right) == val2, \
3869            szVarOrChanged,VT_##vt1,VT_##vt2)
3870 #define VARORCY(vt1,val1,val2,rvt,rval) \
3871         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3872         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3873         memset(&result,0,sizeof(result)); hres = pVarOr(&left,&right,&result); \
3874         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3875         "VarOr(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##vt1, VT_CY, \
3876         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3877         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3878            V_VT(&right) == VT_CY && V_CY(&right).int64 == val2, \
3879            "VarOr(%d,%d): Modified input arguments\n",VT_##vt1,VT_CY)
3880
3881 static void test_VarOr(void)
3882 {
3883     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3884     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3885     VARIANT left, right, result;
3886     BSTR lbstr, rbstr;
3887     VARTYPE i;
3888     HRESULT hres;
3889
3890     CHECKPTR(VarOr);
3891
3892     /* Test all possible flag/vt combinations & the resulting vt type */
3893     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3894     {
3895         VARTYPE leftvt, rightvt, resvt;
3896
3897         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3898         {
3899
3900             SKIPTESTS(leftvt);
3901
3902             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3903             {
3904                 BOOL bFail = FALSE;
3905
3906                 SKIPTESTS(rightvt);
3907
3908                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3909                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3910                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3911                     continue;
3912
3913                 memset(&left, 0, sizeof(left));
3914                 memset(&right, 0, sizeof(right));
3915                 V_VT(&left) = leftvt | ExtraFlags[i];
3916                 V_VT(&right) = rightvt | ExtraFlags[i];
3917                 V_VT(&result) = VT_EMPTY;
3918                 resvt = VT_I4;
3919
3920                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3921                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3922                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3923                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3924                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3925                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3926                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3927                 {
3928                     bFail = TRUE;
3929                 }
3930                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3931                 {
3932                     if (leftvt == rightvt ||
3933                         leftvt == VT_I2 || rightvt == VT_I2 ||
3934                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3935                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3936                         resvt = VT_I2;
3937                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3938                         resvt = VT_NULL;
3939                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3940                         resvt = VT_I8;
3941                 }
3942                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3943                 {
3944                     resvt = VT_NULL;
3945                 }
3946                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3947                 {
3948                     if (leftvt == rightvt)
3949                         resvt = VT_UI1;
3950                     else if (leftvt == rightvt ||
3951                         leftvt == VT_I2 || rightvt == VT_I2 ||
3952                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3953                     {
3954                         resvt = VT_I2;
3955                     }
3956                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3957                         resvt = VT_I8;
3958                 }
3959                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3960                 {
3961                     if (leftvt == rightvt ||
3962                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3963                         resvt = VT_I2;
3964                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3965                         resvt = VT_I8;
3966                 }
3967                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3968                 {
3969                     resvt = VT_BOOL;
3970                 }
3971                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3972                 {
3973                     if (leftvt == VT_INT || rightvt == VT_INT)
3974                         bFail = TRUE;
3975                     else
3976                         resvt = VT_I8;
3977                 }
3978                 hres = pVarOr(&left, &right, &result);
3979                 if (bFail)
3980                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3981                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
3982                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3983                        V_VT(&result));
3984                 else
3985                     ok(hres == S_OK && V_VT(&result) == resvt,
3986                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
3987                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3988                        V_VT(&result));
3989             }
3990         }
3991     }
3992
3993     /* Test returned values. Since we know the returned type is correct
3994      * and that we handle all combinations of invalid types, just check
3995      * that good type combinations produce the desired value.
3996      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3997      */
3998     VAROR(EMPTY,0,EMPTY,0,I2,0);
3999     VAROR(EMPTY,1,EMPTY,0,I2,0);
4000     VAROR(EMPTY,0,NULL,0,NULL,0);
4001     VAROR(EMPTY,0,I1,0,I4,0);
4002     VAROR(EMPTY,0,I1,1,I4,1);
4003     VAROR(EMPTY,0,UI1,0,I2,0);
4004     VAROR(EMPTY,0,UI1,1,I2,1);
4005     VAROR(EMPTY,0,I2,0,I2,0);
4006     VAROR(EMPTY,0,I2,1,I2,1);
4007     VAROR(EMPTY,0,UI2,0,I4,0);
4008     VAROR(EMPTY,0,UI2,1,I4,1);
4009     VAROR(EMPTY,0,I4,0,I4,0);
4010     VAROR(EMPTY,0,I4,1,I4,1);
4011     VAROR(EMPTY,0,UI4,0,I4,0);
4012     VAROR(EMPTY,0,UI4,1,I4,1);
4013     if (HAVE_OLEAUT32_I8)
4014     {
4015         VAROR(EMPTY,0,I8,0,I8,0);
4016         VAROR(EMPTY,0,I8,1,I8,1);
4017         VAROR(EMPTY,0,UI8,0,I4,0);
4018         VAROR(EMPTY,0,UI8,1,I4,1);
4019     }
4020     VAROR(EMPTY,0,INT,0,I4,0);
4021     VAROR(EMPTY,0,INT,1,I4,1);
4022     VAROR(EMPTY,0,UINT,0,I4,0);
4023     VAROR(EMPTY,0,UINT,1,I4,1);
4024     VAROR(EMPTY,0,BOOL,0,I2,0);
4025     VAROR(EMPTY,0,BOOL,1,I2,1);
4026     VAROR(EMPTY,0,R4,0,I4,0);
4027     VAROR(EMPTY,0,R4,1,I4,1);
4028     VAROR(EMPTY,0,R8,0,I4,0);
4029     VAROR(EMPTY,0,R8,1,I4,1);
4030     rbstr = SysAllocString(szFalse);
4031     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
4032     rbstr = SysAllocString(szTrue);
4033     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
4034     VARORCY(EMPTY,0,10000,I4,1);
4035
4036     /* NULL OR 0 = NULL. NULL OR n = n */
4037     VAROR(NULL,0,NULL,0,NULL,0);
4038     VAROR(NULL,1,NULL,0,NULL,0);
4039     VAROR(NULL,0,I1,0,NULL,0);
4040     VAROR(NULL,0,I1,1,I4,1);
4041     VAROR(NULL,0,UI1,0,NULL,0);
4042     VAROR(NULL,0,UI1,1,UI1,1);
4043     VAROR(NULL,0,I2,0,NULL,0);
4044     VAROR(NULL,0,I2,1,I2,1);
4045     VAROR(NULL,0,UI2,0,NULL,0);
4046     VAROR(NULL,0,UI2,1,I4,1);
4047     VAROR(NULL,0,I4,0,NULL,0);
4048     VAROR(NULL,0,I4,1,I4,1);
4049     VAROR(NULL,0,UI4,0,NULL,0);
4050     VAROR(NULL,0,UI4,1,I4,1);
4051     if (HAVE_OLEAUT32_I8)
4052     {
4053         VAROR(NULL,0,I8,0,NULL,0);
4054         VAROR(NULL,0,I8,1,I8,1);
4055         VAROR(NULL,0,UI8,0,NULL,0);
4056         VAROR(NULL,0,UI8,1,I4,1);
4057     }
4058     VAROR(NULL,0,INT,0,NULL,0);
4059     VAROR(NULL,0,INT,1,I4,1);
4060     VAROR(NULL,0,UINT,0,NULL,0);
4061     VAROR(NULL,0,UINT,1,I4,1);
4062     VAROR(NULL,0,BOOL,0,NULL,0);
4063     VAROR(NULL,0,BOOL,1,BOOL,1);
4064     VAROR(NULL,0,R4,0,NULL,0);
4065     VAROR(NULL,0,R4,1,I4,1);
4066     VAROR(NULL,0,R8,0,NULL,0);
4067     VAROR(NULL,0,R8,1,I4,1);
4068     rbstr = SysAllocString(szFalse);
4069     VAROR(NULL,0,BSTR,rbstr,NULL,0);
4070     rbstr = SysAllocString(szTrue);
4071     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
4072     VARORCY(NULL,0,10000,I4,1);
4073     VARORCY(NULL,0,0,NULL,0);
4074
4075     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4076     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4077     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4078     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4079     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4080     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
4081     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4082     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4083     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
4084     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4085     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4086     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
4087     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4088     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4089     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
4090     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4091     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4092     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
4093     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4094     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4095     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
4096     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4097     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4098     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
4099     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4100     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4101     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
4102     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4103     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4104     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
4105     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4106     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4107     if (HAVE_OLEAUT32_I8)
4108     {
4109         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
4110         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4111         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4112         /* This returns DISP_E_OVERFLOW which indicates that a conversion
4113          * to I4 is performed.
4114          */
4115         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4116         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4117         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4118     }
4119     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
4120     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4121     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4122     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
4123     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4124     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4125     rbstr = SysAllocString(szFalse);
4126     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4127     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4128     rbstr = SysAllocString(szTrue);
4129     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4130     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4131     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
4132     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4133     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
4134
4135     VAROR(I1,-1,I1,-1,I4,-1);
4136     VAROR(I1,-1,I1,0,I4,-1);
4137     VAROR(I1,0,I1,0,I4,0);
4138     VAROR(I1,-1,UI1,255,I4,-1);
4139     VAROR(I1,-1,UI1,0,I4,-1);
4140     VAROR(I1,0,UI1,0,I4,0);
4141     VAROR(I1,-1,I2,-1,I4,-1);
4142     VAROR(I1,-1,I2,0,I4,-1);
4143     VAROR(I1,0,I2,0,I4,0);
4144     VAROR(I1,-1,UI2,65535,I4,-1);
4145     VAROR(I1,-1,UI2,0,I4,-1);
4146     VAROR(I1,0,UI2,0,I4,0);
4147     VAROR(I1,-1,I4,-1,I4,-1);
4148     VAROR(I1,-1,I4,0,I4,-1);
4149     VAROR(I1,0,I4,0,I4,0);
4150     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
4151     VAROR(I1,-1,UI4,0,I4,-1);
4152     VAROR(I1,0,UI4,0,I4,0);
4153     VAROR(I1,-1,R4,-1,I4,-1);
4154     VAROR(I1,-1,R4,0,I4,-1);
4155     VAROR(I1,0,R4,0,I4,0);
4156     VAROR(I1,-1,R8,-1,I4,-1);
4157     VAROR(I1,-1,R8,0,I4,-1);
4158     VAROR(I1,0,R8,0,I4,0);
4159     VAROR(I1,-1,DATE,-1,I4,-1);
4160     VAROR(I1,-1,DATE,0,I4,-1);
4161     VAROR(I1,0,DATE,0,I4,0);
4162     if (HAVE_OLEAUT32_I8)
4163     {
4164         VAROR(I1,-1,I8,-1,I8,-1);
4165         VAROR(I1,-1,I8,0,I8,-1);
4166         VAROR(I1,0,I8,0,I8,0);
4167         VAROR(I1,-1,UI8,0,I4,-1);
4168         VAROR(I1,0,UI8,0,I4,0);
4169     }
4170     VAROR(I1,-1,INT,-1,I4,-1);
4171     VAROR(I1,-1,INT,0,I4,-1);
4172     VAROR(I1,0,INT,0,I4,0);
4173     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
4174     VAROR(I1,-1,UINT,0,I4,-1);
4175     VAROR(I1,0,UINT,0,I4,0);
4176     rbstr = SysAllocString(szFalse);
4177     VAROR(I1,0,BSTR,rbstr,I4,0);
4178     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4179     rbstr = SysAllocString(szTrue);
4180     VAROR(I1,0,BSTR,rbstr,I4,-1);
4181     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4182     VARORCY(I1,-1,10000,I4,-1);
4183     VARORCY(I1,-1,0,I4,-1);
4184     VARORCY(I1,0,0,I4,0);
4185
4186     VAROR(UI1,255,UI1,255,UI1,255);
4187     VAROR(UI1,255,UI1,0,UI1,255);
4188     VAROR(UI1,0,UI1,0,UI1,0);
4189     VAROR(UI1,255,I2,-1,I2,-1);
4190     VAROR(UI1,255,I2,0,I2,255);
4191     VAROR(UI1,0,I2,0,I2,0);
4192     VAROR(UI1,255,UI2,65535,I4,65535);
4193     VAROR(UI1,255,UI2,0,I4,255);
4194     VAROR(UI1,0,UI2,0,I4,0);
4195     VAROR(UI1,255,I4,-1,I4,-1);
4196     VAROR(UI1,255,I4,0,I4,255);
4197     VAROR(UI1,0,I4,0,I4,0);
4198     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4199     VAROR(UI1,255,UI4,0,I4,255);
4200     VAROR(UI1,0,UI4,0,I4,0);
4201     VAROR(UI1,255,R4,-1,I4,-1);
4202     VAROR(UI1,255,R4,0,I4,255);
4203     VAROR(UI1,0,R4,0,I4,0);
4204     VAROR(UI1,255,R8,-1,I4,-1);
4205     VAROR(UI1,255,R8,0,I4,255);
4206     VAROR(UI1,0,R8,0,I4,0);
4207     VAROR(UI1,255,DATE,-1,I4,-1);
4208     VAROR(UI1,255,DATE,0,I4,255);
4209     VAROR(UI1,0,DATE,0,I4,0);
4210     if (HAVE_OLEAUT32_I8)
4211     {
4212         VAROR(UI1,255,I8,-1,I8,-1);
4213         VAROR(UI1,255,I8,0,I8,255);
4214         VAROR(UI1,0,I8,0,I8,0);
4215         VAROR(UI1,255,UI8,0,I4,255);
4216         VAROR(UI1,0,UI8,0,I4,0);
4217     }
4218     VAROR(UI1,255,INT,-1,I4,-1);
4219     VAROR(UI1,255,INT,0,I4,255);
4220     VAROR(UI1,0,INT,0,I4,0);
4221     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4222     VAROR(UI1,255,UINT,0,I4,255);
4223     VAROR(UI1,0,UINT,0,I4,0);
4224     rbstr = SysAllocString(szFalse);
4225     VAROR(UI1,0,BSTR,rbstr,I2,0);
4226     VAROR(UI1,255,BSTR,rbstr,I2,255);
4227     rbstr = SysAllocString(szTrue);
4228     VAROR(UI1,0,BSTR,rbstr,I2,-1);
4229     VAROR(UI1,255,BSTR,rbstr,I2,-1);
4230     VARORCY(UI1,255,10000,I4,255);
4231     VARORCY(UI1,255,0,I4,255);
4232     VARORCY(UI1,0,0,I4,0);
4233
4234     VAROR(I2,-1,I2,-1,I2,-1);
4235     VAROR(I2,-1,I2,0,I2,-1);
4236     VAROR(I2,0,I2,0,I2,0);
4237     VAROR(I2,-1,UI2,65535,I4,-1);
4238     VAROR(I2,-1,UI2,0,I4,-1);
4239     VAROR(I2,0,UI2,0,I4,0);
4240     VAROR(I2,-1,I4,-1,I4,-1);
4241     VAROR(I2,-1,I4,0,I4,-1);
4242     VAROR(I2,0,I4,0,I4,0);
4243     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4244     VAROR(I2,-1,UI4,0,I4,-1);
4245     VAROR(I2,0,UI4,0,I4,0);
4246     VAROR(I2,-1,R4,-1,I4,-1);
4247     VAROR(I2,-1,R4,0,I4,-1);
4248     VAROR(I2,0,R4,0,I4,0);
4249     VAROR(I2,-1,R8,-1,I4,-1);
4250     VAROR(I2,-1,R8,0,I4,-1);
4251     VAROR(I2,0,R8,0,I4,0);
4252     VAROR(I2,-1,DATE,-1,I4,-1);
4253     VAROR(I2,-1,DATE,0,I4,-1);
4254     VAROR(I2,0,DATE,0,I4,0);
4255     if (HAVE_OLEAUT32_I8)
4256     {
4257         VAROR(I2,-1,I8,-1,I8,-1);
4258         VAROR(I2,-1,I8,0,I8,-1);
4259         VAROR(I2,0,I8,0,I8,0);
4260         VAROR(I2,-1,UI8,0,I4,-1);
4261         VAROR(I2,0,UI8,0,I4,0);
4262     }
4263     VAROR(I2,-1,INT,-1,I4,-1);
4264     VAROR(I2,-1,INT,0,I4,-1);
4265     VAROR(I2,0,INT,0,I4,0);
4266     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4267     VAROR(I2,-1,UINT,0,I4,-1);
4268     VAROR(I2,0,UINT,0,I4,0);
4269     rbstr = SysAllocString(szFalse);
4270     VAROR(I2,0,BSTR,rbstr,I2,0);
4271     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4272     rbstr = SysAllocString(szTrue);
4273     VAROR(I2,0,BSTR,rbstr,I2,-1);
4274     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4275     VARORCY(I2,-1,10000,I4,-1);
4276     VARORCY(I2,-1,0,I4,-1);
4277     VARORCY(I2,0,0,I4,0);
4278
4279     VAROR(UI2,65535,UI2,65535,I4,65535);
4280     VAROR(UI2,65535,UI2,0,I4,65535);
4281     VAROR(UI2,0,UI2,0,I4,0);
4282     VAROR(UI2,65535,I4,-1,I4,-1);
4283     VAROR(UI2,65535,I4,0,I4,65535);
4284     VAROR(UI2,0,I4,0,I4,0);
4285     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4286     VAROR(UI2,65535,UI4,0,I4,65535);
4287     VAROR(UI2,0,UI4,0,I4,0);
4288     VAROR(UI2,65535,R4,-1,I4,-1);
4289     VAROR(UI2,65535,R4,0,I4,65535);
4290     VAROR(UI2,0,R4,0,I4,0);
4291     VAROR(UI2,65535,R8,-1,I4,-1);
4292     VAROR(UI2,65535,R8,0,I4,65535);
4293     VAROR(UI2,0,R8,0,I4,0);
4294     VAROR(UI2,65535,DATE,-1,I4,-1);
4295     VAROR(UI2,65535,DATE,0,I4,65535);
4296     VAROR(UI2,0,DATE,0,I4,0);
4297     if (HAVE_OLEAUT32_I8)
4298     {
4299         VAROR(UI2,65535,I8,-1,I8,-1);
4300         VAROR(UI2,65535,I8,0,I8,65535);
4301         VAROR(UI2,0,I8,0,I8,0);
4302         VAROR(UI2,65535,UI8,0,I4,65535);
4303         VAROR(UI2,0,UI8,0,I4,0);
4304     }
4305     VAROR(UI2,65535,INT,-1,I4,-1);
4306     VAROR(UI2,65535,INT,0,I4,65535);
4307     VAROR(UI2,0,INT,0,I4,0);
4308     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4309     VAROR(UI2,65535,UINT,0,I4,65535);
4310     VAROR(UI2,0,UINT,0,I4,0);
4311     rbstr = SysAllocString(szFalse);
4312     VAROR(UI2,0,BSTR,rbstr,I4,0);
4313     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4314     rbstr = SysAllocString(szTrue);
4315     VAROR(UI2,0,BSTR,rbstr,I4,-1);
4316     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4317     VARORCY(UI2,65535,10000,I4,65535);
4318     VARORCY(UI2,65535,0,I4,65535);
4319     VARORCY(UI2,0,0,I4,0);
4320
4321     VAROR(I4,-1,I4,-1,I4,-1);
4322     VAROR(I4,-1,I4,0,I4,-1);
4323     VAROR(I4,0,I4,0,I4,0);
4324     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4325     VAROR(I4,-1,UI4,0,I4,-1);
4326     VAROR(I4,0,UI4,0,I4,0);
4327     VAROR(I4,-1,R4,-1,I4,-1);
4328     VAROR(I4,-1,R4,0,I4,-1);
4329     VAROR(I4,0,R4,0,I4,0);
4330     VAROR(I4,-1,R8,-1,I4,-1);
4331     VAROR(I4,-1,R8,0,I4,-1);
4332     VAROR(I4,0,R8,0,I4,0);
4333     VAROR(I4,-1,DATE,-1,I4,-1);
4334     VAROR(I4,-1,DATE,0,I4,-1);
4335     VAROR(I4,0,DATE,0,I4,0);
4336     if (HAVE_OLEAUT32_I8)
4337     {
4338         VAROR(I4,-1,I8,-1,I8,-1);
4339         VAROR(I4,-1,I8,0,I8,-1);
4340         VAROR(I4,0,I8,0,I8,0);
4341         VAROR(I4,-1,UI8,0,I4,-1);
4342         VAROR(I4,0,UI8,0,I4,0);
4343     }
4344     VAROR(I4,-1,INT,-1,I4,-1);
4345     VAROR(I4,-1,INT,0,I4,-1);
4346     VAROR(I4,0,INT,0,I4,0);
4347     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4348     VAROR(I4,-1,UINT,0,I4,-1);
4349     VAROR(I4,0,UINT,0,I4,0);
4350     rbstr = SysAllocString(szFalse);
4351     VAROR(I4,0,BSTR,rbstr,I4,0);
4352     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4353     rbstr = SysAllocString(szTrue);
4354     VAROR(I4,0,BSTR,rbstr,I4,-1);
4355     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4356     VARORCY(I4,-1,10000,I4,-1);
4357     VARORCY(I4,-1,0,I4,-1);
4358     VARORCY(I4,0,0,I4,0);
4359
4360     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4361     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4362     VAROR(UI4,0,UI4,0,I4,0);
4363     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4364     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4365     VAROR(UI4,0,R4,0,I4,0);
4366     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4367     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4368     VAROR(UI4,0,R8,0,I4,0);
4369     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4370     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4371     VAROR(UI4,0,DATE,0,I4,0);
4372     if (HAVE_OLEAUT32_I8)
4373     {
4374         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4375         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4376         VAROR(UI4,0,I8,0,I8,0);
4377         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4378         VAROR(UI4,0,UI8,0,I4,0);
4379     }
4380     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4381     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4382     VAROR(UI4,0,INT,0,I4,0);
4383     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4384     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4385     VAROR(UI4,0,UINT,0,I4,0);
4386     rbstr = SysAllocString(szFalse);
4387     VAROR(UI4,0,BSTR,rbstr,I4,0);
4388     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4389     rbstr = SysAllocString(szTrue);
4390     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4391     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4392     VARORCY(UI4,0xffffffff,10000,I4,-1);
4393     VARORCY(UI4,0xffffffff,0,I4,-1);
4394     VARORCY(UI4,0,0,I4,0);
4395
4396     VAROR(R4,-1,R4,-1,I4,-1);
4397     VAROR(R4,-1,R4,0,I4,-1);
4398     VAROR(R4,0,R4,0,I4,0);
4399     VAROR(R4,-1,R8,-1,I4,-1);
4400     VAROR(R4,-1,R8,0,I4,-1);
4401     VAROR(R4,0,R8,0,I4,0);
4402     VAROR(R4,-1,DATE,-1,I4,-1);
4403     VAROR(R4,-1,DATE,0,I4,-1);
4404     VAROR(R4,0,DATE,0,I4,0);
4405     if (HAVE_OLEAUT32_I8)
4406     {
4407         VAROR(R4,-1,I8,-1,I8,-1);
4408         VAROR(R4,-1,I8,0,I8,-1);
4409         VAROR(R4,0,I8,0,I8,0);
4410         VAROR(R4,-1,UI8,0,I4,-1);
4411         VAROR(R4,0,UI8,0,I4,0);
4412     }
4413     VAROR(R4,-1,INT,-1,I4,-1);
4414     VAROR(R4,-1,INT,0,I4,-1);
4415     VAROR(R4,0,INT,0,I4,0);
4416     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4417     VAROR(R4,-1,UINT,0,I4,-1);
4418     VAROR(R4,0,UINT,0,I4,0);
4419     rbstr = SysAllocString(szFalse);
4420     VAROR(R4,0,BSTR,rbstr,I4,0);
4421     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4422     rbstr = SysAllocString(szTrue);
4423     VAROR(R4,0,BSTR,rbstr,I4,-1);
4424     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4425     VARORCY(R4,-1,10000,I4,-1);
4426     VARORCY(R4,-1,0,I4,-1);
4427     VARORCY(R4,0,0,I4,0);
4428
4429     VAROR(R8,-1,R8,-1,I4,-1);
4430     VAROR(R8,-1,R8,0,I4,-1);
4431     VAROR(R8,0,R8,0,I4,0);
4432     VAROR(R8,-1,DATE,-1,I4,-1);
4433     VAROR(R8,-1,DATE,0,I4,-1);
4434     VAROR(R8,0,DATE,0,I4,0);
4435     if (HAVE_OLEAUT32_I8)
4436     {
4437         VAROR(R8,-1,I8,-1,I8,-1);
4438         VAROR(R8,-1,I8,0,I8,-1);
4439         VAROR(R8,0,I8,0,I8,0);
4440         VAROR(R8,-1,UI8,0,I4,-1);
4441         VAROR(R8,0,UI8,0,I4,0);
4442     }
4443     VAROR(R8,-1,INT,-1,I4,-1);
4444     VAROR(R8,-1,INT,0,I4,-1);
4445     VAROR(R8,0,INT,0,I4,0);
4446     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4447     VAROR(R8,-1,UINT,0,I4,-1);
4448     VAROR(R8,0,UINT,0,I4,0);
4449     rbstr = SysAllocString(szFalse);
4450     VAROR(R8,0,BSTR,rbstr,I4,0);
4451     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4452     rbstr = SysAllocString(szTrue);
4453     VAROR(R8,0,BSTR,rbstr,I4,-1);
4454     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4455     VARORCY(R8,-1,10000,I4,-1);
4456     VARORCY(R8,-1,0,I4,-1);
4457     VARORCY(R8,0,0,I4,0);
4458
4459     VAROR(DATE,-1,DATE,-1,I4,-1);
4460     VAROR(DATE,-1,DATE,0,I4,-1);
4461     VAROR(DATE,0,DATE,0,I4,0);
4462     if (HAVE_OLEAUT32_I8)
4463     {
4464         VAROR(DATE,-1,I8,-1,I8,-1);
4465         VAROR(DATE,-1,I8,0,I8,-1);
4466         VAROR(DATE,0,I8,0,I8,0);
4467         VAROR(DATE,-1,UI8,0,I4,-1);
4468         VAROR(DATE,0,UI8,0,I4,0);
4469     }
4470     VAROR(DATE,-1,INT,-1,I4,-1);
4471     VAROR(DATE,-1,INT,0,I4,-1);
4472     VAROR(DATE,0,INT,0,I4,0);
4473     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4474     VAROR(DATE,-1,UINT,0,I4,-1);
4475     VAROR(DATE,0,UINT,0,I4,0);
4476     rbstr = SysAllocString(szFalse);
4477     VAROR(DATE,0,BSTR,rbstr,I4,0);
4478     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4479     rbstr = SysAllocString(szTrue);
4480     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4481     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4482     VARORCY(DATE,-1,10000,I4,-1);
4483     VARORCY(DATE,-1,0,I4,-1);
4484     VARORCY(DATE,0,0,I4,0);
4485
4486     if (HAVE_OLEAUT32_I8)
4487     {
4488         VAROR(I8,-1,I8,-1,I8,-1);
4489         VAROR(I8,-1,I8,0,I8,-1);
4490         VAROR(I8,0,I8,0,I8,0);
4491         VAROR(I8,-1,UI8,0,I8,-1);
4492         VAROR(I8,0,UI8,0,I8,0);
4493         /* These overflow under native and Wine
4494         VAROR(I8,-1,INT,-1,I4,-1);
4495         VAROR(I8,-1,INT,0,I4,-1);
4496         VAROR(I8,0,INT,0,I4,0); */
4497         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4498         VAROR(I8,-1,UINT,0,I8,-1);
4499         VAROR(I8,0,UINT,0,I8,0);
4500         rbstr = SysAllocString(szFalse);
4501         VAROR(I8,0,BSTR,rbstr,I8,0);
4502         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4503         rbstr = SysAllocString(szTrue);
4504         VAROR(I8,0,BSTR,rbstr,I8,-1);
4505         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4506         VARORCY(I8,-1,10000,I8,-1);
4507         VARORCY(I8,-1,0,I8,-1);
4508         VARORCY(I8,0,0,I8,0);
4509
4510         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4511         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4512         VAROR(UI8,0,UI8,0,I4,0);
4513         VAROR(UI8,0xffff,INT,-1,I4,-1);
4514         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4515         VAROR(UI8,0,INT,0,I4,0);
4516         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4517         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4518         VAROR(UI8,0,UINT,0,I4,0);
4519         rbstr = SysAllocString(szFalse);
4520         VAROR(UI8,0,BSTR,rbstr,I4,0);
4521         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4522         rbstr = SysAllocString(szTrue);
4523         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4524         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4525         VARORCY(UI8,0xffff,10000,I4,0xffff);
4526         VARORCY(UI8,0xffff,0,I4,0xffff);
4527         VARORCY(UI8,0,0,I4,0);
4528     }
4529
4530     VAROR(INT,-1,INT,-1,I4,-1);
4531     VAROR(INT,-1,INT,0,I4,-1);
4532     VAROR(INT,0,INT,0,I4,0);
4533     VAROR(INT,-1,UINT,0xffff,I4,-1);
4534     VAROR(INT,-1,UINT,0,I4,-1);
4535     VAROR(INT,0,UINT,0,I4,0);
4536     rbstr = SysAllocString(szFalse);
4537     VAROR(INT,0,BSTR,rbstr,I4,0);
4538     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4539     rbstr = SysAllocString(szTrue);
4540     VAROR(INT,0,BSTR,rbstr,I4,-1);
4541     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4542     VARORCY(INT,-1,10000,I4,-1);
4543     VARORCY(INT,-1,0,I4,-1);
4544     VARORCY(INT,0,0,I4,0);
4545
4546     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4547     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4548     VAROR(UINT,0,UINT,0,I4,0);
4549     rbstr = SysAllocString(szFalse);
4550     VAROR(UINT,0,BSTR,rbstr,I4,0);
4551     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4552     rbstr = SysAllocString(szTrue);
4553     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4554     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4555     VARORCY(UINT,0xffff,10000,I4,0xffff);
4556     VARORCY(UINT,0xffff,0,I4,0xffff);
4557     VARORCY(UINT,0,0,I4,0);
4558
4559     lbstr = SysAllocString(szFalse);
4560     rbstr = SysAllocString(szFalse);
4561     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4562     rbstr = SysAllocString(szTrue);
4563     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4564     lbstr = SysAllocString(szTrue);
4565     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4566     VARORCY(BSTR,lbstr,10000,I4,-1);
4567     lbstr = SysAllocString(szFalse);
4568     VARORCY(BSTR,lbstr,10000,I4,1);
4569 }
4570
4571 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4572
4573 static const char *szVarEqvFail = "VarEqv(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4574 #define VAREQV(vt1,val1,vt2,val2,rvt,rval) \
4575         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4576         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4577         memset(&result,0,sizeof(result)); hres = pVarEqv(&left,&right,&result); \
4578         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4579         szVarEqvFail, VT_##vt1, VT_##vt2, \
4580         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result))
4581
4582 static void test_VarEqv(void)
4583 {
4584     VARIANT left, right, result;
4585     VARTYPE i;
4586     HRESULT hres;
4587
4588     CHECKPTR(VarEqv);
4589
4590     /* Test all possible flag/vt combinations & the resulting vt type */
4591     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4592     {
4593         VARTYPE leftvt, rightvt, resvt;
4594
4595         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4596         {
4597             SKIPTESTS(leftvt);
4598
4599             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4600             {
4601                 BOOL bFail = FALSE;
4602
4603                 SKIPTESTS(rightvt);
4604
4605                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4606                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4607                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4608                     continue;
4609
4610                 memset(&left, 0, sizeof(left));
4611                 memset(&right, 0, sizeof(right));
4612                 V_VT(&left) = leftvt | ExtraFlags[i];
4613                 V_VT(&right) = rightvt | ExtraFlags[i];
4614                 V_VT(&result) = VT_EMPTY;
4615                 resvt = VT_I4;
4616
4617                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4618                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4619                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4620                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4621                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4622                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4623                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4624                 {
4625                     bFail = TRUE;
4626                 }
4627                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4628                 {
4629                     if (leftvt == rightvt ||
4630                         leftvt == VT_I2 || rightvt == VT_I2 ||
4631                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4632                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4633                         resvt = VT_I2;
4634                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4635                         resvt = VT_NULL;
4636                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4637                         resvt = VT_I8;
4638                 }
4639                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4640                 {
4641                     resvt = VT_NULL;
4642                 }
4643                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4644                 {
4645                     if (leftvt == rightvt)
4646                         resvt = VT_UI1;
4647                     else if (leftvt == rightvt ||
4648                         leftvt == VT_I2 || rightvt == VT_I2 ||
4649                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4650                     {
4651                         resvt = VT_I2;
4652                     }
4653                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4654                         resvt = VT_I8;
4655                 }
4656                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4657                 {
4658                     if (leftvt == rightvt ||
4659                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4660                         resvt = VT_I2;
4661                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4662                         resvt = VT_I8;
4663                 }
4664                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4665                 {
4666                     resvt = VT_BOOL;
4667                 }
4668                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4669                 {
4670                     if (leftvt == VT_INT || rightvt == VT_INT)
4671                         bFail = TRUE;
4672                     else
4673                         resvt = VT_I8;
4674                 }
4675                 hres = pVarEqv(&left, &right, &result);
4676                 if (bFail)
4677                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4678                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4679                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4680                        V_VT(&result));
4681                 else
4682                     ok(hres == S_OK && V_VT(&result) == resvt,
4683                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4684                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4685                        V_VT(&result));
4686             }
4687         }
4688     }
4689
4690     /* Test returned values */
4691     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4692     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4693     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4694     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4695     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4696     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4697     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4698     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4699     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4700     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4701     VAREQV(BOOL,6,I2,7,I2,-2);
4702     VAREQV(UI1,1,UI1,1,UI1,255);
4703     VAREQV(UI1,1,UI1,0,UI1,254);
4704     VAREQV(UI1,0,UI1,1,UI1,254);
4705     if (HAVE_OLEAUT32_I8)
4706     {
4707         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4708         VAREQV(UI4,5,I8,19,I8,-23);
4709         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4710     }
4711 }
4712
4713 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4714
4715 static const char *szVarMulI4 = "VarMul(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4716 static const char *szVarMulR8 = "VarMul(%d,%d): expected 0x0,%d,%f, got 0x%lX,%d,%f\n";
4717
4718 #define VARMUL(vt1,val1,vt2,val2,rvt,rval) \
4719         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4720         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4721         memset(&result,0,sizeof(result)); hres = pVarMul(&left,&right,&result); \
4722         if (VT_##rvt == VT_R4 || VT_##rvt == VT_R8) { \
4723         ok(hres == S_OK && V_VT(&result) == VT_##rvt && \
4724         EQ_FLOAT(V_##rvt(&result), rval), \
4725         szVarMulR8, VT_##vt1, VT_##vt2, \
4726         VT_##rvt, (double)(rval), hres, V_VT(&result), (double)V_##rvt(&result)); \
4727         } else { \
4728         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4729         szVarMulI4, VT_##vt1, VT_##vt2, \
4730         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); }
4731
4732 static void test_VarMul(void)
4733 {
4734     static const WCHAR sz12[] = {'1','2','\0'};
4735     VARIANT left, right, result, cy, dec;
4736     VARTYPE i;
4737     BSTR lbstr, rbstr;
4738     HRESULT hres;
4739     double r;
4740
4741     CHECKPTR(VarMul);
4742
4743     lbstr = SysAllocString(sz12);
4744     rbstr = SysAllocString(sz12);
4745
4746     /* Test all possible flag/vt combinations & the resulting vt type */
4747     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4748     {
4749         VARTYPE leftvt, rightvt, resvt;
4750
4751         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4752         {
4753
4754             SKIPTESTS(leftvt);
4755
4756             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4757             {
4758                 BOOL bFail = FALSE;
4759
4760                 SKIPTESTS(rightvt);
4761
4762                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4763                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4764                     continue;
4765
4766                 memset(&left, 0, sizeof(left));
4767                 memset(&right, 0, sizeof(right));
4768                 V_VT(&left) = leftvt | ExtraFlags[i];
4769                 if (leftvt == VT_BSTR)
4770                     V_BSTR(&left) = lbstr;
4771                 V_VT(&right) = rightvt | ExtraFlags[i];
4772                 if (rightvt == VT_BSTR)
4773                     V_BSTR(&right) = rbstr;
4774                 V_VT(&result) = VT_EMPTY;
4775                 resvt = VT_UNKNOWN;
4776
4777                 /* Don't ask me why but native VarMul cannot handle:
4778                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
4779                    Tested with DCOM98, Win2k, WinXP */
4780                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4781                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4782                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4783                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4784                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4785                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4786                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
4787                     leftvt == VT_I1 || rightvt == VT_I1 ||
4788                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
4789                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
4790                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
4791                     leftvt == VT_INT || rightvt == VT_INT ||
4792                     leftvt == VT_UINT || rightvt == VT_UINT) {
4793                     bFail = TRUE;
4794                 }
4795
4796                 if (leftvt == VT_NULL || rightvt == VT_NULL)
4797                     resvt = VT_NULL;
4798                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
4799                     resvt = VT_DECIMAL;
4800                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
4801                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
4802                          leftvt == VT_DATE || rightvt == VT_DATE)
4803                     resvt = VT_R8;
4804                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
4805                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
4806                         leftvt == VT_I8 || rightvt == VT_I8 ||
4807                         leftvt == VT_CY || rightvt == VT_CY)
4808                         resvt = VT_R8;
4809                     else
4810                         resvt = VT_R4;
4811                 } else if (leftvt == VT_CY || rightvt == VT_CY)
4812                     resvt = VT_CY;
4813                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4814                     resvt = VT_I8;
4815                 else if (leftvt == VT_I4 || rightvt == VT_I4)
4816                     resvt = VT_I4;
4817                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
4818                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
4819                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
4820                     resvt = VT_I2;
4821                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4822                     resvt = VT_UI1;
4823
4824                 hres = pVarMul(&left, &right, &result);
4825                 if (bFail) {
4826                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4827                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4828                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4829                        V_VT(&result));
4830                 } else {
4831                     ok(hres == S_OK && V_VT(&result) == resvt,
4832                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4833                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4834                        V_VT(&result));
4835                 }
4836             }
4837         }
4838     }
4839
4840     /* Test returned values */
4841     VARMUL(I4,4,I4,2,I4,8);
4842     VARMUL(I2,4,I2,2,I2,8);
4843     VARMUL(I2,-13,I4,5,I4,-65);
4844     VARMUL(I4,-13,I4,5,I4,-65);
4845     VARMUL(I2,7,R4,0.5,R4,3.5);
4846     VARMUL(R4,0.5,I4,5,R8,2.5);
4847     VARMUL(R8,7.1,BOOL,0,R8,0);
4848     VARMUL(BSTR,lbstr,I2,4,R8,48);
4849     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
4850     VARMUL(BSTR,lbstr,R4,0.1,R8,1.2);
4851     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
4852     VARMUL(R4,0.2,BSTR,rbstr,R8,2.4);
4853     VARMUL(DATE,2.25,I4,7,R8,15.75);
4854
4855     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
4856     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
4857     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
4858     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
4859     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
4860     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
4861     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
4862     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
4863     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
4864     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
4865     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
4866     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
4867
4868     /* Manuly test some VT_CY and VT_DECIMAL variants */
4869     V_VT(&cy) = VT_CY;
4870     hres = VarCyFromI4(4711, &V_CY(&cy));
4871     ok(hres == S_OK, "VarCyFromI4 failed!\n");
4872     V_VT(&dec) = VT_DECIMAL;
4873     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
4874     ok(hres == S_OK, "VarDecFromR4 failed!\n");
4875     memset(&left, 0, sizeof(left));
4876     memset(&right, 0, sizeof(right));
4877     V_VT(&left) = VT_I4;
4878     V_I4(&left) = -11;
4879     V_VT(&right) = VT_UI1;
4880     V_UI1(&right) = 9;
4881
4882     hres = VarMul(&cy, &right, &result);
4883     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
4884     hres = VarR8FromCy(V_CY(&result), &r);
4885     ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
4886
4887     hres = VarMul(&left, &dec, &result);
4888     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
4889     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
4890     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
4891
4892     SysFreeString(lbstr);
4893     SysFreeString(rbstr);
4894 }
4895
4896 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
4897
4898 static const char *szVarAddI4 = "VarAdd(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4899 static const char *szVarAddR8 = "VarAdd(%d,%d): expected 0x0,%d,%f, got 0x%lX,%d,%f\n";
4900
4901 #define VARADD(vt1,val1,vt2,val2,rvt,rval) \
4902         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4903         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4904         memset(&result,0,sizeof(result)); hres = pVarAdd(&left,&right,&result); \
4905         if (VT_##rvt == VT_R4 || VT_##rvt == VT_R8 || VT_##rvt == VT_DATE) { \
4906         ok(hres == S_OK && V_VT(&result) == VT_##rvt && \
4907         EQ_FLOAT(V_##rvt(&result), rval), \
4908         szVarAddR8, VT_##vt1, VT_##vt2, \
4909         VT_##rvt, (double)(rval), hres, V_VT(&result), (double)V_##rvt(&result)); \
4910         } else { \
4911         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4912         szVarAddI4, VT_##vt1, VT_##vt2, \
4913         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); }
4914
4915 static void test_VarAdd(void)
4916 {
4917     static const WCHAR sz12[] = {'1','2','\0'};
4918     VARIANT left, right, result, cy, dec;
4919     VARTYPE i;
4920     BSTR lbstr, rbstr;
4921     HRESULT hres;
4922     double r;
4923
4924     CHECKPTR(VarAdd);
4925
4926     lbstr = SysAllocString(sz12);
4927     rbstr = SysAllocString(sz12);
4928
4929     /* Test all possible flag/vt combinations & the resulting vt type */
4930     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4931     {
4932         VARTYPE leftvt, rightvt, resvt;
4933
4934         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4935         {
4936
4937             SKIPTESTS(leftvt);
4938
4939             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4940             {
4941                 BOOL bFail = FALSE;
4942
4943                 SKIPTESTS(rightvt);
4944
4945                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4946                     continue;
4947
4948                 memset(&left, 0, sizeof(left));
4949                 memset(&right, 0, sizeof(right));
4950                 V_VT(&left) = leftvt | ExtraFlags[i];
4951                 if (leftvt == VT_BSTR)
4952                     V_BSTR(&left) = lbstr;
4953                 V_VT(&right) = rightvt | ExtraFlags[i];
4954                 if (rightvt == VT_BSTR)
4955                     V_BSTR(&right) = rbstr;
4956                 V_VT(&result) = VT_EMPTY;
4957                 resvt = VT_ERROR;
4958
4959                 /* Don't ask me why but native VarAdd cannot handle:
4960                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
4961                    Tested with DCOM98, Win2k, WinXP */
4962                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4963                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4964                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4965                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4966                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4967                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4968                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
4969                     leftvt == VT_I1 || rightvt == VT_I1 ||
4970                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
4971                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
4972                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
4973                     leftvt == VT_INT || rightvt == VT_INT ||
4974                     leftvt == VT_UINT || rightvt == VT_UINT) {
4975                     bFail = TRUE;
4976                 }
4977
4978                 if (leftvt == VT_NULL || rightvt == VT_NULL)
4979                     resvt = VT_NULL;
4980                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
4981                     bFail = TRUE;
4982                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
4983                     resvt = VT_DECIMAL;
4984                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
4985                     resvt = VT_DATE;
4986                 else if (leftvt == VT_CY || rightvt == VT_CY)
4987                     resvt = VT_CY;
4988                 else if (leftvt == VT_R8 || rightvt == VT_R8)
4989                     resvt = VT_R8;
4990                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
4991                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
4992                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4993                         resvt = VT_BSTR;
4994                     else
4995                         resvt = VT_R8;
4996                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
4997                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
4998                         leftvt == VT_I8 || rightvt == VT_I8)
4999                         resvt = VT_R8;
5000                     else
5001                         resvt = VT_R4;
5002                 }
5003                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5004                     resvt = VT_I8;
5005                 else if (leftvt == VT_I4 || rightvt == VT_I4)
5006                     resvt = VT_I4;
5007                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5008                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
5009                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5010                     resvt = VT_I2;
5011                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5012                     resvt = VT_UI1;
5013
5014                 hres = pVarAdd(&left, &right, &result);
5015                 if (bFail) {
5016                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5017                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
5018                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5019                        V_VT(&result));
5020                 } else {
5021                     ok(hres == S_OK && V_VT(&result) == resvt,
5022                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
5023                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5024                        V_VT(&result));
5025                 }
5026             }
5027         }
5028     }
5029
5030     /* Test returned values */
5031     VARADD(I4,4,I4,2,I4,6);
5032     VARADD(I2,4,I2,2,I2,6);
5033     VARADD(I2,-13,I4,5,I4,-8);
5034     VARADD(I4,-13,I4,5,I4,-8);
5035     VARADD(I2,7,R4,0.5,R4,7.5);
5036     VARADD(R4,0.5,I4,5,R8,5.5);
5037     VARADD(R8,7.1,BOOL,0,R8,7.1);
5038     VARADD(BSTR,lbstr,I2,4,R8,16);
5039     VARADD(BSTR,lbstr,BOOL,1,R8,13);
5040     VARADD(BSTR,lbstr,R4,0.1,R8,12.1);
5041     VARADD(R4,0.2,BSTR,rbstr,R8,12.2);
5042     VARADD(DATE,2.25,I4,7,DATE,9.25);
5043     VARADD(DATE,1.25,R4,-1.7,DATE,-0.45);
5044
5045     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
5046     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
5047     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
5048     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
5049     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
5050     VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
5051     VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
5052     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
5053     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
5054     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
5055     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
5056     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
5057
5058     /* Manualy test BSTR + BSTR */
5059     V_VT(&left) = VT_BSTR;
5060     V_BSTR(&left) = lbstr;
5061     V_VT(&right) = VT_BSTR;
5062     V_BSTR(&right) = rbstr;
5063     hres = VarAdd(&left, &right, &result);
5064     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
5065     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
5066     ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
5067
5068     /* Manuly test some VT_CY and VT_DECIMAL variants */
5069     V_VT(&cy) = VT_CY;
5070     hres = VarCyFromI4(4711, &V_CY(&cy));
5071     ok(hres == S_OK, "VarCyFromI4 failed!\n");
5072     V_VT(&dec) = VT_DECIMAL;
5073     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5074     ok(hres == S_OK, "VarDecFromR4 failed!\n");
5075     memset(&left, 0, sizeof(left));
5076     memset(&right, 0, sizeof(right));
5077     V_VT(&left) = VT_I4;
5078     V_I4(&left) = -11;
5079     V_VT(&right) = VT_UI1;
5080     V_UI1(&right) = 9;
5081
5082     hres = VarAdd(&cy, &right, &result);
5083     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5084     hres = VarR8FromCy(V_CY(&result), &r);
5085     ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
5086
5087     hres = VarAdd(&left, &dec, &result);
5088     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5089     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5090     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
5091
5092     SysFreeString(lbstr);
5093     SysFreeString(rbstr);
5094 }
5095
5096 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
5097
5098 /* ERROR from wingdi.h is interfering here */
5099 #undef ERROR
5100 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
5101         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
5102         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
5103         hres = pVarCmp(&left,&right,lcid,flags); \
5104         ok(hres == result, "VarCmp(VT_" #vt1 "|" #vtfl1 ",VT_" #vt2 "|" #vtfl2 "): expected " #result ", got hres=0x%lx\n", hres)
5105 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
5106         _VARCMP(vt1,val1,0,vt2,val2,0,lcid,0,res1); \
5107         _VARCMP(vt1,val1,VT_RESERVED,vt2,val2,0,lcid,0,res2); \
5108         _VARCMP(vt1,val1,0,vt2,val2,VT_RESERVED,lcid,0,res3); \
5109         _VARCMP(vt1,val1,VT_RESERVED,vt2,val2,VT_RESERVED,lcid,0,res4)
5110 #define VARCMP(vt1,val1,vt2,val2,result) \
5111         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
5112 /* The above macros do not work for VT_NULL as NULL gets expanded first */
5113 #define V_NULL_  V_NULL
5114 #define VT_NULL_ VT_NULL
5115
5116 static void test_VarCmp(void)
5117 {
5118     VARIANT left, right;
5119     VARTYPE i;
5120     LCID lcid;
5121     HRESULT hres;
5122     DECIMAL dec;
5123     static const WCHAR szhuh[] = {'h','u','h','?','\0'};
5124     static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
5125     static const WCHAR szempty[] = {'\0'};
5126     static const WCHAR sz0[] = {'0','\0'};
5127     static const WCHAR sz1[] = {'1','\0'};
5128     static const WCHAR sz7[] = {'7','\0'};
5129     static const WCHAR sz42[] = {'4','2','\0'};
5130     static const WCHAR sz1neg[] = {'-','1','\0'};
5131     static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
5132     static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
5133     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
5134     BSTR bstr2cents, bstr1few;
5135
5136     CHECKPTR(VarCmp);
5137
5138     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
5139     bstrempty = SysAllocString(szempty);
5140     bstrhuh = SysAllocString(szhuh);
5141     bstr2cents = SysAllocString(sz2cents);
5142     bstr0 = SysAllocString(sz0);
5143     bstr1 = SysAllocString(sz1);
5144     bstr7 = SysAllocString(sz7);
5145     bstr42 = SysAllocString(sz42);
5146     bstr1neg = SysAllocString(sz1neg);
5147     bstr666neg = SysAllocString(sz666neg);
5148     bstr1few = SysAllocString(sz1few);
5149
5150     /* Test all possible flag/vt combinations & the resulting vt type */
5151     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5152     {
5153         VARTYPE leftvt, rightvt;
5154
5155         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5156         {
5157
5158             SKIPTESTS(leftvt);
5159
5160             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5161             {
5162                 BOOL bFail = FALSE;
5163                 HRESULT expect = VARCMP_EQ;
5164
5165                 SKIPTESTS(rightvt);
5166
5167                 memset(&left, 0, sizeof(left));
5168                 memset(&right, 0, sizeof(right));
5169                 V_VT(&left) = leftvt | ExtraFlags[i];
5170                 if (leftvt == VT_BSTR) {
5171                     V_BSTR(&left) = bstr1neg;
5172                     if (ExtraFlags[i] & VT_RESERVED)
5173                         expect = VARCMP_LT;
5174                     else
5175                         expect = VARCMP_GT;
5176                 }
5177                 V_VT(&right) = rightvt | ExtraFlags[i];
5178                 if (rightvt == VT_BSTR) {
5179                     V_BSTR(&right) = bstr1neg;
5180                     if (ExtraFlags[i] & VT_RESERVED)
5181                         expect = VARCMP_GT;
5182                     else
5183                         expect = VARCMP_LT;
5184                 }
5185
5186                 /* Don't ask me why but native VarCmp cannot handle:
5187                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
5188                    VT_INT is only supported as left variant. Go figure.
5189                    Tested with DCOM98, Win2k, WinXP */
5190                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5191                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
5192                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
5193                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5194                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5195                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
5196                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5197                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
5198                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5199                     leftvt == VT_I1 || rightvt == VT_I1 ||
5200                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
5201                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
5202                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
5203                     rightvt == VT_INT ||
5204                     leftvt == VT_UINT || rightvt == VT_UINT) {
5205                     bFail = TRUE;
5206                 }
5207
5208                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
5209                     !(ExtraFlags[i] & ~VT_RESERVED)) {
5210                     expect = VARCMP_EQ;
5211                     bFail = FALSE;
5212                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
5213                     expect = VARCMP_NULL;
5214                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
5215                     expect = VARCMP_EQ;
5216                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
5217                     expect = VARCMP_GT;
5218                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
5219                     expect = VARCMP_LT;
5220
5221                 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
5222                 if (bFail) {
5223                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5224                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX\n",
5225                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
5226                 } else {
5227                     ok(hres == expect,
5228                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%lX, got 0x%lX\n",
5229                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
5230                        hres);
5231                 }
5232             }
5233         }
5234     }
5235
5236     /* VARCMP{,EX} run each 4 tests with a permutation of all posible
5237        input variants with (1) and without (0) VT_RESERVED set. The order
5238        of the permutations is (0,0); (1,0); (0,1); (1,1) */
5239     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
5240     ok(V_VT(&left) & V_VT(&right) & VT_RESERVED, "VT_RESERVED filtered out!\n");
5241     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
5242     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
5243     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
5244     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
5245     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
5246     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
5247     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
5248     ok(V_VT(&left) & V_VT(&right) & VT_RESERVED, "VT_RESERVED filtered out!\n");
5249     VARCMP(I4,1,UI1,1,VARCMP_EQ);
5250     VARCMP(I2,2,I2,2,VARCMP_EQ);
5251     VARCMP(I2,1,I2,2,VARCMP_LT);
5252     VARCMP(I2,2,I2,1,VARCMP_GT);
5253     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
5254     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
5255
5256     /* BSTR handling, especialy in conjunction with VT_RESERVED */
5257     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
5258     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
5259     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
5260     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
5261     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
5262     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
5263     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
5264     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
5265     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
5266     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
5267     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
5268     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
5269     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
5270     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
5271     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5272     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5273     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
5274     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5275     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
5276     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
5277     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5278     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
5279     ok(V_VT(&left) & V_VT(&right) & VT_RESERVED, "VT_RESERVED filtered out!\n");
5280     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
5281     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
5282     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5283     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
5284     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5285     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5286     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5287     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5288     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
5289     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5290     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
5291     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5292     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
5293     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5294     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
5295     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
5296     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5297     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
5298     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
5299     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
5300     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
5301     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
5302     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
5303     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
5304     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
5305     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
5306     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
5307     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
5308     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
5309     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
5310     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
5311     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
5312     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
5313
5314     /* DECIMAL handling */
5315     SETDEC(dec,0,0,0,0);
5316     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
5317     SETDEC64(dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
5318     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
5319     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
5320     SETDEC64(dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
5321     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
5322     SETDEC64(dec,20,0,0x5,0x6BC75E2D,0x63100001);     /* 1+1e-20 */
5323     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precission */
5324
5325     /* Show that DATE is handled just as a R8 */
5326     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
5327     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
5328     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
5329     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
5330     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
5331     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
5332     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
5333     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
5334     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
5335
5336     /* R4 precission handling */
5337     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
5338     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
5339     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
5340     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
5341     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
5342     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
5343     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
5344     SETDEC(dec,8,0,0,0x5F5E101);          /* 1+1e-8 */
5345     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
5346
5347     SysFreeString(bstrhuh);
5348     SysFreeString(bstrempty);
5349     SysFreeString(bstr0);
5350     SysFreeString(bstr1);
5351     SysFreeString(bstr7);
5352     SysFreeString(bstr42);
5353     SysFreeString(bstr1neg);
5354     SysFreeString(bstr666neg);
5355     SysFreeString(bstr2cents);
5356     SysFreeString(bstr1few);
5357 }
5358
5359 START_TEST(vartest)
5360 {
5361   hOleaut32 = LoadLibraryA("oleaut32.dll");
5362
5363   test_VariantInit();
5364   test_VariantClear();
5365   test_VariantCopy();
5366   test_VariantCopyInd();
5367   test_VarParseNumFromStr();
5368   test_VarNumFromParseNum();
5369   test_VarUdateFromDate();
5370   test_VarDateFromUdate();
5371   test_SystemTimeToVariantTime();
5372   test_VariantTimeToSystemTime();
5373   test_DosDateTimeToVariantTime();
5374   test_VariantTimeToDosDateTime();
5375   test_VarFormatNumber();
5376   test_VarFormat();
5377   test_VarAbs();
5378   test_VarNot();
5379   test_VarSub();
5380   test_VarMod();
5381   test_VarFix();
5382   test_VarInt();
5383   test_VarNeg();
5384   test_VarRound();
5385   test_VarXor();
5386   test_VarOr();
5387   test_VarEqv();
5388   test_VarMul();
5389   test_VarAdd();
5390   test_VarCmp();
5391 }