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