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_I4,V_I4,17,"#0",S_OK,"17");
1720   VARFMT(VT_I4,V_I4,4711,"#0",S_OK,"4711");
1721   VARFMT(VT_I4,V_I4,17,"#00",S_OK,"17");
1722   VARFMT(VT_I4,V_I4,17,"#000",S_OK,"017");
1723   VARFMT(VT_I4,V_I4,17,"#0.00",S_OK,"17.00");
1724   VARFMT(VT_I4,V_I4,17,"#0000.00",S_OK,"0017.00");
1725   VARFMT(VT_I4,V_I4,17,"#.00",S_OK,"17.00");
1726   VARFMT(VT_R8,V_R8,1.7,"#.00",S_OK,"1.70");
1727   VARFMT(VT_R8,V_R8,.17,"#.00",S_OK,".17");
1728   VARFMT(VT_I4,V_I4,17,"#3",S_OK,"173");
1729   VARFMT(VT_I4,V_I4,17,"#33",S_OK,"1733");
1730   VARFMT(VT_I4,V_I4,17,"#3.33",S_OK,"173.33");
1731   VARFMT(VT_I4,V_I4,17,"#3333.33",S_OK,"173333.33");
1732   VARFMT(VT_I4,V_I4,17,"#.33",S_OK,"17.33");
1733   VARFMT(VT_R8,V_R8,.17,"#.33",S_OK,".33");
1734   VARFMT(VT_R8,V_R8,1.7,"0.0000E-000",S_OK,"1.7000E000");
1735   VARFMT(VT_R8,V_R8,1.7,"0.0000e-1",S_OK,"1.7000e01");
1736   VARFMT(VT_R8,V_R8,86.936849,"#0.000000000000e-000",S_OK,"86.936849000000e000");
1737   todo_wine {
1738     /* rounding */
1739     VARFMT(VT_R8,V_R8,1.7,"#0",S_OK,"2");
1740     VARFMT(VT_R8,V_R8,1.7,"#.33",S_OK,"2.33");
1741     VARFMT(VT_R8,V_R8,1.7,"#3",S_OK,"23");
1742     VARFMT(VT_R8,V_R8,1.73245,"0.0000E+000",S_OK,"1.7325E+000");
1743     VARFMT(VT_R8,V_R8,9.9999999,"#0.000000",S_OK,"10.000000");
1744     /* handling of numbers > 0 with exponent format */
1745     VARFMT(VT_R8,V_R8,1.7,"0.0000e+0#",S_OK,"1.7000e+0");
1746     VARFMT(VT_R8,V_R8,100.0001e+0,"0.0000E+0",S_OK,"1.0000E+2");
1747     VARFMT(VT_R8,V_R8,1000001,"0.0000e+1",S_OK,"1.0000e+61");
1748     VARFMT(VT_R8,V_R8,100.0001e+25,"0.0000e+0",S_OK,"1.0000e+27");
1749     VARFMT(VT_R8,V_R8,450.0001e+43,"#000.0000e+0",S_OK,"4500.0010e+42");
1750   }
1751
1752
1753   /* 'out' is not cleared */
1754   out = (BSTR)0x1;
1755   pVarFormat(&in,NULL,fd,fw,flags,&out); /* Would crash if out is cleared */
1756   out = NULL;
1757
1758   /* Invalid args */
1759   hres = pVarFormat(&in,NULL,fd,fw,flags,NULL);
1760   ok(hres == E_INVALIDARG, "Null out: expected E_INVALIDARG, got 0x%08lx\n", hres);
1761   hres = pVarFormat(NULL,NULL,fd,fw,flags,&out);
1762   ok(hres == E_INVALIDARG, "Null in: expected E_INVALIDARG, got 0x%08lx\n", hres);
1763   fd = -1;
1764   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1765   fd = 8;
1766   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1767   fd = 0; fw = -1;
1768   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1769   fw = 4;
1770   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1771 }
1772
1773 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1774
1775 static const char *szVarAbsFail = "VarAbs: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
1776 #define VARABS(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
1777         memset(&vDst,0,sizeof(vDst)); hres = pVarAbs(&v,&vDst); \
1778         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
1779            szVarAbsFail, VT_##rvt, (int)(rval), \
1780            hres, V_VT(&vDst), (int)V_##rvt(&vDst))
1781
1782 static void test_VarAbs(void)
1783 {
1784     static const WCHAR szNum[] = {'-','1','.','1','\0' };
1785     char buff[8];
1786     HRESULT hres;
1787     VARIANT v, vDst;
1788     size_t i;
1789
1790     CHECKPTR(VarAbs);
1791
1792     /* Test all possible V_VT values.
1793      */
1794     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1795     {
1796         VARTYPE vt;
1797
1798         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1799         {
1800             HRESULT hExpected = DISP_E_BADVARTYPE;
1801
1802             SKIPTESTS(vt);
1803
1804             memset(&v, 0, sizeof(v));
1805             V_VT(&v) = vt | ExtraFlags[i];
1806             V_VT(&vDst) = VT_EMPTY;
1807
1808             hres = pVarAbs(&v,&vDst);
1809             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1810                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1811                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1812             {
1813                 hExpected = DISP_E_TYPEMISMATCH;
1814             }
1815             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1816             {
1817                 hExpected = DISP_E_BADVARTYPE;
1818             }
1819             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1820                 hExpected = S_OK;
1821
1822             /* Native always fails on some vartypes that should be valid. don't
1823              * check that Wine does the same; these are bugs in native.
1824              */
1825             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1826                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1827                 continue;
1828             ok(hres == hExpected, "VarAbs: expected 0x%lX, got 0x%lX for vt %d | 0x%X\n",
1829                hExpected, hres, vt, ExtraFlags[i]);
1830         }
1831     }
1832
1833     /* BOOL->I2, BSTR->R8, all others remain the same */
1834     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1835     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1836     VARABS(EMPTY,0,I2,0);
1837     VARABS(EMPTY,1,I2,0);
1838     VARABS(NULL,0,NULL,0);
1839     VARABS(NULL,1,NULL,0);
1840     VARABS(I2,1,I2,1);
1841     VARABS(I2,-1,I2,1);
1842     VARABS(I4,1,I4,1);
1843     VARABS(I4,-1,I4,1);
1844     VARABS(UI1,1,UI1,1);
1845     VARABS(R4,1,R4,1);
1846     VARABS(R4,-1,R4,1);
1847     VARABS(R8,1,R8,1);
1848     VARABS(R8,-1,R8,1);
1849     VARABS(DATE,1,DATE,1);
1850     VARABS(DATE,-1,DATE,1);
1851     V_VT(&v) = VT_CY;
1852     V_CY(&v).int64 = -10000;
1853     memset(&vDst,0,sizeof(vDst));
1854     hres = pVarAbs(&v,&vDst);
1855     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1856        "VarAbs(CY): expected 0x0 got 0x%lX\n", hres);
1857     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1858     if (buff[0] != '.' || buff[1])
1859     {
1860         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1861         return;
1862     }
1863     V_VT(&v) = VT_BSTR;
1864     V_BSTR(&v) = (BSTR)szNum;
1865     memset(&vDst,0,sizeof(vDst));
1866     hres = pVarAbs(&v,&vDst);
1867     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1868        "VarAbs: expected 0x0,%d,%g, got 0x%lX,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1869 }
1870
1871 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
1872
1873 static const char *szVarNotFail = "VarNot: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
1874 #define VARNOT(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
1875         memset(&vDst,0,sizeof(vDst)); hres = pVarNot(&v,&vDst); \
1876         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
1877         szVarNotFail, VT_##rvt, (int)(rval), \
1878         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
1879
1880 static void test_VarNot(void)
1881 {
1882     static const WCHAR szNum0[] = {'0','\0' };
1883     static const WCHAR szNum1[] = {'1','\0' };
1884     HRESULT hres;
1885     VARIANT v, vDst;
1886     DECIMAL *pdec = &V_DECIMAL(&v);
1887     CY *pcy = &V_CY(&v);
1888     size_t i;
1889
1890     CHECKPTR(VarNot);
1891
1892     /* Test all possible V_VT values */
1893     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1894     {
1895         VARTYPE vt;
1896
1897         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1898         {
1899             HRESULT hExpected = DISP_E_BADVARTYPE;
1900
1901             SKIPTESTS(vt);
1902
1903             memset(&v, 0, sizeof(v));
1904             V_VT(&v) = vt | ExtraFlags[i];
1905             V_VT(&vDst) = VT_EMPTY;
1906
1907             switch (V_VT(&v))
1908             {
1909             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
1910             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
1911             case VT_R4:  case VT_R8:
1912             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
1913             case VT_DATE: case VT_CY:
1914                 hExpected = S_OK;
1915                 break;
1916             case VT_I8: case VT_UI8:
1917                 if (HAVE_OLEAUT32_I8)
1918                     hExpected = S_OK;
1919                 break;
1920             case VT_RECORD:
1921                 if (HAVE_OLEAUT32_RECORD)
1922                     hExpected = DISP_E_TYPEMISMATCH;
1923                 break;
1924             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
1925                 hExpected = DISP_E_TYPEMISMATCH;
1926                 break;
1927             default:
1928                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
1929                    hExpected = DISP_E_TYPEMISMATCH;
1930                 break;
1931             }
1932
1933             hres = pVarNot(&v,&vDst);
1934             ok(hres == hExpected, "VarNot: expected 0x%lX, got 0x%lX vt %d|0x%X\n",
1935                hExpected, hres, vt, ExtraFlags[i]);
1936         }
1937     }
1938     /* Test the values returned by all cases that can succeed */
1939     VARNOT(EMPTY,0,I2,-1);
1940     VARNOT(EMPTY,1,I2,-1);
1941     VARNOT(NULL,0,NULL,0);
1942     VARNOT(NULL,1,NULL,0);
1943     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
1944     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
1945     VARNOT(I1,-1,I4,0);
1946     VARNOT(I1,0,I4,-1);
1947     VARNOT(I2,-1,I2,0);
1948     VARNOT(I2,0,I2,-1);
1949     VARNOT(I2,1,I2,-2);
1950     VARNOT(I4,1,I4,-2);
1951     VARNOT(I4,0,I4,-1);
1952     VARNOT(UI1,1,UI1,254);
1953     VARNOT(UI1,0,UI1,255);
1954     VARNOT(UI2,0,I4,-1);
1955     VARNOT(UI2,1,I4,-2);
1956     VARNOT(UI4,0,I4,-1);
1957     VARNOT(UI4,1,I4,-2);
1958     VARNOT(INT,0,I4,-1);
1959     VARNOT(INT,1,I4,-2);
1960     VARNOT(UINT,0,I4,-1);
1961     VARNOT(UINT,1,I4,-2);
1962     if (HAVE_OLEAUT32_I8)
1963     {
1964         VARNOT(I8,1,I8,-2);
1965         VARNOT(I8,0,I8,-1);
1966         VARNOT(UI8,0,I4,-1);
1967         VARNOT(UI8,1,I4,-2);
1968     }
1969     VARNOT(R4,1,I4,-2);
1970     VARNOT(R4,0,I4,-1);
1971     VARNOT(R8,1,I4,-2);
1972     VARNOT(R8,0,I4,-1);
1973     VARNOT(DATE,1,I4,-2);
1974     VARNOT(DATE,0,I4,-1);
1975     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
1976     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
1977     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
1978     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
1979
1980     V_VT(&v) = VT_DECIMAL;
1981     S(U(*pdec)).sign = DECIMAL_NEG;
1982     S(U(*pdec)).scale = 0;
1983     pdec->Hi32 = 0;
1984     S1(U1(*pdec)).Mid32 = 0;
1985     S1(U1(*pdec)).Lo32 = 1;
1986     VARNOT(DECIMAL,*pdec,I4,0);
1987
1988     pcy->int64 = 10000;
1989     VARNOT(CY,*pcy,I4,-2);
1990
1991     pcy->int64 = 0;
1992     VARNOT(CY,*pcy,I4,-1);
1993
1994     pcy->int64 = -1;
1995     VARNOT(CY,*pcy,I4,-1);
1996 }
1997 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
1998
1999 static void test_VarSub(void)
2000 {
2001     VARIANT va, vb, vc;
2002     HRESULT hr;
2003
2004     CHECKPTR(VarSub);
2005
2006     V_VT(&va) = VT_DATE;
2007     V_DATE(&va) = 200000.0;
2008     V_VT(&vb) = VT_DATE;
2009     V_DATE(&vb) = 100000.0;
2010
2011     hr = pVarSub(&va, &vb, &vc);
2012     ok(hr == S_OK,"VarSub of VT_DATE - VT_DATE failed with %lx\n", hr);
2013     ok(V_VT(&vc) == VT_R8,"VarSub of VT_DATE - VT_DATE returned vt 0x%x\n", V_VT(&vc));
2014     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));
2015     /* fprintf(stderr,"VarSub of 10000-20000 returned: %g\n", V_R8(&vc)); */
2016 }
2017
2018 static const char *szVarModFail = "VarMod: expected 0x%lx,%d(%s),%d, got 0x%lX,%d(%s),%d\n";
2019 #define VARMOD(vt1,vt2,val1,val2,rvt,rval,hexpected) V_VT(&v1) = VT_##vt1; V_##vt1(&v1) = val1; \
2020         V_VT(&v2) = VT_##vt2; V_##vt2(&v2) = val2;                  \
2021         memset(&vDst,0,sizeof(vDst)); hres = pVarMod(&v1,&v2,&vDst);                    \
2022         ok(hres == hexpected && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2023         szVarModFail, hexpected, VT_##rvt, vtstr(VT_##rvt), (int)(rval), \
2024         hres, V_VT(&vDst), vtstr(V_VT(&vDst)), (int)V_##rvt(&vDst))
2025
2026 static const char *szVarMod2Fail = "VarMod: expected 0x%lx,%d(%s),%d, got 0x%lX,%d(%s),%d\n";
2027 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected) V_VT(&v1) = VT_##vt1; V_I4(&v1) = val1; \
2028         V_VT(&v2) = VT_##vt2; V_I4(&v2) = val2;                                \
2029         memset(&vDst,0,sizeof(vDst)); hres = pVarMod(&v1,&v2,&vDst);                     \
2030         ok(hres == hexpected && V_VT(&vDst) == VT_##rvt && V_I4(&vDst) == (rval), \
2031         szVarMod2Fail, hexpected, VT_##rvt, vtstr(VT_##rvt), (int)(rval), \
2032         hres, V_VT(&vDst), vtstr(V_VT(&vDst)), (int)V_I4(&vDst))
2033
2034 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2035
2036 static void test_VarMod(void)
2037 {
2038   VARIANT v1, v2, vDst;
2039   HRESULT hres;
2040   HRESULT hexpected = 0;
2041   static const WCHAR szNum0[] = {'1','2','5','\0'};
2042   static const WCHAR szNum1[] = {'1','0','\0'};
2043   int l, r;
2044   BOOL lFound, rFound;
2045   BOOL lValid, rValid;
2046   BSTR strNum0, strNum1;
2047
2048   CHECKPTR(VarMod);
2049
2050   VARMOD(I1,BOOL,100,10,I4,0,S_OK);
2051   VARMOD(I1,I1,100,10,I4,0,S_OK);
2052   VARMOD(I1,UI1,100,10,I4,0,S_OK);
2053   VARMOD(I1,I2,100,10,I4,0,S_OK);
2054   VARMOD(I1,UI2,100,10,I4,0,S_OK);
2055   VARMOD(I1,I4,100,10,I4,0,S_OK);
2056   VARMOD(I1,UI4,100,10,I4,0,S_OK);
2057   VARMOD(I1,R4,100,10,I4,0,S_OK);
2058   VARMOD(I1,R8,100,10,I4,0,S_OK);
2059
2060   VARMOD(UI1,BOOL,100,10,I2,0,S_OK);
2061   VARMOD(UI1,I1,100,10,I4,0,S_OK);
2062   VARMOD(UI1,UI1,100,10,UI1,0,S_OK);
2063   VARMOD(UI1,I2,100,10,I2,0,S_OK);
2064   VARMOD(UI1,UI2,100,10,I4,0,S_OK);
2065   VARMOD(UI1,I4,100,10,I4,0,S_OK);
2066   VARMOD(UI1,UI4,100,10,I4,0,S_OK);
2067   VARMOD(UI1,R4,100,10,I4,0,S_OK);
2068   VARMOD(UI1,R8,100,10,I4,0,S_OK);
2069
2070   VARMOD(I2,BOOL,100,10,I2,0,S_OK);
2071   VARMOD(I2,I1,100,10,I4,0,S_OK);
2072   VARMOD(I2,UI1,100,10,I2,0,S_OK);
2073   VARMOD(I2,I2,100,10,I2,0,S_OK);
2074   VARMOD(I2,UI2,100,10,I4,0,S_OK);
2075   VARMOD(I2,I4,100,10,I4,0,S_OK);
2076   VARMOD(I2,UI4,100,10,I4,0,S_OK);
2077   VARMOD(I2,R4,100,10,I4,0,S_OK);
2078   VARMOD(I2,R8,100,10,I4,0,S_OK);
2079
2080   VARMOD(I4,BOOL,100,10,I4,0,S_OK);
2081   VARMOD(I4,I1,100,10,I4,0,S_OK);
2082   VARMOD(I4,UI1,100,10,I4,0,S_OK);
2083   VARMOD(I4,I2,100,10,I4,0,S_OK);
2084   VARMOD(I4,UI2,100,10,I4,0,S_OK);
2085   VARMOD(I4,I4,100,10,I4,0,S_OK);
2086   VARMOD(I4,UI4,100,10,I4,0,S_OK);
2087   VARMOD(I4,R4,100,10,I4,0,S_OK);
2088   VARMOD(I4,R8,100,10,I4,0,S_OK);
2089   VARMOD(UI4,BOOL,100,10,I4,0,S_OK);
2090   VARMOD(UI4,I1,100,10,I4,0,S_OK);
2091   VARMOD(UI4,UI1,100,10,I4,0,S_OK);
2092   VARMOD(UI4,I2,100,10,I4,0,S_OK);
2093   VARMOD(UI4,UI2,100,10,I4,0,S_OK);
2094   VARMOD(UI4,I4,100,10,I4,0,S_OK);
2095   VARMOD(UI4,UI4,100,10,I4,0,S_OK);
2096   VARMOD(UI4,R4,100,10,I4,0,S_OK);
2097   VARMOD(UI4,R8,100,10,I4,0,S_OK);
2098   VARMOD(R4,BOOL,100,10,I4,0,S_OK);
2099   VARMOD(R4,I1,100,10,I4,0,S_OK);
2100   VARMOD(R4,UI1,100,10,I4,0,S_OK);
2101   VARMOD(R4,I2,100,10,I4,0,S_OK);
2102   VARMOD(R4,UI2,100,10,I4,0,S_OK);
2103   VARMOD(R4,I4,100,10,I4,0,S_OK);
2104   VARMOD(R4,UI4,100,10,I4,0,S_OK);
2105   VARMOD(R4,R4,100,10,I4,0,S_OK);
2106   VARMOD(R4,R8,100,10,I4,0,S_OK);
2107   VARMOD(R8,BOOL,100,10,I4,0,S_OK);
2108   VARMOD(R8,I1,100,10,I4,0,S_OK);
2109   VARMOD(R8,UI1,100,10,I4,0,S_OK);
2110   VARMOD(R8,I2,100,10,I4,0,S_OK);
2111   VARMOD(R8,UI2,100,10,I4,0,S_OK);
2112   VARMOD(R8,I4,100,10,I4,0,S_OK);
2113   VARMOD(R8,UI4,100,10,I4,0,S_OK);
2114   VARMOD(R8,R4,100,10,I4,0,S_OK);
2115   VARMOD(R8,R8,100,10,I4,0,S_OK);
2116
2117   VARMOD(INT,INT,100,10,I4,0,S_OK);
2118   VARMOD(INT,UINT,100,10,I4,0,S_OK);
2119
2120   VARMOD(BOOL,BOOL,100,10,I2,0,S_OK);
2121   VARMOD(BOOL,I1,100,10,I4,0,S_OK);
2122   VARMOD(BOOL,UI1,100,10,I2,0,S_OK);
2123   VARMOD(BOOL,I2,100,10,I2,0,S_OK);
2124   VARMOD(BOOL,UI2,100,10,I4,0,S_OK);
2125   VARMOD(BOOL,I4,100,10,I4,0,S_OK);
2126   VARMOD(BOOL,UI4,100,10,I4,0,S_OK);
2127   VARMOD(BOOL,R4,100,10,I4,0,S_OK);
2128   VARMOD(BOOL,R8,100,10,I4,0,S_OK);
2129   VARMOD(BOOL,DATE,100,10,I4,0,S_OK);
2130
2131   VARMOD(DATE,BOOL,100,10,I4,0,S_OK);
2132   VARMOD(DATE,I1,100,10,I4,0,S_OK);
2133   VARMOD(DATE,UI1,100,10,I4,0,S_OK);
2134   VARMOD(DATE,I2,100,10,I4,0,S_OK);
2135   VARMOD(DATE,UI2,100,10,I4,0,S_OK);
2136   VARMOD(DATE,I4,100,10,I4,0,S_OK);
2137   VARMOD(DATE,UI4,100,10,I4,0,S_OK);
2138   VARMOD(DATE,R4,100,10,I4,0,S_OK);
2139   VARMOD(DATE,R8,100,10,I4,0,S_OK);
2140   VARMOD(DATE,DATE,100,10,I4,0,S_OK);
2141
2142   strNum0 = SysAllocString(szNum0);
2143   strNum1 = SysAllocString(szNum1);
2144   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5,S_OK);
2145   VARMOD(BSTR,I1,strNum0,10,I4,5,S_OK);
2146   VARMOD(BSTR,I2,strNum0,10,I4,5,S_OK);
2147   VARMOD(BSTR,I4,strNum0,10,I4,5,S_OK);
2148   VARMOD(BSTR,R4,strNum0,10,I4,5,S_OK);
2149   VARMOD(BSTR,R8,strNum0,10,I4,5,S_OK);
2150   VARMOD(I4,BSTR,125,strNum1,I4,5,S_OK);
2151
2152   if (HAVE_OLEAUT32_I8)
2153   {
2154     VARMOD(BOOL,I8,100,10,I8,0,S_OK);
2155     VARMOD(I1,I8,100,10,I8,0,S_OK);
2156     VARMOD(UI1,I8,100,10,I8,0,S_OK);
2157     VARMOD(I2,I8,100,10,I8,0,S_OK);
2158     VARMOD(I4,I8,100,10,I8,0,S_OK);
2159     VARMOD(UI4,I8,100,10,I8,0,S_OK);
2160     VARMOD(R4,I8,100,10,I8,0,S_OK);
2161     VARMOD(R8,I8,100,10,I8,0,S_OK);
2162     VARMOD(DATE,I8,100,10,I8,0,S_OK);
2163
2164     VARMOD(I8,BOOL,100,10,I8,0,S_OK);
2165     VARMOD(I8,I1,100,10,I8,0,S_OK);
2166     VARMOD(I8,UI1,100,10,I8,0,S_OK);
2167     VARMOD(I8,I2,100,10,I8,0,S_OK);
2168     VARMOD(I8,UI2,100,10,I8,0,S_OK);
2169     VARMOD(I8,I4,100,10,I8,0,S_OK);
2170     VARMOD(I8,UI4,100,10,I8,0,S_OK);
2171     VARMOD(I8,R4,100,10,I8,0,S_OK);
2172     VARMOD(I8,R8,100,10,I8,0,S_OK);
2173     VARMOD(I8,I8,100,10,I8,0,S_OK);
2174
2175     VARMOD(BSTR,I8,strNum0,10,I8,5,S_OK);
2176   }
2177
2178   /* test all combinations of types */
2179   for(l = 0; l < VT_BSTR_BLOB; l++)
2180   {
2181     SKIPTESTS(l);
2182
2183     for(r = 0; r < VT_BSTR_BLOB; r++)
2184     {
2185       SKIPTESTS(r);
2186
2187       if(l == VT_BSTR) continue;
2188       if(l == VT_DISPATCH) continue;
2189       if(r == VT_BSTR) continue;
2190       if(r == VT_DISPATCH) continue;
2191
2192       lFound = TRUE;
2193       lValid = TRUE;
2194       switch(l)
2195         {
2196         case VT_EMPTY:
2197         case VT_NULL:
2198         case VT_I1:
2199         case VT_UI1:
2200         case VT_I2:
2201         case VT_UI2:
2202         case VT_I4:
2203         case VT_I8:
2204         case VT_UI4:
2205         case VT_UI8:
2206         case VT_INT:
2207         case VT_UINT:
2208         case VT_R4:
2209         case VT_R8:
2210         case VT_BOOL:
2211         case VT_DATE:
2212         case VT_CY:
2213           hexpected = S_OK;
2214           break;
2215         case VT_ERROR:
2216         case VT_VARIANT:
2217         case VT_UNKNOWN:
2218         case VT_DECIMAL:
2219         case VT_RECORD:
2220           lValid = FALSE;
2221           break;
2222         default:
2223           lFound = FALSE;
2224           hexpected = DISP_E_BADVARTYPE;
2225           break;
2226         }
2227
2228       rFound = TRUE;
2229       rValid = TRUE;
2230       switch(r)
2231         {
2232         case VT_EMPTY:
2233         case VT_NULL:
2234         case VT_I1:
2235         case VT_UI1:
2236         case VT_I2:
2237         case VT_UI2:
2238         case VT_I4:
2239         case VT_I8:
2240         case VT_UI4:
2241         case VT_UI8:
2242         case VT_INT:
2243         case VT_UINT:
2244         case VT_R4:
2245         case VT_R8:
2246         case VT_BOOL:
2247         case VT_DATE:
2248         case VT_CY:
2249           hexpected = S_OK;
2250           break;
2251         case VT_ERROR:
2252         case VT_VARIANT:
2253         case VT_UNKNOWN:
2254         case VT_DECIMAL:
2255         case VT_RECORD:
2256           rValid = FALSE;
2257           break;
2258         default:
2259           rFound = FALSE;
2260           break;
2261         }
2262
2263       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2264       {
2265         hexpected = DISP_E_TYPEMISMATCH;
2266       } else if((l == VT_EMPTY) && (r == VT_NULL))
2267       {
2268         hexpected = S_OK;
2269       } else if((l == VT_NULL) && (r == VT_EMPTY))
2270       {
2271         hexpected = S_OK;
2272       } else if((l == VT_EMPTY) && (r == VT_CY))
2273       {
2274         hexpected = S_OK;
2275       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2276       {
2277         hexpected = DISP_E_TYPEMISMATCH;
2278       } else if((r == VT_EMPTY) && lFound && lValid)
2279       {
2280         hexpected = DISP_E_DIVBYZERO;
2281       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2282       {
2283         hexpected = DISP_E_TYPEMISMATCH;
2284       } else if((l == VT_NULL) && (r == VT_NULL))
2285       {
2286         hexpected = S_OK;
2287       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2288       {
2289         hexpected = DISP_E_TYPEMISMATCH;
2290       } else if((l == VT_NULL) && (r == VT_RECORD))
2291       {
2292         hexpected = DISP_E_TYPEMISMATCH;
2293       } else if((l == VT_NULL) && (r == VT_DECIMAL))
2294       {
2295         hexpected = DISP_E_OVERFLOW;
2296       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2297       {
2298         hexpected = DISP_E_TYPEMISMATCH;
2299       } else if((l == VT_NULL) && rFound)
2300       {
2301         hexpected = S_OK;
2302       } else if((l == VT_DECIMAL) || ((r == VT_DECIMAL) && lFound && lValid))
2303       {
2304         hexpected = DISP_E_OVERFLOW;
2305       } else if(l == VT_RECORD)
2306       {
2307         hexpected = DISP_E_TYPEMISMATCH;
2308       } else if((r == VT_RECORD) && lValid && lFound)
2309       {
2310         hexpected = DISP_E_TYPEMISMATCH;
2311       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2312       {
2313         hexpected = DISP_E_DIVBYZERO;
2314       } else if((l == VT_CY) && !rFound)
2315       {
2316         hexpected = DISP_E_BADVARTYPE;
2317       } else if(lFound && !rFound)
2318       {
2319         hexpected = DISP_E_BADVARTYPE;
2320       } else if(!lFound && rFound)
2321       {
2322         hexpected = DISP_E_BADVARTYPE;
2323       } else if((r == VT_NULL) && lFound && lValid)
2324       {
2325         hexpected = S_OK;
2326       } else if((l == VT_NULL) || (r == VT_NULL))
2327       {
2328         hexpected = DISP_E_BADVARTYPE;
2329       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2330       {
2331         hexpected = DISP_E_BADVARTYPE;
2332       } else if(lFound && !rFound)
2333       {
2334         hexpected = DISP_E_BADVARTYPE;
2335       } else if(!lFound && !rFound)
2336       {
2337         hexpected = DISP_E_BADVARTYPE;
2338       }
2339
2340       V_VT(&v1) = l;
2341       V_VT(&v2) = r;
2342
2343       if(l == VT_CY)
2344         V_CY(&v1).int64 = 1000000;
2345       else if(l == VT_R4)
2346         V_R4(&v1) = 100;
2347       else if(l == VT_R8)
2348         V_R8(&v1) = 100;
2349       else if(l == VT_UI8)
2350         V_UI8(&v1) = 100;
2351       else if(l == VT_DATE)
2352         V_DATE(&v1) = 1000;
2353       else
2354         V_I4(&v1) = 10000;
2355
2356       if(r == VT_CY)
2357         V_CY(&v2).int64 = 10000;
2358       else if(r == VT_R4)
2359         V_R4(&v2) = 100;
2360       else if(r == VT_R8)
2361         V_R8(&v2) = 100;
2362       else if(r == VT_UI8)
2363         V_UI8(&v2) = 100;
2364       else if(r == VT_DATE)
2365         V_DATE(&v2) = 1000;
2366       else
2367         V_I4(&v2) = 10000;
2368
2369       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2370       {
2371         hres = pVarMod(&v1,&v2,&vDst);
2372         ok(hres == hexpected,
2373            "VarMod: expected 0x%lx, got 0x%lX for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2374       }
2375     }
2376   }
2377
2378
2379   /****************************/
2380   /* test some bad parameters */
2381   VARMOD(I4,I4,-1,-1,I4,0,S_OK);
2382
2383   /* test modulus with zero */
2384   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2385
2386   VARMOD(I4,I4,0,10,I4,0,S_OK); /* test 0 mod 10 */
2387
2388   /* right parameter is type empty */
2389   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2390
2391   /* left parameter is type empty */
2392   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2393
2394   /* mod with a null left value */
2395   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2396
2397   /* mod with a null right value */
2398   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2399
2400   /* void left value */
2401   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2402
2403   /* void right value */
2404   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2405
2406   /* null left value, void right value */
2407   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2408
2409   /* void left value, null right value */
2410   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2411
2412   /* some currencies */
2413   V_VT(&v1) = VT_CY;
2414   V_VT(&v2) = VT_CY;
2415   V_CY(&v1).int64 = 100000;
2416   V_CY(&v2).int64 = 100000;
2417   hres = pVarMod(&v1,&v2,&vDst);
2418   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2419      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2420
2421   V_VT(&v1) = VT_I4;
2422   V_VT(&v2) = VT_CY;
2423   V_I4(&v1) = 100;
2424   V_CY(&v2).int64 = 100000;
2425   hres = pVarMod(&v1,&v2,&vDst);
2426   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2427      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2428
2429   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2430
2431   /* test that an error results in the type of the result changing but not its value */
2432   V_VT(&v1) = VT_UNKNOWN;
2433   V_VT(&v2) = VT_EMPTY;
2434   V_I4(&v1) = 100;
2435   V_CY(&v2).int64 = 100000;
2436   V_VT(&vDst) = VT_I4;
2437   V_I4(&vDst) = 1231;
2438   hres = pVarMod(&v1,&v2,&vDst);
2439   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2440      "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));
2441
2442
2443   /* test some invalid types */
2444   /*TODO: not testing VT_DISPATCH */
2445   if (HAVE_OLEAUT32_I8)
2446   {
2447     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2448   }
2449   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2450   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2451   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2452   VARMOD2(DECIMAL,I4,100,10,EMPTY,0,DISP_E_OVERFLOW);
2453   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2454   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2455   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2456   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2457   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2458   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2459   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2460   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2461   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2462   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2463   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2464   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2465   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2466   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2467   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2468   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2469   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2470   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2471   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2472   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2473   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2474
2475   /* test some more invalid types */
2476   V_VT(&v1) = 456;
2477   V_VT(&v2) = 234;
2478   V_I4(&v1) = 100;
2479   V_I4(&v2)=  10;
2480   hres = pVarMod(&v1,&v2,&vDst);
2481   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 0,
2482      "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));
2483 }
2484
2485 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2486
2487 static const char *szVarFixFail = "VarFix: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2488 #define VARFIX(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2489         memset(&vDst,0,sizeof(vDst)); hres = pVarFix(&v,&vDst); \
2490         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2491         szVarFixFail, VT_##rvt, (int)(rval), \
2492         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2493
2494 static void test_VarFix(void)
2495 {
2496     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2497     HRESULT hres;
2498     VARIANT v, vDst;
2499     DECIMAL *pdec = &V_DECIMAL(&v);
2500     CY *pcy = &V_CY(&v);
2501     size_t i;
2502
2503     CHECKPTR(VarFix);
2504
2505     /* Test all possible V_VT values */
2506     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2507     {
2508         VARTYPE vt;
2509
2510         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2511         {
2512             HRESULT bFail = TRUE;
2513
2514             SKIPTESTS(vt);
2515
2516             memset(&v, 0, sizeof(v));
2517             V_VT(&v) = vt | ExtraFlags[i];
2518             V_VT(&vDst) = VT_EMPTY;
2519
2520             switch (V_VT(&v))
2521             {
2522               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2523               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2524               case VT_DATE: case VT_CY:
2525                 bFail = FALSE;
2526                 break;
2527               case VT_I8:
2528                 if (HAVE_OLEAUT32_I8)
2529                   bFail = FALSE;
2530                 break;
2531             }
2532
2533             hres = pVarFix(&v,&vDst);
2534             if (bFail)
2535               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2536                  "VarFix: expected failure, got 0x%lX vt %d|0x%X\n",
2537                  hres, vt, ExtraFlags[i]);
2538             else
2539                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%lX vt %d|0x%X\n",
2540                     hres, vt, ExtraFlags[i]);
2541         }
2542     }
2543
2544     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2545     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2546     VARFIX(BOOL,1,I2,1);
2547     VARFIX(UI1,1,UI1,1);
2548     VARFIX(I2,-1,I2,-1);
2549     VARFIX(I4,-1,I4,-1);
2550     if (HAVE_OLEAUT32_I8)
2551     {
2552         VARFIX(I8,-1,I8,-1);
2553     }
2554     VARFIX(R4,1.4,R4,1);
2555     VARFIX(R4,1.5,R4,1);
2556     VARFIX(R4,1.6,R4,1);
2557     VARFIX(R4,-1.4,R4,-1);
2558     VARFIX(R4,-1.5,R4,-1);
2559     VARFIX(R4,-1.6,R4,-1);
2560     /* DATE & R8 round as for R4 */
2561     VARFIX(DATE,-1,DATE,-1);
2562     VARFIX(R8,-1,R8,-1);
2563     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2564
2565     V_VT(&v) = VT_EMPTY;
2566     hres = pVarFix(&v,&vDst);
2567     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2568        "VarFix: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2569        hres, V_VT(&vDst), V_I2(&vDst));
2570
2571     V_VT(&v) = VT_NULL;
2572     hres = pVarFix(&v,&vDst);
2573     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2574        "VarFix: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2575
2576     V_VT(&v) = VT_DECIMAL;
2577     S(U(*pdec)).sign = DECIMAL_NEG;
2578     S(U(*pdec)).scale = 0;
2579     pdec->Hi32 = 0;
2580     S1(U1(*pdec)).Mid32 = 0;
2581     S1(U1(*pdec)).Lo32 = 1;
2582     hres = pVarFix(&v,&vDst);
2583     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2584        "VarFix: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
2585        hres, V_VT(&vDst));
2586
2587     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2588
2589     V_VT(&v) = VT_CY;
2590     pcy->int64 = -10000;
2591     hres = pVarFix(&v,&vDst);
2592     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2593        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
2594
2595     V_VT(&v) = VT_CY;
2596     pcy->int64 = -16000;
2597     hres = pVarFix(&v,&vDst);
2598     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2599        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
2600 }
2601
2602 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2603
2604 static const char *szVarIntFail = "VarInt: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2605 #define VARINT(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2606         memset(&vDst,0,sizeof(vDst)); hres = pVarInt(&v,&vDst); \
2607         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2608         szVarIntFail, VT_##rvt, (int)(rval), \
2609         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2610
2611 static void test_VarInt(void)
2612 {
2613     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2614     HRESULT hres;
2615     VARIANT v, vDst;
2616     DECIMAL *pdec = &V_DECIMAL(&v);
2617     CY *pcy = &V_CY(&v);
2618     size_t i;
2619
2620     CHECKPTR(VarInt);
2621
2622     /* Test all possible V_VT values */
2623     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2624     {
2625         VARTYPE vt;
2626
2627         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2628         {
2629             HRESULT bFail = TRUE;
2630
2631             SKIPTESTS(vt);
2632
2633             memset(&v, 0, sizeof(v));
2634             V_VT(&v) = vt | ExtraFlags[i];
2635             V_VT(&vDst) = VT_EMPTY;
2636
2637             switch (V_VT(&v))
2638             {
2639               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2640               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2641               case VT_DATE: case VT_CY:
2642                 bFail = FALSE;
2643                 break;
2644               case VT_I8:
2645                 if (HAVE_OLEAUT32_I8)
2646                   bFail = FALSE;
2647                 break;
2648             }
2649
2650             hres = pVarInt(&v,&vDst);
2651             if (bFail)
2652               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2653                  "VarInt: expected failure, got 0x%lX vt %d|0x%X\n",
2654                  hres, vt, ExtraFlags[i]);
2655             else
2656                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%lX vt %d|0x%X\n",
2657                     hres, vt, ExtraFlags[i]);
2658         }
2659     }
2660
2661     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2662     VARINT(BOOL,VARIANT_FALSE,I2,0);
2663     VARINT(BOOL,1,I2,1);
2664     VARINT(UI1,1,UI1,1);
2665     VARINT(I2,-1,I2,-1);
2666     VARINT(I4,-1,I4,-1);
2667     if (HAVE_OLEAUT32_I8)
2668     {
2669         VARINT(I8,-1,I8,-1);
2670     }
2671     VARINT(R4,1.4,R4,1);
2672     VARINT(R4,1.5,R4,1);
2673     VARINT(R4,1.6,R4,1);
2674     VARINT(R4,-1.4,R4,-2); /* Note these 3 are different from VarFix */
2675     VARINT(R4,-1.5,R4,-2);
2676     VARINT(R4,-1.6,R4,-2);
2677     /* DATE & R8 round as for R4 */
2678     VARINT(DATE,-1,DATE,-1);
2679     VARINT(R8,-1,R8,-1);
2680     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
2681
2682     V_VT(&v) = VT_EMPTY;
2683     hres = pVarInt(&v,&vDst);
2684     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2685        "VarInt: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2686        hres, V_VT(&vDst), V_I2(&vDst));
2687
2688     V_VT(&v) = VT_NULL;
2689     hres = pVarInt(&v,&vDst);
2690     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2691        "VarInt: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2692
2693     V_VT(&v) = VT_DECIMAL;
2694     S(U(*pdec)).sign = DECIMAL_NEG;
2695     S(U(*pdec)).scale = 0;
2696     pdec->Hi32 = 0;
2697     S1(U1(*pdec)).Mid32 = 0;
2698     S1(U1(*pdec)).Lo32 = 1;
2699     hres = pVarInt(&v,&vDst);
2700     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2701        "VarInt: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
2702        hres, V_VT(&vDst));
2703
2704     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
2705
2706     V_VT(&v) = VT_CY;
2707     pcy->int64 = -10000;
2708     hres = pVarInt(&v,&vDst);
2709     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2710        "VarInt: VT_CY wrong, hres=0x%lX\n", hres);
2711
2712     V_VT(&v) = VT_CY;
2713     pcy->int64 = -11000;
2714     hres = pVarInt(&v,&vDst);
2715     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
2716        "VarInt: VT_CY wrong, hres=0x%lX %lld\n", hres,V_CY(&vDst).int64);
2717 }
2718
2719 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
2720
2721 static const char *szVarNegFail = "VarNeg: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2722 #define VARNEG(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2723         memset(&vDst,0,sizeof(vDst)); hres = pVarNeg(&v,&vDst); \
2724         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2725         szVarNegFail, VT_##rvt, (int)(rval), \
2726         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2727
2728 static void test_VarNeg(void)
2729 {
2730     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2731     static const WCHAR szNum1[] = {'1','\0' };
2732     HRESULT hres;
2733     VARIANT v, vDst;
2734     DECIMAL *pdec = &V_DECIMAL(&v);
2735     CY *pcy = &V_CY(&v);
2736     size_t i;
2737
2738     CHECKPTR(VarNeg);
2739
2740     /* Test all possible V_VT values. But don't test the exact return values
2741      * except for success/failure, since M$ made a hash of them in the
2742      * native version. This at least ensures (as with all tests here) that
2743      * we will notice if/when new vtypes/flags are added in native.
2744      */
2745     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2746     {
2747         VARTYPE vt;
2748
2749         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2750         {
2751             HRESULT bFail = TRUE;
2752
2753             SKIPTESTS(vt);
2754
2755             memset(&v, 0, sizeof(v));
2756             V_VT(&v) = vt | ExtraFlags[i];
2757             V_VT(&vDst) = VT_EMPTY;
2758
2759             switch (V_VT(&v))
2760             {
2761             case VT_UI1: case VT_I2: case VT_I4:
2762             case VT_R4:  case VT_R8:
2763             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2764             case VT_DATE: case VT_CY:
2765                 bFail = FALSE;
2766                 break;
2767             case VT_I8:
2768                 if (HAVE_OLEAUT32_I8)
2769                     bFail = FALSE;
2770             }
2771
2772             hres = pVarNeg(&v,&vDst);
2773             if (bFail)
2774                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2775                    "VarNeg: expected failure, got 0x%lX vt %d|0x%X\n",
2776                    hres, vt, ExtraFlags[i]);
2777             else
2778                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%lX vt %d|0x%X\n",
2779                     hres, vt, ExtraFlags[i]);
2780         }
2781     }
2782
2783     VARNEG(BOOL,VARIANT_TRUE,I2,1);
2784     VARNEG(BOOL,VARIANT_FALSE,I2,0);
2785     VARNEG(BOOL,1,I2,-1);
2786     VARNEG(UI1,1,I2,-1);
2787     VARNEG(UI1,254,I2,-254);
2788     VARNEG(I2,-32768,I4,32768);
2789     VARNEG(I2,-1,I2,1);
2790     VARNEG(I2,1,I2,-1);
2791     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
2792     VARNEG(I4,-1,I4,1);
2793     VARNEG(I4,1,I4,-1);
2794     if (HAVE_OLEAUT32_I8)
2795     {
2796         VARNEG(I8,1,I8,-1);
2797         VARNEG(I8,-1,I8,1);
2798     }
2799     VARNEG(R4,1,R4,-1);
2800     VARNEG(R4,-1,R4,1);
2801     VARNEG(DATE,1,DATE,-1);
2802     VARNEG(DATE,-1,DATE,1);
2803     VARNEG(R8,1,R8,-1);
2804     VARNEG(R8,-1,R8,1);
2805     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
2806     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
2807
2808     V_VT(&v) = VT_EMPTY;
2809     hres = pVarNeg(&v,&vDst);
2810     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2811        "VarNeg: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2812        hres, V_VT(&vDst), V_I2(&vDst));
2813
2814     V_VT(&v) = VT_NULL;
2815     hres = pVarNeg(&v,&vDst);
2816     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2817        "VarNeg: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2818
2819     V_VT(&v) = VT_DECIMAL;
2820     S(U(*pdec)).sign = DECIMAL_NEG;
2821     S(U(*pdec)).scale = 0;
2822     pdec->Hi32 = 0;
2823     S1(U1(*pdec)).Mid32 = 0;
2824     S1(U1(*pdec)).Lo32 = 1;
2825     hres = pVarNeg(&v,&vDst);
2826     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2827        S(U(V_DECIMAL(&vDst))).sign == 0,
2828        "VarNeg: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2829        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2830
2831     S(U(*pdec)).sign = 0;
2832     hres = pVarNeg(&v,&vDst);
2833     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2834        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
2835        "VarNeg: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2836        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2837
2838     V_VT(&v) = VT_CY;
2839     pcy->int64 = -10000;
2840     hres = pVarNeg(&v,&vDst);
2841     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
2842        "VarNeg: VT_CY wrong, hres=0x%lX\n", hres);
2843 }
2844
2845 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
2846
2847 #define VARROUND(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2848         memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \
2849         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2850         "VarRound: expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##rvt, (int)(rval), \
2851         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2852
2853 #define VARROUNDF(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2854         memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \
2855         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2856         "VarRound: expected 0x0,%d,%f, got 0x%lX,%d,%f\n", VT_##rvt, rval, \
2857         hres, V_VT(&vDst), V_##rvt(&vDst))
2858
2859 static void test_VarRound(void)
2860 {
2861     /* static const WCHAR szNumMin[] = {'-','1','.','4','5','\0' };
2862        static const WCHAR szNum[] = {'1','.','4','5','\0' }; */
2863     HRESULT hres;
2864     VARIANT v, vDst;
2865     CY *pcy = &V_CY(&v);
2866
2867     CHECKPTR(VarRound);
2868
2869     /* first check valid integer types */
2870     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
2871     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
2872     VARROUND(BOOL,1,0,I2,1);
2873     VARROUND(UI1,1,0,UI1,1);
2874     VARROUND(UI1,254,0,UI1,254);
2875     VARROUND(I2,-32768,0,I2,-32768);
2876     VARROUND(I2,-1,0,I2,-1);
2877     VARROUND(I2,1,0,I2,1);
2878     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
2879     VARROUND(I4,-1,0,I4,-1);
2880     VARROUND(I4,1,0,I4,1);
2881
2882
2883     /* MSDN states that rounding of R4/R8 is dependent on the underlying
2884      * bit pattern of the number and so is architecture dependent. In this
2885      * case Wine returns .2 (which is more correct) and Native returns .3
2886      */
2887
2888     VARROUNDF(R4,1.0,0,R4,1.0);
2889     VARROUNDF(R4,-1.0,0,R4,-1.0);
2890     VARROUNDF(R8,1.0,0,R8,1.0);
2891     VARROUNDF(R8,-1.0,0,R8,-1.0);
2892
2893     /* floating point numbers aren't exactly equal and we can't just
2894      * compare the first few digits.
2895     todo_wine {
2896         VARROUNDF(DATE,1.451,1,DATE,1.5);
2897         VARROUNDF(DATE,-1.45,1,DATE,-1.4);
2898         VARROUNDF(BSTR,(BSTR)szNumMin,1,R8,-1.40);
2899         VARROUNDF(BSTR,(BSTR)szNum,1,R8,1.50);
2900
2901         VARROUNDF(R4,1.23456,0,R4,1.0);
2902         VARROUNDF(R4,1.23456,1,R4,1.2);
2903         VARROUNDF(R4,1.23456,2,R4,1.23);
2904         VARROUNDF(R4,1.23456,3,R4,1.235);
2905         VARROUNDF(R4,1.23456,4,R4,1.2346);
2906         VARROUNDF(R4,-1.23456,0,R4,-1.0);
2907         VARROUNDF(R4,-1.23456,1,R4,-1.2);
2908         VARROUNDF(R4,-1.23456,2,R4,-1.23);
2909         VARROUNDF(R4,-1.23456,3,R4,-1.235);
2910         VARROUNDF(R4,-1.23456,4,R4,-1.2346);
2911
2912         VARROUNDF(R8,1.23456,0,R8,1.0);
2913         VARROUNDF(R8,1.23456,1,R8,1.2);
2914         VARROUNDF(R8,1.23456,2,R8,1.23);
2915         VARROUNDF(R8,1.23456,3,R8,1.235);
2916         VARROUNDF(R8,1.23456,4,R8,1.2346);
2917         VARROUNDF(R8,-1.23456,0,R8,-1.0);
2918         VARROUNDF(R8,-1.23456,1,R8,-1.2);
2919         VARROUNDF(R8,-1.23456,2,R8,-1.23);
2920         VARROUNDF(R8,-1.23456,3,R8,-1.235);
2921         VARROUNDF(R8,-1.23456,4,R8,-1.2346);
2922     }
2923     */
2924
2925     V_VT(&v) = VT_EMPTY;
2926     hres = pVarRound(&v,0,&vDst);
2927     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2928         "VarRound: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2929         hres, V_VT(&vDst), V_I2(&vDst));
2930
2931     V_VT(&v) = VT_NULL;
2932     hres = pVarRound(&v,0,&vDst);
2933     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2934         "VarRound: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2935
2936     /* not yet implemented so no use testing yet
2937     todo_wine {
2938         DECIMAL *pdec = &V_DECIMAL(&v);
2939         V_VT(&v) = VT_DECIMAL;
2940         S(U(*pdec)).sign = DECIMAL_NEG;
2941         S(U(*pdec)).scale = 0;
2942         pdec->Hi32 = 0;
2943         S1(U1(*pdec)).Mid32 = 0;
2944         S1(U1(*pdec)).Lo32 = 1;
2945         hres = pVarRound(&v,0,&vDst);
2946         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2947             S(U(V_DECIMAL(&vDst))).sign == 0,
2948             "VarRound: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2949             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2950
2951         S(U(*pdec)).sign = 0;
2952         hres = pVarRound(&v,0,&vDst);
2953         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2954             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
2955             "VarRound: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2956             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2957     }
2958     */
2959
2960     V_VT(&v) = VT_CY;
2961     pcy->int64 = 10000;
2962     hres = pVarRound(&v,0,&vDst);
2963     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
2964         "VarRound: VT_CY wrong, hres=0x%lX\n", hres);
2965
2966 }
2967
2968 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
2969
2970 static const char *szVarXorFail = "VarXor(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2971 #define VARXOR(vt1,val1,vt2,val2,rvt,rval) \
2972         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
2973         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2974         memset(&result,0,sizeof(result)); hres = pVarXor(&left,&right,&result); \
2975         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
2976         szVarXorFail, VT_##vt1, VT_##vt2, \
2977         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
2978         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
2979            V_VT(&right) == VT_##vt2 && V_##vt2(&right) == val2, \
2980            "VarXor(%d,%d): Modified input arguments\n",VT_##vt1,VT_##vt2)
2981 #define VARXORCY(vt1,val1,val2,rvt,rval) \
2982         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
2983         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
2984         memset(&result,0,sizeof(result)); hres = pVarXor(&left,&right,&result); \
2985         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
2986         "VarXor(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##vt1, VT_CY, \
2987         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
2988         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
2989            V_VT(&right) == VT_CY && V_CY(&right).int64 == val2, \
2990            "VarXor(%d,%d): Modified input arguments\n",VT_##vt1,VT_CY)
2991
2992 static void test_VarXor(void)
2993 {
2994     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
2995     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
2996     VARIANT left, right, result;
2997     BSTR lbstr, rbstr;
2998     VARTYPE i;
2999     HRESULT hres;
3000
3001     CHECKPTR(VarXor);
3002
3003     /* Test all possible flag/vt combinations & the resulting vt type */
3004     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3005     {
3006         VARTYPE leftvt, rightvt, resvt;
3007
3008         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3009         {
3010
3011             SKIPTESTS(leftvt);
3012
3013             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3014             {
3015                 BOOL bFail = FALSE;
3016
3017                 SKIPTESTS(rightvt);
3018
3019                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3020                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3021                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3022                     continue;
3023
3024                 memset(&left, 0, sizeof(left));
3025                 memset(&right, 0, sizeof(right));
3026                 V_VT(&left) = leftvt | ExtraFlags[i];
3027                 V_VT(&right) = rightvt | ExtraFlags[i];
3028                 V_VT(&result) = VT_EMPTY;
3029                 resvt = VT_I4;
3030
3031                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3032                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3033                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3034                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3035                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3036                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3037                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3038                 {
3039                     bFail = TRUE;
3040                 }
3041                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3042                 {
3043                     if (leftvt == rightvt ||
3044                         leftvt == VT_I2 || rightvt == VT_I2 ||
3045                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3046                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3047                         resvt = VT_I2;
3048                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3049                         resvt = VT_NULL;
3050                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3051                         resvt = VT_I8;
3052                 }
3053                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3054                 {
3055                     resvt = VT_NULL;
3056                 }
3057                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3058                 {
3059                     if (leftvt == rightvt)
3060                         resvt = VT_UI1;
3061                     else if (leftvt == rightvt ||
3062                         leftvt == VT_I2 || rightvt == VT_I2 ||
3063                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3064                     {
3065                         resvt = VT_I2;
3066                     }
3067                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3068                         resvt = VT_I8;
3069                 }
3070                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3071                 {
3072                     if (leftvt == rightvt ||
3073                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3074                         resvt = VT_I2;
3075                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3076                         resvt = VT_I8;
3077                 }
3078                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3079                 {
3080                     resvt = VT_BOOL;
3081                 }
3082                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3083                 {
3084                     if (leftvt == VT_INT || rightvt == VT_INT)
3085                         bFail = TRUE;
3086                     else
3087                         resvt = VT_I8;
3088                 }
3089                 hres = pVarXor(&left, &right, &result);
3090                 if (bFail)
3091                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3092                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
3093                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3094                        V_VT(&result));
3095                 else
3096                     ok(hres == S_OK && V_VT(&result) == resvt,
3097                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
3098                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3099                        V_VT(&result));
3100             }
3101         }
3102     }
3103
3104     /* Test returned values
3105      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3106      */
3107     VARXOR(EMPTY,0,EMPTY,0,I2,0);
3108     VARXOR(EMPTY,1,EMPTY,0,I2,0);
3109     VARXOR(EMPTY,0,NULL,0,NULL,0);
3110     VARXOR(EMPTY,0,I1,0,I4,0);
3111     VARXOR(EMPTY,0,I1,1,I4,1);
3112     VARXOR(EMPTY,0,UI1,0,I2,0);
3113     VARXOR(EMPTY,0,UI1,1,I2,1);
3114     VARXOR(EMPTY,0,I2,0,I2,0);
3115     VARXOR(EMPTY,0,I2,1,I2,1);
3116     VARXOR(EMPTY,0,UI2,0,I4,0);
3117     VARXOR(EMPTY,0,UI2,1,I4,1);
3118     VARXOR(EMPTY,0,I4,0,I4,0);
3119     VARXOR(EMPTY,0,I4,1,I4,1);
3120     VARXOR(EMPTY,0,UI4,0,I4,0);
3121     VARXOR(EMPTY,0,UI4,1,I4,1);
3122     if (HAVE_OLEAUT32_I8)
3123     {
3124         VARXOR(EMPTY,0,I8,0,I8,0);
3125         VARXOR(EMPTY,0,I8,1,I8,1);
3126         VARXOR(EMPTY,0,UI8,0,I4,0);
3127         VARXOR(EMPTY,0,UI8,1,I4,1);
3128     }
3129     VARXOR(EMPTY,0,INT,0,I4,0);
3130     VARXOR(EMPTY,0,INT,1,I4,1);
3131     VARXOR(EMPTY,0,UINT,0,I4,0);
3132     VARXOR(EMPTY,0,UINT,1,I4,1);
3133     VARXOR(EMPTY,0,BOOL,0,I2,0);
3134     VARXOR(EMPTY,0,BOOL,1,I2,1);
3135     VARXOR(EMPTY,0,R4,0,I4,0);
3136     VARXOR(EMPTY,0,R4,1,I4,1);
3137     VARXOR(EMPTY,0,R8,0,I4,0);
3138     VARXOR(EMPTY,0,R8,1,I4,1);
3139     rbstr = SysAllocString(szFalse);
3140     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3141     rbstr = SysAllocString(szTrue);
3142     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3143     VARXORCY(EMPTY,0,10000,I4,1);
3144
3145     /* NULL OR 0 = NULL. NULL OR n = n */
3146     VARXOR(NULL,0,NULL,0,NULL,0);
3147     VARXOR(NULL,1,NULL,0,NULL,0);
3148     VARXOR(NULL,0,I1,0,NULL,0);
3149     VARXOR(NULL,0,I1,1,NULL,0);
3150     VARXOR(NULL,0,UI1,0,NULL,0);
3151     VARXOR(NULL,0,UI1,1,NULL,0);
3152     VARXOR(NULL,0,I2,0,NULL,0);
3153     VARXOR(NULL,0,I2,1,NULL,0);
3154     VARXOR(NULL,0,UI2,0,NULL,0);
3155     VARXOR(NULL,0,UI2,1,NULL,0);
3156     VARXOR(NULL,0,I4,0,NULL,0);
3157     VARXOR(NULL,0,I4,1,NULL,0);
3158     VARXOR(NULL,0,UI4,0,NULL,0);
3159     VARXOR(NULL,0,UI4,1,NULL,0);
3160     if (HAVE_OLEAUT32_I8)
3161     {
3162         VARXOR(NULL,0,I8,0,NULL,0);
3163         VARXOR(NULL,0,I8,1,NULL,0);
3164         VARXOR(NULL,0,UI8,0,NULL,0);
3165         VARXOR(NULL,0,UI8,1,NULL,0);
3166     }
3167     VARXOR(NULL,0,INT,0,NULL,0);
3168     VARXOR(NULL,0,INT,1,NULL,0);
3169     VARXOR(NULL,0,UINT,0,NULL,0);
3170     VARXOR(NULL,0,UINT,1,NULL,0);
3171     VARXOR(NULL,0,BOOL,0,NULL,0);
3172     VARXOR(NULL,0,BOOL,1,NULL,0);
3173     VARXOR(NULL,0,R4,0,NULL,0);
3174     VARXOR(NULL,0,R4,1,NULL,0);
3175     VARXOR(NULL,0,R8,0,NULL,0);
3176     VARXOR(NULL,0,R8,1,NULL,0);
3177     rbstr = SysAllocString(szFalse);
3178     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3179     rbstr = SysAllocString(szTrue);
3180     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3181     VARXORCY(NULL,0,10000,NULL,0);
3182     VARXORCY(NULL,0,0,NULL,0);
3183
3184     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3185     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3186     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3187     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3188     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3189     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3190     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3191     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3192     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3193     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3194     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3195     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3196     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3197     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3198     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3199     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3200     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3201     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3202     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3203     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3204     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3205     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3206     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3207     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3208     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3209     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3210     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3211     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3212     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3213     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3214     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3215     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3216     if (HAVE_OLEAUT32_I8)
3217     {
3218         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3219         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3220         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3221         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3222          * to I4 is performed.
3223          */
3224         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3225         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3226         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3227     }
3228     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3229     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3230     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3231     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3232     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3233     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3234     rbstr = SysAllocString(szFalse);
3235     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3236     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3237     rbstr = SysAllocString(szTrue);
3238     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3239     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3240     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3241     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3242     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3243
3244     VARXOR(I1,-1,I1,-1,I4,0);
3245     VARXOR(I1,-1,I1,0,I4,-1);
3246     VARXOR(I1,0,I1,0,I4,0);
3247     VARXOR(I1,-1,UI1,255,I4,-256);
3248     VARXOR(I1,-1,UI1,0,I4,-1);
3249     VARXOR(I1,0,UI1,0,I4,0);
3250     VARXOR(I1,-1,I2,-1,I4,0);
3251     VARXOR(I1,-1,I2,0,I4,-1);
3252     VARXOR(I1,0,I2,0,I4,0);
3253     VARXOR(I1,-1,UI2,65535,I4,-65536);
3254     VARXOR(I1,-1,UI2,0,I4,-1);
3255     VARXOR(I1,0,UI2,0,I4,0);
3256     VARXOR(I1,-1,I4,-1,I4,0);
3257     VARXOR(I1,-1,I4,0,I4,-1);
3258     VARXOR(I1,0,I4,0,I4,0);
3259     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3260     VARXOR(I1,-1,UI4,0,I4,-1);
3261     VARXOR(I1,0,UI4,0,I4,0);
3262     VARXOR(I1,-1,R4,-1,I4,0);
3263     VARXOR(I1,-1,R4,0,I4,-1);
3264     VARXOR(I1,0,R4,0,I4,0);
3265     VARXOR(I1,-1,R8,-1,I4,0);
3266     VARXOR(I1,-1,R8,0,I4,-1);
3267     VARXOR(I1,0,R8,0,I4,0);
3268     VARXOR(I1,-1,DATE,-1,I4,0);
3269     VARXOR(I1,-1,DATE,0,I4,-1);
3270     VARXOR(I1,0,DATE,0,I4,0);
3271     if (HAVE_OLEAUT32_I8)
3272     {
3273         VARXOR(I1,-1,I8,-1,I8,0);
3274         VARXOR(I1,-1,I8,0,I8,-1);
3275         VARXOR(I1,0,I8,0,I8,0);
3276         VARXOR(I1,-1,UI8,0,I4,-1);
3277         VARXOR(I1,0,UI8,0,I4,0);
3278     }
3279     VARXOR(I1,-1,INT,-1,I4,0);
3280     VARXOR(I1,-1,INT,0,I4,-1);
3281     VARXOR(I1,0,INT,0,I4,0);
3282     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3283     VARXOR(I1,-1,UINT,0,I4,-1);
3284     VARXOR(I1,0,UINT,0,I4,0);
3285     rbstr = SysAllocString(szFalse);
3286     VARXOR(I1,0,BSTR,rbstr,I4,0);
3287     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3288     rbstr = SysAllocString(szTrue);
3289     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3290     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3291     VARXORCY(I1,-1,10000,I4,-2);
3292     VARXORCY(I1,-1,0,I4,-1);
3293     VARXORCY(I1,0,0,I4,0);
3294
3295     VARXOR(UI1,255,UI1,255,UI1,0);
3296     VARXOR(UI1,255,UI1,0,UI1,255);
3297     VARXOR(UI1,0,UI1,0,UI1,0);
3298     VARXOR(UI1,255,I2,-1,I2,-256);
3299     VARXOR(UI1,255,I2,0,I2,255);
3300     VARXOR(UI1,0,I2,0,I2,0);
3301     VARXOR(UI1,255,UI2,65535,I4,65280);
3302     VARXOR(UI1,255,UI2,0,I4,255);
3303     VARXOR(UI1,0,UI2,0,I4,0);
3304     VARXOR(UI1,255,I4,-1,I4,-256);
3305     VARXOR(UI1,255,I4,0,I4,255);
3306     VARXOR(UI1,0,I4,0,I4,0);
3307     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3308     VARXOR(UI1,255,UI4,0,I4,255);
3309     VARXOR(UI1,0,UI4,0,I4,0);
3310     VARXOR(UI1,255,R4,-1,I4,-256);
3311     VARXOR(UI1,255,R4,0,I4,255);
3312     VARXOR(UI1,0,R4,0,I4,0);
3313     VARXOR(UI1,255,R8,-1,I4,-256);
3314     VARXOR(UI1,255,R8,0,I4,255);
3315     VARXOR(UI1,0,R8,0,I4,0);
3316     VARXOR(UI1,255,DATE,-1,I4,-256);
3317     VARXOR(UI1,255,DATE,0,I4,255);
3318     VARXOR(UI1,0,DATE,0,I4,0);
3319     if (HAVE_OLEAUT32_I8)
3320     {
3321         VARXOR(UI1,255,I8,-1,I8,-256);
3322         VARXOR(UI1,255,I8,0,I8,255);
3323         VARXOR(UI1,0,I8,0,I8,0);
3324         VARXOR(UI1,255,UI8,0,I4,255);
3325         VARXOR(UI1,0,UI8,0,I4,0);
3326     }
3327     VARXOR(UI1,255,INT,-1,I4,-256);
3328     VARXOR(UI1,255,INT,0,I4,255);
3329     VARXOR(UI1,0,INT,0,I4,0);
3330     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3331     VARXOR(UI1,255,UINT,0,I4,255);
3332     VARXOR(UI1,0,UINT,0,I4,0);
3333     rbstr = SysAllocString(szFalse);
3334     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3335     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3336     rbstr = SysAllocString(szTrue);
3337     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3338     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3339     VARXORCY(UI1,255,10000,I4,254);
3340     VARXORCY(UI1,255,0,I4,255);
3341     VARXORCY(UI1,0,0,I4,0);
3342
3343     VARXOR(I2,-1,I2,-1,I2,0);
3344     VARXOR(I2,-1,I2,0,I2,-1);
3345     VARXOR(I2,0,I2,0,I2,0);
3346     VARXOR(I2,-1,UI2,65535,I4,-65536);
3347     VARXOR(I2,-1,UI2,0,I4,-1);
3348     VARXOR(I2,0,UI2,0,I4,0);
3349     VARXOR(I2,-1,I4,-1,I4,0);
3350     VARXOR(I2,-1,I4,0,I4,-1);
3351     VARXOR(I2,0,I4,0,I4,0);
3352     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3353     VARXOR(I2,-1,UI4,0,I4,-1);
3354     VARXOR(I2,0,UI4,0,I4,0);
3355     VARXOR(I2,-1,R4,-1,I4,0);
3356     VARXOR(I2,-1,R4,0,I4,-1);
3357     VARXOR(I2,0,R4,0,I4,0);
3358     VARXOR(I2,-1,R8,-1,I4,0);
3359     VARXOR(I2,-1,R8,0,I4,-1);
3360     VARXOR(I2,0,R8,0,I4,0);
3361     VARXOR(I2,-1,DATE,-1,I4,0);
3362     VARXOR(I2,-1,DATE,0,I4,-1);
3363     VARXOR(I2,0,DATE,0,I4,0);
3364     if (HAVE_OLEAUT32_I8)
3365     {
3366         VARXOR(I2,-1,I8,-1,I8,0);
3367         VARXOR(I2,-1,I8,0,I8,-1);
3368         VARXOR(I2,0,I8,0,I8,0);
3369         VARXOR(I2,-1,UI8,0,I4,-1);
3370         VARXOR(I2,0,UI8,0,I4,0);
3371     }
3372     VARXOR(I2,-1,INT,-1,I4,0);
3373     VARXOR(I2,-1,INT,0,I4,-1);
3374     VARXOR(I2,0,INT,0,I4,0);
3375     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3376     VARXOR(I2,-1,UINT,0,I4,-1);
3377     VARXOR(I2,0,UINT,0,I4,0);
3378     rbstr = SysAllocString(szFalse);
3379     VARXOR(I2,0,BSTR,rbstr,I2,0);
3380     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3381     rbstr = SysAllocString(szTrue);
3382     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3383     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3384     VARXORCY(I2,-1,10000,I4,-2);
3385     VARXORCY(I2,-1,0,I4,-1);
3386     VARXORCY(I2,0,0,I4,0);
3387
3388     VARXOR(UI2,65535,UI2,65535,I4,0);
3389     VARXOR(UI2,65535,UI2,0,I4,65535);
3390     VARXOR(UI2,0,UI2,0,I4,0);
3391     VARXOR(UI2,65535,I4,-1,I4,-65536);
3392     VARXOR(UI2,65535,I4,0,I4,65535);
3393     VARXOR(UI2,0,I4,0,I4,0);
3394     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3395     VARXOR(UI2,65535,UI4,0,I4,65535);
3396     VARXOR(UI2,0,UI4,0,I4,0);
3397     VARXOR(UI2,65535,R4,-1,I4,-65536);
3398     VARXOR(UI2,65535,R4,0,I4,65535);
3399     VARXOR(UI2,0,R4,0,I4,0);
3400     VARXOR(UI2,65535,R8,-1,I4,-65536);
3401     VARXOR(UI2,65535,R8,0,I4,65535);
3402     VARXOR(UI2,0,R8,0,I4,0);
3403     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3404     VARXOR(UI2,65535,DATE,0,I4,65535);
3405     VARXOR(UI2,0,DATE,0,I4,0);
3406     if (HAVE_OLEAUT32_I8)
3407     {
3408         VARXOR(UI2,65535,I8,-1,I8,-65536);
3409         VARXOR(UI2,65535,I8,0,I8,65535);
3410         VARXOR(UI2,0,I8,0,I8,0);
3411         VARXOR(UI2,65535,UI8,0,I4,65535);
3412         VARXOR(UI2,0,UI8,0,I4,0);
3413     }
3414     VARXOR(UI2,65535,INT,-1,I4,-65536);
3415     VARXOR(UI2,65535,INT,0,I4,65535);
3416     VARXOR(UI2,0,INT,0,I4,0);
3417     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3418     VARXOR(UI2,65535,UINT,0,I4,65535);
3419     VARXOR(UI2,0,UINT,0,I4,0);
3420     rbstr = SysAllocString(szFalse);
3421     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3422     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3423     rbstr = SysAllocString(szTrue);
3424     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3425     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3426     VARXORCY(UI2,65535,10000,I4,65534);
3427     VARXORCY(UI2,65535,0,I4,65535);
3428     VARXORCY(UI2,0,0,I4,0);
3429
3430     VARXOR(I4,-1,I4,-1,I4,0);
3431     VARXOR(I4,-1,I4,0,I4,-1);
3432     VARXOR(I4,0,I4,0,I4,0);
3433     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3434     VARXOR(I4,-1,UI4,0,I4,-1);
3435     VARXOR(I4,0,UI4,0,I4,0);
3436     VARXOR(I4,-1,R4,-1,I4,0);
3437     VARXOR(I4,-1,R4,0,I4,-1);
3438     VARXOR(I4,0,R4,0,I4,0);
3439     VARXOR(I4,-1,R8,-1,I4,0);
3440     VARXOR(I4,-1,R8,0,I4,-1);
3441     VARXOR(I4,0,R8,0,I4,0);
3442     VARXOR(I4,-1,DATE,-1,I4,0);
3443     VARXOR(I4,-1,DATE,0,I4,-1);
3444     VARXOR(I4,0,DATE,0,I4,0);
3445     if (HAVE_OLEAUT32_I8)
3446     {
3447         VARXOR(I4,-1,I8,-1,I8,0);
3448         VARXOR(I4,-1,I8,0,I8,-1);
3449         VARXOR(I4,0,I8,0,I8,0);
3450         VARXOR(I4,-1,UI8,0,I4,-1);
3451         VARXOR(I4,0,UI8,0,I4,0);
3452     }
3453     VARXOR(I4,-1,INT,-1,I4,0);
3454     VARXOR(I4,-1,INT,0,I4,-1);
3455     VARXOR(I4,0,INT,0,I4,0);
3456     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3457     VARXOR(I4,-1,UINT,0,I4,-1);
3458     VARXOR(I4,0,UINT,0,I4,0);
3459     rbstr = SysAllocString(szFalse);
3460     VARXOR(I4,0,BSTR,rbstr,I4,0);
3461     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3462     rbstr = SysAllocString(szTrue);
3463     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3464     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3465     VARXORCY(I4,-1,10000,I4,-2);
3466     VARXORCY(I4,-1,0,I4,-1);
3467     VARXORCY(I4,0,0,I4,0);
3468
3469     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3470     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3471     VARXOR(UI4,0,UI4,0,I4,0);
3472     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3473     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3474     VARXOR(UI4,0,R4,0,I4,0);
3475     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3476     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3477     VARXOR(UI4,0,R8,0,I4,0);
3478     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3479     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3480     VARXOR(UI4,0,DATE,0,I4,0);
3481     if (HAVE_OLEAUT32_I8)
3482     {
3483         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3484         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3485         VARXOR(UI4,0,I8,0,I8,0);
3486         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3487         VARXOR(UI4,0,UI8,0,I4,0);
3488     }
3489     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3490     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3491     VARXOR(UI4,0,INT,0,I4,0);
3492     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3493     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3494     VARXOR(UI4,0,UINT,0,I4,0);
3495     rbstr = SysAllocString(szFalse);
3496     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3497     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3498     rbstr = SysAllocString(szTrue);
3499     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3500     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3501     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3502     VARXORCY(UI4,0xffffffff,0,I4,-1);
3503     VARXORCY(UI4,0,0,I4,0);
3504
3505     VARXOR(R4,-1,R4,-1,I4,0);
3506     VARXOR(R4,-1,R4,0,I4,-1);
3507     VARXOR(R4,0,R4,0,I4,0);
3508     VARXOR(R4,-1,R8,-1,I4,0);
3509     VARXOR(R4,-1,R8,0,I4,-1);
3510     VARXOR(R4,0,R8,0,I4,0);
3511     VARXOR(R4,-1,DATE,-1,I4,0);
3512     VARXOR(R4,-1,DATE,0,I4,-1);
3513     VARXOR(R4,0,DATE,0,I4,0);
3514     if (HAVE_OLEAUT32_I8)
3515     {
3516         VARXOR(R4,-1,I8,-1,I8,0);
3517         VARXOR(R4,-1,I8,0,I8,-1);
3518         VARXOR(R4,0,I8,0,I8,0);
3519         VARXOR(R4,-1,UI8,0,I4,-1);
3520         VARXOR(R4,0,UI8,0,I4,0);
3521     }
3522     VARXOR(R4,-1,INT,-1,I4,0);
3523     VARXOR(R4,-1,INT,0,I4,-1);
3524     VARXOR(R4,0,INT,0,I4,0);
3525     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3526     VARXOR(R4,-1,UINT,0,I4,-1);
3527     VARXOR(R4,0,UINT,0,I4,0);
3528     rbstr = SysAllocString(szFalse);
3529     VARXOR(R4,0,BSTR,rbstr,I4,0);
3530     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3531     rbstr = SysAllocString(szTrue);
3532     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3533     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3534     VARXORCY(R4,-1,10000,I4,-2);
3535     VARXORCY(R4,-1,0,I4,-1);
3536     VARXORCY(R4,0,0,I4,0);
3537
3538     VARXOR(R8,-1,R8,-1,I4,0);
3539     VARXOR(R8,-1,R8,0,I4,-1);
3540     VARXOR(R8,0,R8,0,I4,0);
3541     VARXOR(R8,-1,DATE,-1,I4,0);
3542     VARXOR(R8,-1,DATE,0,I4,-1);
3543     VARXOR(R8,0,DATE,0,I4,0);
3544     if (HAVE_OLEAUT32_I8)
3545     {
3546         VARXOR(R8,-1,I8,-1,I8,0);
3547         VARXOR(R8,-1,I8,0,I8,-1);
3548         VARXOR(R8,0,I8,0,I8,0);
3549         VARXOR(R8,-1,UI8,0,I4,-1);
3550         VARXOR(R8,0,UI8,0,I4,0);
3551     }
3552     VARXOR(R8,-1,INT,-1,I4,0);
3553     VARXOR(R8,-1,INT,0,I4,-1);
3554     VARXOR(R8,0,INT,0,I4,0);
3555     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3556     VARXOR(R8,-1,UINT,0,I4,-1);
3557     VARXOR(R8,0,UINT,0,I4,0);
3558     rbstr = SysAllocString(szFalse);
3559     VARXOR(R8,0,BSTR,rbstr,I4,0);
3560     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3561     rbstr = SysAllocString(szTrue);
3562     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3563     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3564     VARXORCY(R8,-1,10000,I4,-2);
3565     VARXORCY(R8,-1,0,I4,-1);
3566     VARXORCY(R8,0,0,I4,0);
3567
3568     VARXOR(DATE,-1,DATE,-1,I4,0);
3569     VARXOR(DATE,-1,DATE,0,I4,-1);
3570     VARXOR(DATE,0,DATE,0,I4,0);
3571     if (HAVE_OLEAUT32_I8)
3572     {
3573         VARXOR(DATE,-1,I8,-1,I8,0);
3574         VARXOR(DATE,-1,I8,0,I8,-1);
3575         VARXOR(DATE,0,I8,0,I8,0);
3576         VARXOR(DATE,-1,UI8,0,I4,-1);
3577         VARXOR(DATE,0,UI8,0,I4,0);
3578     }
3579     VARXOR(DATE,-1,INT,-1,I4,0);
3580     VARXOR(DATE,-1,INT,0,I4,-1);
3581     VARXOR(DATE,0,INT,0,I4,0);
3582     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3583     VARXOR(DATE,-1,UINT,0,I4,-1);
3584     VARXOR(DATE,0,UINT,0,I4,0);
3585     rbstr = SysAllocString(szFalse);
3586     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3587     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3588     rbstr = SysAllocString(szTrue);
3589     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3590     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3591     VARXORCY(DATE,-1,10000,I4,-2);
3592     VARXORCY(DATE,-1,0,I4,-1);
3593     VARXORCY(DATE,0,0,I4,0);
3594
3595     if (HAVE_OLEAUT32_I8)
3596     {
3597         VARXOR(I8,-1,I8,-1,I8,0);
3598         VARXOR(I8,-1,I8,0,I8,-1);
3599         VARXOR(I8,0,I8,0,I8,0);
3600         VARXOR(I8,-1,UI8,0,I8,-1);
3601         VARXOR(I8,0,UI8,0,I8,0);
3602         VARXOR(I8,-1,UINT,0,I8,-1);
3603         VARXOR(I8,0,UINT,0,I8,0);
3604         rbstr = SysAllocString(szFalse);
3605         VARXOR(I8,0,BSTR,rbstr,I8,0);
3606         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
3607         rbstr = SysAllocString(szTrue);
3608         VARXOR(I8,0,BSTR,rbstr,I8,-1);
3609         VARXOR(I8,-1,BSTR,rbstr,I8,0);
3610         VARXORCY(I8,-1,10000,I8,-2);
3611         VARXORCY(I8,-1,0,I8,-1);
3612         VARXORCY(I8,0,0,I8,0);
3613
3614         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
3615         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
3616         VARXOR(UI8,0,UI8,0,I4,0);
3617         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
3618         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
3619         VARXOR(UI8,0,INT,0,I4,0);
3620         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
3621         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
3622         VARXOR(UI8,0,UINT,0,I4,0);
3623         rbstr = SysAllocString(szFalse);
3624         VARXOR(UI8,0,BSTR,rbstr,I4,0);
3625         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
3626         rbstr = SysAllocString(szTrue);
3627         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
3628         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
3629         VARXORCY(UI8,0xffff,10000,I4,65534);
3630         VARXORCY(UI8,0xffff,0,I4,0xffff);
3631         VARXORCY(UI8,0,0,I4,0);
3632     }
3633
3634     VARXOR(INT,-1,INT,-1,I4,0);
3635     VARXOR(INT,-1,INT,0,I4,-1);
3636     VARXOR(INT,0,INT,0,I4,0);
3637     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
3638     VARXOR(INT,-1,UINT,0,I4,-1);
3639     VARXOR(INT,0,UINT,0,I4,0);
3640     rbstr = SysAllocString(szFalse);
3641     VARXOR(INT,0,BSTR,rbstr,I4,0);
3642     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
3643     rbstr = SysAllocString(szTrue);
3644     VARXOR(INT,0,BSTR,rbstr,I4,-1);
3645     VARXOR(INT,-1,BSTR,rbstr,I4,0);
3646     VARXORCY(INT,-1,10000,I4,-2);
3647     VARXORCY(INT,-1,0,I4,-1);
3648     VARXORCY(INT,0,0,I4,0);
3649
3650     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
3651     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
3652     VARXOR(UINT,0,UINT,0,I4,0);
3653     rbstr = SysAllocString(szFalse);
3654     VARXOR(UINT,0,BSTR,rbstr,I4,0);
3655     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
3656     rbstr = SysAllocString(szTrue);
3657     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
3658     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
3659     VARXORCY(UINT,0xffff,10000,I4,65534);
3660     VARXORCY(UINT,0xffff,0,I4,0xffff);
3661     VARXORCY(UINT,0,0,I4,0);
3662
3663     lbstr = SysAllocString(szFalse);
3664     rbstr = SysAllocString(szFalse);
3665     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
3666     rbstr = SysAllocString(szTrue);
3667     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
3668     lbstr = SysAllocString(szTrue);
3669     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
3670     VARXORCY(BSTR,lbstr,10000,I4,-2);
3671     lbstr = SysAllocString(szFalse);
3672     VARXORCY(BSTR,lbstr,10000,I4,1);
3673 }
3674
3675 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
3676
3677 static const char *szVarOrFail = "VarOr(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
3678 static const char *szVarOrChanged = "VarOr(%d,%d): Modified input arguments\n";
3679 #define VAROR(vt1,val1,vt2,val2,rvt,rval) \
3680         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3681         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3682         memset(&result,0,sizeof(result)); hres = pVarOr(&left,&right,&result); \
3683         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3684         szVarOrFail, VT_##vt1, VT_##vt2, \
3685         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3686         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3687            V_VT(&right) == VT_##vt2 && V_##vt2(&right) == val2, \
3688            szVarOrChanged,VT_##vt1,VT_##vt2)
3689 #define VARORCY(vt1,val1,val2,rvt,rval) \
3690         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3691         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3692         memset(&result,0,sizeof(result)); hres = pVarOr(&left,&right,&result); \
3693         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3694         "VarOr(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##vt1, VT_CY, \
3695         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3696         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3697            V_VT(&right) == VT_CY && V_CY(&right).int64 == val2, \
3698            "VarOr(%d,%d): Modified input arguments\n",VT_##vt1,VT_CY)
3699
3700 static void test_VarOr(void)
3701 {
3702     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3703     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3704     VARIANT left, right, result;
3705     BSTR lbstr, rbstr;
3706     VARTYPE i;
3707     HRESULT hres;
3708
3709     CHECKPTR(VarOr);
3710
3711     /* Test all possible flag/vt combinations & the resulting vt type */
3712     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3713     {
3714         VARTYPE leftvt, rightvt, resvt;
3715
3716         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3717         {
3718
3719             SKIPTESTS(leftvt);
3720
3721             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3722             {
3723                 BOOL bFail = FALSE;
3724
3725                 SKIPTESTS(rightvt);
3726
3727                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3728                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3729                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3730                     continue;
3731
3732                 memset(&left, 0, sizeof(left));
3733                 memset(&right, 0, sizeof(right));
3734                 V_VT(&left) = leftvt | ExtraFlags[i];
3735                 V_VT(&right) = rightvt | ExtraFlags[i];
3736                 V_VT(&result) = VT_EMPTY;
3737                 resvt = VT_I4;
3738
3739                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3740                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3741                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3742                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3743                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3744                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3745                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3746                 {
3747                     bFail = TRUE;
3748                 }
3749                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3750                 {
3751                     if (leftvt == rightvt ||
3752                         leftvt == VT_I2 || rightvt == VT_I2 ||
3753                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3754                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3755                         resvt = VT_I2;
3756                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3757                         resvt = VT_NULL;
3758                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3759                         resvt = VT_I8;
3760                 }
3761                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3762                 {
3763                     resvt = VT_NULL;
3764                 }
3765                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3766                 {
3767                     if (leftvt == rightvt)
3768                         resvt = VT_UI1;
3769                     else if (leftvt == rightvt ||
3770                         leftvt == VT_I2 || rightvt == VT_I2 ||
3771                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3772                     {
3773                         resvt = VT_I2;
3774                     }
3775                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3776                         resvt = VT_I8;
3777                 }
3778                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3779                 {
3780                     if (leftvt == rightvt ||
3781                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3782                         resvt = VT_I2;
3783                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3784                         resvt = VT_I8;
3785                 }
3786                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3787                 {
3788                     resvt = VT_BOOL;
3789                 }
3790                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3791                 {
3792                     if (leftvt == VT_INT || rightvt == VT_INT)
3793                         bFail = TRUE;
3794                     else
3795                         resvt = VT_I8;
3796                 }
3797                 hres = pVarOr(&left, &right, &result);
3798                 if (bFail)
3799                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3800                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
3801                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3802                        V_VT(&result));
3803                 else
3804                     ok(hres == S_OK && V_VT(&result) == resvt,
3805                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
3806                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3807                        V_VT(&result));
3808             }
3809         }
3810     }
3811
3812     /* Test returned values. Since we know the returned type is correct
3813      * and that we handle all combinations of invalid types, just check
3814      * that good type combinations produce the desired value.
3815      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3816      */
3817     VAROR(EMPTY,0,EMPTY,0,I2,0);
3818     VAROR(EMPTY,1,EMPTY,0,I2,0);
3819     VAROR(EMPTY,0,NULL,0,NULL,0);
3820     VAROR(EMPTY,0,I1,0,I4,0);
3821     VAROR(EMPTY,0,I1,1,I4,1);
3822     VAROR(EMPTY,0,UI1,0,I2,0);
3823     VAROR(EMPTY,0,UI1,1,I2,1);
3824     VAROR(EMPTY,0,I2,0,I2,0);
3825     VAROR(EMPTY,0,I2,1,I2,1);
3826     VAROR(EMPTY,0,UI2,0,I4,0);
3827     VAROR(EMPTY,0,UI2,1,I4,1);
3828     VAROR(EMPTY,0,I4,0,I4,0);
3829     VAROR(EMPTY,0,I4,1,I4,1);
3830     VAROR(EMPTY,0,UI4,0,I4,0);
3831     VAROR(EMPTY,0,UI4,1,I4,1);
3832     if (HAVE_OLEAUT32_I8)
3833     {
3834         VAROR(EMPTY,0,I8,0,I8,0);
3835         VAROR(EMPTY,0,I8,1,I8,1);
3836         VAROR(EMPTY,0,UI8,0,I4,0);
3837         VAROR(EMPTY,0,UI8,1,I4,1);
3838     }
3839     VAROR(EMPTY,0,INT,0,I4,0);
3840     VAROR(EMPTY,0,INT,1,I4,1);
3841     VAROR(EMPTY,0,UINT,0,I4,0);
3842     VAROR(EMPTY,0,UINT,1,I4,1);
3843     VAROR(EMPTY,0,BOOL,0,I2,0);
3844     VAROR(EMPTY,0,BOOL,1,I2,1);
3845     VAROR(EMPTY,0,R4,0,I4,0);
3846     VAROR(EMPTY,0,R4,1,I4,1);
3847     VAROR(EMPTY,0,R8,0,I4,0);
3848     VAROR(EMPTY,0,R8,1,I4,1);
3849     rbstr = SysAllocString(szFalse);
3850     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
3851     rbstr = SysAllocString(szTrue);
3852     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
3853     VARORCY(EMPTY,0,10000,I4,1);
3854
3855     /* NULL OR 0 = NULL. NULL OR n = n */
3856     VAROR(NULL,0,NULL,0,NULL,0);
3857     VAROR(NULL,1,NULL,0,NULL,0);
3858     VAROR(NULL,0,I1,0,NULL,0);
3859     VAROR(NULL,0,I1,1,I4,1);
3860     VAROR(NULL,0,UI1,0,NULL,0);
3861     VAROR(NULL,0,UI1,1,UI1,1);
3862     VAROR(NULL,0,I2,0,NULL,0);
3863     VAROR(NULL,0,I2,1,I2,1);
3864     VAROR(NULL,0,UI2,0,NULL,0);
3865     VAROR(NULL,0,UI2,1,I4,1);
3866     VAROR(NULL,0,I4,0,NULL,0);
3867     VAROR(NULL,0,I4,1,I4,1);
3868     VAROR(NULL,0,UI4,0,NULL,0);
3869     VAROR(NULL,0,UI4,1,I4,1);
3870     if (HAVE_OLEAUT32_I8)
3871     {
3872         VAROR(NULL,0,I8,0,NULL,0);
3873         VAROR(NULL,0,I8,1,I8,1);
3874         VAROR(NULL,0,UI8,0,NULL,0);
3875         VAROR(NULL,0,UI8,1,I4,1);
3876     }
3877     VAROR(NULL,0,INT,0,NULL,0);
3878     VAROR(NULL,0,INT,1,I4,1);
3879     VAROR(NULL,0,UINT,0,NULL,0);
3880     VAROR(NULL,0,UINT,1,I4,1);
3881     VAROR(NULL,0,BOOL,0,NULL,0);
3882     VAROR(NULL,0,BOOL,1,BOOL,1);
3883     VAROR(NULL,0,R4,0,NULL,0);
3884     VAROR(NULL,0,R4,1,I4,1);
3885     VAROR(NULL,0,R8,0,NULL,0);
3886     VAROR(NULL,0,R8,1,I4,1);
3887     rbstr = SysAllocString(szFalse);
3888     VAROR(NULL,0,BSTR,rbstr,NULL,0);
3889     rbstr = SysAllocString(szTrue);
3890     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
3891     VARORCY(NULL,0,10000,I4,1);
3892     VARORCY(NULL,0,0,NULL,0);
3893
3894     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3895     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3896     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3897     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3898     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3899     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
3900     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3901     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3902     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
3903     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3904     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3905     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
3906     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3907     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3908     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
3909     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3910     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3911     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
3912     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3913     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3914     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
3915     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3916     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3917     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
3918     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3919     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3920     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
3921     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3922     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3923     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
3924     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3925     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3926     if (HAVE_OLEAUT32_I8)
3927     {
3928         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
3929         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3930         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3931         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3932          * to I4 is performed.
3933          */
3934         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3935         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3936         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3937     }
3938     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
3939     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3940     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3941     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
3942     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3943     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3944     rbstr = SysAllocString(szFalse);
3945     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3946     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3947     rbstr = SysAllocString(szTrue);
3948     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3949     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3950     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
3951     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3952     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
3953
3954     VAROR(I1,-1,I1,-1,I4,-1);
3955     VAROR(I1,-1,I1,0,I4,-1);
3956     VAROR(I1,0,I1,0,I4,0);
3957     VAROR(I1,-1,UI1,255,I4,-1);
3958     VAROR(I1,-1,UI1,0,I4,-1);
3959     VAROR(I1,0,UI1,0,I4,0);
3960     VAROR(I1,-1,I2,-1,I4,-1);
3961     VAROR(I1,-1,I2,0,I4,-1);
3962     VAROR(I1,0,I2,0,I4,0);
3963     VAROR(I1,-1,UI2,65535,I4,-1);
3964     VAROR(I1,-1,UI2,0,I4,-1);
3965     VAROR(I1,0,UI2,0,I4,0);
3966     VAROR(I1,-1,I4,-1,I4,-1);
3967     VAROR(I1,-1,I4,0,I4,-1);
3968     VAROR(I1,0,I4,0,I4,0);
3969     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
3970     VAROR(I1,-1,UI4,0,I4,-1);
3971     VAROR(I1,0,UI4,0,I4,0);
3972     VAROR(I1,-1,R4,-1,I4,-1);
3973     VAROR(I1,-1,R4,0,I4,-1);
3974     VAROR(I1,0,R4,0,I4,0);
3975     VAROR(I1,-1,R8,-1,I4,-1);
3976     VAROR(I1,-1,R8,0,I4,-1);
3977     VAROR(I1,0,R8,0,I4,0);
3978     VAROR(I1,-1,DATE,-1,I4,-1);
3979     VAROR(I1,-1,DATE,0,I4,-1);
3980     VAROR(I1,0,DATE,0,I4,0);
3981     if (HAVE_OLEAUT32_I8)
3982     {
3983         VAROR(I1,-1,I8,-1,I8,-1);
3984         VAROR(I1,-1,I8,0,I8,-1);
3985         VAROR(I1,0,I8,0,I8,0);
3986         VAROR(I1,-1,UI8,0,I4,-1);
3987         VAROR(I1,0,UI8,0,I4,0);
3988     }
3989     VAROR(I1,-1,INT,-1,I4,-1);
3990     VAROR(I1,-1,INT,0,I4,-1);
3991     VAROR(I1,0,INT,0,I4,0);
3992     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
3993     VAROR(I1,-1,UINT,0,I4,-1);
3994     VAROR(I1,0,UINT,0,I4,0);
3995     rbstr = SysAllocString(szFalse);
3996     VAROR(I1,0,BSTR,rbstr,I4,0);
3997     VAROR(I1,-1,BSTR,rbstr,I4,-1);
3998     rbstr = SysAllocString(szTrue);
3999     VAROR(I1,0,BSTR,rbstr,I4,-1);
4000     VAROR(I1,-1,BSTR,rbstr,I4,-1);
4001     VARORCY(I1,-1,10000,I4,-1);
4002     VARORCY(I1,-1,0,I4,-1);
4003     VARORCY(I1,0,0,I4,0);
4004
4005     VAROR(UI1,255,UI1,255,UI1,255);
4006     VAROR(UI1,255,UI1,0,UI1,255);
4007     VAROR(UI1,0,UI1,0,UI1,0);
4008     VAROR(UI1,255,I2,-1,I2,-1);
4009     VAROR(UI1,255,I2,0,I2,255);
4010     VAROR(UI1,0,I2,0,I2,0);
4011     VAROR(UI1,255,UI2,65535,I4,65535);
4012     VAROR(UI1,255,UI2,0,I4,255);
4013     VAROR(UI1,0,UI2,0,I4,0);
4014     VAROR(UI1,255,I4,-1,I4,-1);
4015     VAROR(UI1,255,I4,0,I4,255);
4016     VAROR(UI1,0,I4,0,I4,0);
4017     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4018     VAROR(UI1,255,UI4,0,I4,255);
4019     VAROR(UI1,0,UI4,0,I4,0);
4020     VAROR(UI1,255,R4,-1,I4,-1);
4021     VAROR(UI1,255,R4,0,I4,255);
4022     VAROR(UI1,0,R4,0,I4,0);
4023     VAROR(UI1,255,R8,-1,I4,-1);
4024     VAROR(UI1,255,R8,0,I4,255);
4025     VAROR(UI1,0,R8,0,I4,0);
4026     VAROR(UI1,255,DATE,-1,I4,-1);
4027     VAROR(UI1,255,DATE,0,I4,255);
4028     VAROR(UI1,0,DATE,0,I4,0);
4029     if (HAVE_OLEAUT32_I8)
4030     {
4031         VAROR(UI1,255,I8,-1,I8,-1);
4032         VAROR(UI1,255,I8,0,I8,255);
4033         VAROR(UI1,0,I8,0,I8,0);
4034         VAROR(UI1,255,UI8,0,I4,255);
4035         VAROR(UI1,0,UI8,0,I4,0);
4036     }
4037     VAROR(UI1,255,INT,-1,I4,-1);
4038     VAROR(UI1,255,INT,0,I4,255);
4039     VAROR(UI1,0,INT,0,I4,0);
4040     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4041     VAROR(UI1,255,UINT,0,I4,255);
4042     VAROR(UI1,0,UINT,0,I4,0);
4043     rbstr = SysAllocString(szFalse);
4044     VAROR(UI1,0,BSTR,rbstr,I2,0);
4045     VAROR(UI1,255,BSTR,rbstr,I2,255);
4046     rbstr = SysAllocString(szTrue);
4047     VAROR(UI1,0,BSTR,rbstr,I2,-1);
4048     VAROR(UI1,255,BSTR,rbstr,I2,-1);
4049     VARORCY(UI1,255,10000,I4,255);
4050     VARORCY(UI1,255,0,I4,255);
4051     VARORCY(UI1,0,0,I4,0);
4052
4053     VAROR(I2,-1,I2,-1,I2,-1);
4054     VAROR(I2,-1,I2,0,I2,-1);
4055     VAROR(I2,0,I2,0,I2,0);
4056     VAROR(I2,-1,UI2,65535,I4,-1);
4057     VAROR(I2,-1,UI2,0,I4,-1);
4058     VAROR(I2,0,UI2,0,I4,0);
4059     VAROR(I2,-1,I4,-1,I4,-1);
4060     VAROR(I2,-1,I4,0,I4,-1);
4061     VAROR(I2,0,I4,0,I4,0);
4062     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4063     VAROR(I2,-1,UI4,0,I4,-1);
4064     VAROR(I2,0,UI4,0,I4,0);
4065     VAROR(I2,-1,R4,-1,I4,-1);
4066     VAROR(I2,-1,R4,0,I4,-1);
4067     VAROR(I2,0,R4,0,I4,0);
4068     VAROR(I2,-1,R8,-1,I4,-1);
4069     VAROR(I2,-1,R8,0,I4,-1);
4070     VAROR(I2,0,R8,0,I4,0);
4071     VAROR(I2,-1,DATE,-1,I4,-1);
4072     VAROR(I2,-1,DATE,0,I4,-1);
4073     VAROR(I2,0,DATE,0,I4,0);
4074     if (HAVE_OLEAUT32_I8)
4075     {
4076         VAROR(I2,-1,I8,-1,I8,-1);
4077         VAROR(I2,-1,I8,0,I8,-1);
4078         VAROR(I2,0,I8,0,I8,0);
4079         VAROR(I2,-1,UI8,0,I4,-1);
4080         VAROR(I2,0,UI8,0,I4,0);
4081     }
4082     VAROR(I2,-1,INT,-1,I4,-1);
4083     VAROR(I2,-1,INT,0,I4,-1);
4084     VAROR(I2,0,INT,0,I4,0);
4085     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4086     VAROR(I2,-1,UINT,0,I4,-1);
4087     VAROR(I2,0,UINT,0,I4,0);
4088     rbstr = SysAllocString(szFalse);
4089     VAROR(I2,0,BSTR,rbstr,I2,0);
4090     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4091     rbstr = SysAllocString(szTrue);
4092     VAROR(I2,0,BSTR,rbstr,I2,-1);
4093     VAROR(I2,-1,BSTR,rbstr,I2,-1);
4094     VARORCY(I2,-1,10000,I4,-1);
4095     VARORCY(I2,-1,0,I4,-1);
4096     VARORCY(I2,0,0,I4,0);
4097
4098     VAROR(UI2,65535,UI2,65535,I4,65535);
4099     VAROR(UI2,65535,UI2,0,I4,65535);
4100     VAROR(UI2,0,UI2,0,I4,0);
4101     VAROR(UI2,65535,I4,-1,I4,-1);
4102     VAROR(UI2,65535,I4,0,I4,65535);
4103     VAROR(UI2,0,I4,0,I4,0);
4104     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4105     VAROR(UI2,65535,UI4,0,I4,65535);
4106     VAROR(UI2,0,UI4,0,I4,0);
4107     VAROR(UI2,65535,R4,-1,I4,-1);
4108     VAROR(UI2,65535,R4,0,I4,65535);
4109     VAROR(UI2,0,R4,0,I4,0);
4110     VAROR(UI2,65535,R8,-1,I4,-1);
4111     VAROR(UI2,65535,R8,0,I4,65535);
4112     VAROR(UI2,0,R8,0,I4,0);
4113     VAROR(UI2,65535,DATE,-1,I4,-1);
4114     VAROR(UI2,65535,DATE,0,I4,65535);
4115     VAROR(UI2,0,DATE,0,I4,0);
4116     if (HAVE_OLEAUT32_I8)
4117     {
4118         VAROR(UI2,65535,I8,-1,I8,-1);
4119         VAROR(UI2,65535,I8,0,I8,65535);
4120         VAROR(UI2,0,I8,0,I8,0);
4121         VAROR(UI2,65535,UI8,0,I4,65535);
4122         VAROR(UI2,0,UI8,0,I4,0);
4123     }
4124     VAROR(UI2,65535,INT,-1,I4,-1);
4125     VAROR(UI2,65535,INT,0,I4,65535);
4126     VAROR(UI2,0,INT,0,I4,0);
4127     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4128     VAROR(UI2,65535,UINT,0,I4,65535);
4129     VAROR(UI2,0,UINT,0,I4,0);
4130     rbstr = SysAllocString(szFalse);
4131     VAROR(UI2,0,BSTR,rbstr,I4,0);
4132     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4133     rbstr = SysAllocString(szTrue);
4134     VAROR(UI2,0,BSTR,rbstr,I4,-1);
4135     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4136     VARORCY(UI2,65535,10000,I4,65535);
4137     VARORCY(UI2,65535,0,I4,65535);
4138     VARORCY(UI2,0,0,I4,0);
4139
4140     VAROR(I4,-1,I4,-1,I4,-1);
4141     VAROR(I4,-1,I4,0,I4,-1);
4142     VAROR(I4,0,I4,0,I4,0);
4143     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4144     VAROR(I4,-1,UI4,0,I4,-1);
4145     VAROR(I4,0,UI4,0,I4,0);
4146     VAROR(I4,-1,R4,-1,I4,-1);
4147     VAROR(I4,-1,R4,0,I4,-1);
4148     VAROR(I4,0,R4,0,I4,0);
4149     VAROR(I4,-1,R8,-1,I4,-1);
4150     VAROR(I4,-1,R8,0,I4,-1);
4151     VAROR(I4,0,R8,0,I4,0);
4152     VAROR(I4,-1,DATE,-1,I4,-1);
4153     VAROR(I4,-1,DATE,0,I4,-1);
4154     VAROR(I4,0,DATE,0,I4,0);
4155     if (HAVE_OLEAUT32_I8)
4156     {
4157         VAROR(I4,-1,I8,-1,I8,-1);
4158         VAROR(I4,-1,I8,0,I8,-1);
4159         VAROR(I4,0,I8,0,I8,0);
4160         VAROR(I4,-1,UI8,0,I4,-1);
4161         VAROR(I4,0,UI8,0,I4,0);
4162     }
4163     VAROR(I4,-1,INT,-1,I4,-1);
4164     VAROR(I4,-1,INT,0,I4,-1);
4165     VAROR(I4,0,INT,0,I4,0);
4166     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4167     VAROR(I4,-1,UINT,0,I4,-1);
4168     VAROR(I4,0,UINT,0,I4,0);
4169     rbstr = SysAllocString(szFalse);
4170     VAROR(I4,0,BSTR,rbstr,I4,0);
4171     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4172     rbstr = SysAllocString(szTrue);
4173     VAROR(I4,0,BSTR,rbstr,I4,-1);
4174     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4175     VARORCY(I4,-1,10000,I4,-1);
4176     VARORCY(I4,-1,0,I4,-1);
4177     VARORCY(I4,0,0,I4,0);
4178
4179     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4180     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4181     VAROR(UI4,0,UI4,0,I4,0);
4182     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4183     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4184     VAROR(UI4,0,R4,0,I4,0);
4185     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4186     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4187     VAROR(UI4,0,R8,0,I4,0);
4188     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4189     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4190     VAROR(UI4,0,DATE,0,I4,0);
4191     if (HAVE_OLEAUT32_I8)
4192     {
4193         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4194         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4195         VAROR(UI4,0,I8,0,I8,0);
4196         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4197         VAROR(UI4,0,UI8,0,I4,0);
4198     }
4199     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4200     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4201     VAROR(UI4,0,INT,0,I4,0);
4202     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4203     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4204     VAROR(UI4,0,UINT,0,I4,0);
4205     rbstr = SysAllocString(szFalse);
4206     VAROR(UI4,0,BSTR,rbstr,I4,0);
4207     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4208     rbstr = SysAllocString(szTrue);
4209     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4210     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4211     VARORCY(UI4,0xffffffff,10000,I4,-1);
4212     VARORCY(UI4,0xffffffff,0,I4,-1);
4213     VARORCY(UI4,0,0,I4,0);
4214
4215     VAROR(R4,-1,R4,-1,I4,-1);
4216     VAROR(R4,-1,R4,0,I4,-1);
4217     VAROR(R4,0,R4,0,I4,0);
4218     VAROR(R4,-1,R8,-1,I4,-1);
4219     VAROR(R4,-1,R8,0,I4,-1);
4220     VAROR(R4,0,R8,0,I4,0);
4221     VAROR(R4,-1,DATE,-1,I4,-1);
4222     VAROR(R4,-1,DATE,0,I4,-1);
4223     VAROR(R4,0,DATE,0,I4,0);
4224     if (HAVE_OLEAUT32_I8)
4225     {
4226         VAROR(R4,-1,I8,-1,I8,-1);
4227         VAROR(R4,-1,I8,0,I8,-1);
4228         VAROR(R4,0,I8,0,I8,0);
4229         VAROR(R4,-1,UI8,0,I4,-1);
4230         VAROR(R4,0,UI8,0,I4,0);
4231     }
4232     VAROR(R4,-1,INT,-1,I4,-1);
4233     VAROR(R4,-1,INT,0,I4,-1);
4234     VAROR(R4,0,INT,0,I4,0);
4235     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4236     VAROR(R4,-1,UINT,0,I4,-1);
4237     VAROR(R4,0,UINT,0,I4,0);
4238     rbstr = SysAllocString(szFalse);
4239     VAROR(R4,0,BSTR,rbstr,I4,0);
4240     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4241     rbstr = SysAllocString(szTrue);
4242     VAROR(R4,0,BSTR,rbstr,I4,-1);
4243     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4244     VARORCY(R4,-1,10000,I4,-1);
4245     VARORCY(R4,-1,0,I4,-1);
4246     VARORCY(R4,0,0,I4,0);
4247
4248     VAROR(R8,-1,R8,-1,I4,-1);
4249     VAROR(R8,-1,R8,0,I4,-1);
4250     VAROR(R8,0,R8,0,I4,0);
4251     VAROR(R8,-1,DATE,-1,I4,-1);
4252     VAROR(R8,-1,DATE,0,I4,-1);
4253     VAROR(R8,0,DATE,0,I4,0);
4254     if (HAVE_OLEAUT32_I8)
4255     {
4256         VAROR(R8,-1,I8,-1,I8,-1);
4257         VAROR(R8,-1,I8,0,I8,-1);
4258         VAROR(R8,0,I8,0,I8,0);
4259         VAROR(R8,-1,UI8,0,I4,-1);
4260         VAROR(R8,0,UI8,0,I4,0);
4261     }
4262     VAROR(R8,-1,INT,-1,I4,-1);
4263     VAROR(R8,-1,INT,0,I4,-1);
4264     VAROR(R8,0,INT,0,I4,0);
4265     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4266     VAROR(R8,-1,UINT,0,I4,-1);
4267     VAROR(R8,0,UINT,0,I4,0);
4268     rbstr = SysAllocString(szFalse);
4269     VAROR(R8,0,BSTR,rbstr,I4,0);
4270     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4271     rbstr = SysAllocString(szTrue);
4272     VAROR(R8,0,BSTR,rbstr,I4,-1);
4273     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4274     VARORCY(R8,-1,10000,I4,-1);
4275     VARORCY(R8,-1,0,I4,-1);
4276     VARORCY(R8,0,0,I4,0);
4277
4278     VAROR(DATE,-1,DATE,-1,I4,-1);
4279     VAROR(DATE,-1,DATE,0,I4,-1);
4280     VAROR(DATE,0,DATE,0,I4,0);
4281     if (HAVE_OLEAUT32_I8)
4282     {
4283         VAROR(DATE,-1,I8,-1,I8,-1);
4284         VAROR(DATE,-1,I8,0,I8,-1);
4285         VAROR(DATE,0,I8,0,I8,0);
4286         VAROR(DATE,-1,UI8,0,I4,-1);
4287         VAROR(DATE,0,UI8,0,I4,0);
4288     }
4289     VAROR(DATE,-1,INT,-1,I4,-1);
4290     VAROR(DATE,-1,INT,0,I4,-1);
4291     VAROR(DATE,0,INT,0,I4,0);
4292     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4293     VAROR(DATE,-1,UINT,0,I4,-1);
4294     VAROR(DATE,0,UINT,0,I4,0);
4295     rbstr = SysAllocString(szFalse);
4296     VAROR(DATE,0,BSTR,rbstr,I4,0);
4297     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4298     rbstr = SysAllocString(szTrue);
4299     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4300     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4301     VARORCY(DATE,-1,10000,I4,-1);
4302     VARORCY(DATE,-1,0,I4,-1);
4303     VARORCY(DATE,0,0,I4,0);
4304
4305     if (HAVE_OLEAUT32_I8)
4306     {
4307         VAROR(I8,-1,I8,-1,I8,-1);
4308         VAROR(I8,-1,I8,0,I8,-1);
4309         VAROR(I8,0,I8,0,I8,0);
4310         VAROR(I8,-1,UI8,0,I8,-1);
4311         VAROR(I8,0,UI8,0,I8,0);
4312         /* These overflow under native and Wine
4313         VAROR(I8,-1,INT,-1,I4,-1);
4314         VAROR(I8,-1,INT,0,I4,-1);
4315         VAROR(I8,0,INT,0,I4,0); */
4316         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4317         VAROR(I8,-1,UINT,0,I8,-1);
4318         VAROR(I8,0,UINT,0,I8,0);
4319         rbstr = SysAllocString(szFalse);
4320         VAROR(I8,0,BSTR,rbstr,I8,0);
4321         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4322         rbstr = SysAllocString(szTrue);
4323         VAROR(I8,0,BSTR,rbstr,I8,-1);
4324         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4325         VARORCY(I8,-1,10000,I8,-1);
4326         VARORCY(I8,-1,0,I8,-1);
4327         VARORCY(I8,0,0,I8,0);
4328
4329         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4330         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4331         VAROR(UI8,0,UI8,0,I4,0);
4332         VAROR(UI8,0xffff,INT,-1,I4,-1);
4333         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4334         VAROR(UI8,0,INT,0,I4,0);
4335         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4336         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4337         VAROR(UI8,0,UINT,0,I4,0);
4338         rbstr = SysAllocString(szFalse);
4339         VAROR(UI8,0,BSTR,rbstr,I4,0);
4340         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4341         rbstr = SysAllocString(szTrue);
4342         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4343         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4344         VARORCY(UI8,0xffff,10000,I4,0xffff);
4345         VARORCY(UI8,0xffff,0,I4,0xffff);
4346         VARORCY(UI8,0,0,I4,0);
4347     }
4348
4349     VAROR(INT,-1,INT,-1,I4,-1);
4350     VAROR(INT,-1,INT,0,I4,-1);
4351     VAROR(INT,0,INT,0,I4,0);
4352     VAROR(INT,-1,UINT,0xffff,I4,-1);
4353     VAROR(INT,-1,UINT,0,I4,-1);
4354     VAROR(INT,0,UINT,0,I4,0);
4355     rbstr = SysAllocString(szFalse);
4356     VAROR(INT,0,BSTR,rbstr,I4,0);
4357     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4358     rbstr = SysAllocString(szTrue);
4359     VAROR(INT,0,BSTR,rbstr,I4,-1);
4360     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4361     VARORCY(INT,-1,10000,I4,-1);
4362     VARORCY(INT,-1,0,I4,-1);
4363     VARORCY(INT,0,0,I4,0);
4364
4365     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4366     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4367     VAROR(UINT,0,UINT,0,I4,0);
4368     rbstr = SysAllocString(szFalse);
4369     VAROR(UINT,0,BSTR,rbstr,I4,0);
4370     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4371     rbstr = SysAllocString(szTrue);
4372     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4373     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4374     VARORCY(UINT,0xffff,10000,I4,0xffff);
4375     VARORCY(UINT,0xffff,0,I4,0xffff);
4376     VARORCY(UINT,0,0,I4,0);
4377
4378     lbstr = SysAllocString(szFalse);
4379     rbstr = SysAllocString(szFalse);
4380     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4381     rbstr = SysAllocString(szTrue);
4382     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4383     lbstr = SysAllocString(szTrue);
4384     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4385     VARORCY(BSTR,lbstr,10000,I4,-1);
4386     lbstr = SysAllocString(szFalse);
4387     VARORCY(BSTR,lbstr,10000,I4,1);
4388 }
4389
4390 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4391
4392 static const char *szVarEqvFail = "VarEqv(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4393 #define VAREQV(vt1,val1,vt2,val2,rvt,rval) \
4394         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4395         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4396         memset(&result,0,sizeof(result)); hres = pVarEqv(&left,&right,&result); \
4397         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4398         szVarEqvFail, VT_##vt1, VT_##vt2, \
4399         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result))
4400
4401 static void test_VarEqv(void)
4402 {
4403     VARIANT left, right, result;
4404     VARTYPE i;
4405     HRESULT hres;
4406
4407     CHECKPTR(VarEqv);
4408
4409     /* Test all possible flag/vt combinations & the resulting vt type */
4410     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4411     {
4412         VARTYPE leftvt, rightvt, resvt;
4413
4414         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4415         {
4416             SKIPTESTS(leftvt);
4417
4418             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4419             {
4420                 BOOL bFail = FALSE;
4421
4422                 SKIPTESTS(rightvt);
4423
4424                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4425                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4426                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4427                     continue;
4428
4429                 memset(&left, 0, sizeof(left));
4430                 memset(&right, 0, sizeof(right));
4431                 V_VT(&left) = leftvt | ExtraFlags[i];
4432                 V_VT(&right) = rightvt | ExtraFlags[i];
4433                 V_VT(&result) = VT_EMPTY;
4434                 resvt = VT_I4;
4435
4436                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4437                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4438                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4439                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4440                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4441                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4442                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4443                 {
4444                     bFail = TRUE;
4445                 }
4446                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4447                 {
4448                     if (leftvt == rightvt ||
4449                         leftvt == VT_I2 || rightvt == VT_I2 ||
4450                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4451                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4452                         resvt = VT_I2;
4453                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4454                         resvt = VT_NULL;
4455                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4456                         resvt = VT_I8;
4457                 }
4458                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4459                 {
4460                     resvt = VT_NULL;
4461                 }
4462                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4463                 {
4464                     if (leftvt == rightvt)
4465                         resvt = VT_UI1;
4466                     else if (leftvt == rightvt ||
4467                         leftvt == VT_I2 || rightvt == VT_I2 ||
4468                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4469                     {
4470                         resvt = VT_I2;
4471                     }
4472                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4473                         resvt = VT_I8;
4474                 }
4475                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4476                 {
4477                     if (leftvt == rightvt ||
4478                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4479                         resvt = VT_I2;
4480                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4481                         resvt = VT_I8;
4482                 }
4483                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4484                 {
4485                     resvt = VT_BOOL;
4486                 }
4487                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4488                 {
4489                     if (leftvt == VT_INT || rightvt == VT_INT)
4490                         bFail = TRUE;
4491                     else
4492                         resvt = VT_I8;
4493                 }
4494                 hres = pVarEqv(&left, &right, &result);
4495                 if (bFail)
4496                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4497                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4498                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4499                        V_VT(&result));
4500                 else
4501                     ok(hres == S_OK && V_VT(&result) == resvt,
4502                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4503                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4504                        V_VT(&result));
4505             }
4506         }
4507     }
4508
4509     /* Test returned values */
4510     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4511     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4512     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4513     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4514     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4515     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4516     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4517     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4518     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4519     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4520     VAREQV(BOOL,6,I2,7,I2,-2);
4521     VAREQV(UI1,1,UI1,1,UI1,255);
4522     VAREQV(UI1,1,UI1,0,UI1,254);
4523     VAREQV(UI1,0,UI1,1,UI1,254);
4524     if (HAVE_OLEAUT32_I8)
4525     {
4526         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4527         VAREQV(UI4,5,I8,19,I8,-23);
4528         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4529     }
4530 }
4531
4532 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4533
4534 static const char *szVarMulI4 = "VarMul(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4535 static const char *szVarMulR8 = "VarMul(%d,%d): expected 0x0,%d,%f, got 0x%lX,%d,%f\n";
4536
4537 #define VARMUL(vt1,val1,vt2,val2,rvt,rval) \
4538         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4539         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4540         memset(&result,0,sizeof(result)); hres = pVarMul(&left,&right,&result); \
4541         if (VT_##rvt == VT_R4 || VT_##rvt == VT_R8) { \
4542         ok(hres == S_OK && V_VT(&result) == VT_##rvt && \
4543         EQ_FLOAT(V_##rvt(&result), rval), \
4544         szVarMulR8, VT_##vt1, VT_##vt2, \
4545         VT_##rvt, (double)(rval), hres, V_VT(&result), (double)V_##rvt(&result)); \
4546         } else { \
4547         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4548         szVarMulI4, VT_##vt1, VT_##vt2, \
4549         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); }
4550
4551 static void test_VarMul(void)
4552 {
4553     static const WCHAR sz12[] = {'1','2','\0'};
4554     VARIANT left, right, result, cy, dec;
4555     VARTYPE i;
4556     BSTR lbstr, rbstr;
4557     HRESULT hres;
4558     double r;
4559
4560     CHECKPTR(VarMul);
4561
4562     lbstr = SysAllocString(sz12);
4563     rbstr = SysAllocString(sz12);
4564
4565     /* Test all possible flag/vt combinations & the resulting vt type */
4566     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4567     {
4568         VARTYPE leftvt, rightvt, resvt;
4569
4570         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4571         {
4572
4573             SKIPTESTS(leftvt);
4574
4575             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4576             {
4577                 BOOL bFail = FALSE;
4578
4579                 SKIPTESTS(rightvt);
4580
4581                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4582                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4583                     continue;
4584
4585                 memset(&left, 0, sizeof(left));
4586                 memset(&right, 0, sizeof(right));
4587                 V_VT(&left) = leftvt | ExtraFlags[i];
4588                 if (leftvt == VT_BSTR)
4589                     V_BSTR(&left) = lbstr;
4590                 V_VT(&right) = rightvt | ExtraFlags[i];
4591                 if (rightvt == VT_BSTR)
4592                     V_BSTR(&right) = rbstr;
4593                 V_VT(&result) = VT_EMPTY;
4594                 resvt = VT_UNKNOWN;
4595
4596                 /* Don't ask me why but native VarMul cannot handle:
4597                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
4598                    Tested with DCOM98, Win2k, WinXP */
4599                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4600                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4601                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4602                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4603                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4604                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4605                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
4606                     leftvt == VT_I1 || rightvt == VT_I1 ||
4607                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
4608                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
4609                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
4610                     leftvt == VT_INT || rightvt == VT_INT ||
4611                     leftvt == VT_UINT || rightvt == VT_UINT) {
4612                     bFail = TRUE;
4613                 }
4614
4615                 if (leftvt == VT_NULL || rightvt == VT_NULL)
4616                     resvt = VT_NULL;
4617                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
4618                     resvt = VT_DECIMAL;
4619                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
4620                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
4621                          leftvt == VT_DATE || rightvt == VT_DATE)
4622                     resvt = VT_R8;
4623                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
4624                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
4625                         leftvt == VT_I8 || rightvt == VT_I8 ||
4626                         leftvt == VT_CY || rightvt == VT_CY)
4627                         resvt = VT_R8;
4628                     else
4629                         resvt = VT_R4;
4630                 } else if (leftvt == VT_CY || rightvt == VT_CY)
4631                     resvt = VT_CY;
4632                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4633                     resvt = VT_I8;
4634                 else if (leftvt == VT_I4 || rightvt == VT_I4)
4635                     resvt = VT_I4;
4636                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
4637                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
4638                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
4639                     resvt = VT_I2;
4640                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4641                     resvt = VT_UI1;
4642
4643                 hres = pVarMul(&left, &right, &result);
4644                 if (bFail) {
4645                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4646                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4647                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4648                        V_VT(&result));
4649                 } else {
4650                     ok(hres == S_OK && V_VT(&result) == resvt,
4651                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4652                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4653                        V_VT(&result));
4654                 }
4655             }
4656         }
4657     }
4658
4659     /* Test returned values */
4660     VARMUL(I4,4,I4,2,I4,8);
4661     VARMUL(I2,4,I2,2,I2,8);
4662     VARMUL(I2,-13,I4,5,I4,-65);
4663     VARMUL(I4,-13,I4,5,I4,-65);
4664     VARMUL(I2,7,R4,0.5,R4,3.5);
4665     VARMUL(R4,0.5,I4,5,R8,2.5);
4666     VARMUL(R8,7.1,BOOL,0,R8,0);
4667     VARMUL(BSTR,lbstr,I2,4,R8,48);
4668     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
4669     VARMUL(BSTR,lbstr,R4,0.1,R8,1.2);
4670     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
4671     VARMUL(R4,0.2,BSTR,rbstr,R8,2.4);
4672     VARMUL(DATE,2.25,I4,7,R8,15.75);
4673
4674     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
4675     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
4676     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
4677     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
4678 if (HAVE_OLEAUT32_I8) {
4679     VARMUL(I4, I4_MAX, I4, I4_MAX, I8, (LONGLONG)I4_MAX * I4_MAX);
4680     VARMUL(I4, I4_MAX, I4, I4_MIN, I8, (LONGLONG)I4_MAX * I4_MIN);
4681     VARMUL(I4, I4_MIN, I4, I4_MIN, I8, (LONGLONG)I4_MIN * I4_MIN);
4682 } else {
4683     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
4684     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
4685     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
4686 }
4687     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
4688     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
4689     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
4690     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
4691     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
4692
4693     /* Manuly test some VT_CY and VT_DECIMAL variants */
4694     V_VT(&cy) = VT_CY;
4695     hres = VarCyFromI4(4711, &V_CY(&cy));
4696     ok(hres == S_OK, "VarCyFromI4 failed!\n");
4697     V_VT(&dec) = VT_DECIMAL;
4698     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
4699     ok(hres == S_OK, "VarDecFromR4 failed!\n");
4700     memset(&left, 0, sizeof(left));
4701     memset(&right, 0, sizeof(right));
4702     V_VT(&left) = VT_I4;
4703     V_I4(&left) = -11;
4704     V_VT(&right) = VT_UI1;
4705     V_UI1(&right) = 9;
4706
4707     hres = VarMul(&cy, &right, &result);
4708     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n'", vtstr(V_VT(&result)));
4709     hres = VarR8FromCy(V_CY(&result), &r);
4710     ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
4711
4712     hres = VarMul(&left, &dec, &result);
4713     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n'", vtstr(V_VT(&result)));
4714     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
4715     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
4716 }
4717
4718 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
4719
4720 static const char *szVarAddI4 = "VarAdd(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4721 static const char *szVarAddR8 = "VarAdd(%d,%d): expected 0x0,%d,%f, got 0x%lX,%d,%f\n";
4722
4723 #define VARADD(vt1,val1,vt2,val2,rvt,rval) \
4724         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4725         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4726         memset(&result,0,sizeof(result)); hres = pVarAdd(&left,&right,&result); \
4727         if (VT_##rvt == VT_R4 || VT_##rvt == VT_R8 || VT_##rvt == VT_DATE) { \
4728         ok(hres == S_OK && V_VT(&result) == VT_##rvt && \
4729         EQ_FLOAT(V_##rvt(&result), rval), \
4730         szVarAddR8, VT_##vt1, VT_##vt2, \
4731         VT_##rvt, (double)(rval), hres, V_VT(&result), (double)V_##rvt(&result)); \
4732         } else { \
4733         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4734         szVarAddI4, VT_##vt1, VT_##vt2, \
4735         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); }
4736
4737 static void test_VarAdd(void)
4738 {
4739     static const WCHAR sz12[] = {'1','2','\0'};
4740     VARIANT left, right, result, cy, dec;
4741     VARTYPE i;
4742     BSTR lbstr, rbstr;
4743     HRESULT hres;
4744     double r;
4745
4746     CHECKPTR(VarAdd);
4747
4748     lbstr = SysAllocString(sz12);
4749     rbstr = SysAllocString(sz12);
4750
4751     /* Test all possible flag/vt combinations & the resulting vt type */
4752     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4753     {
4754         VARTYPE leftvt, rightvt, resvt;
4755
4756         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4757         {
4758
4759             SKIPTESTS(leftvt);
4760
4761             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4762             {
4763                 BOOL bFail = FALSE;
4764
4765                 SKIPTESTS(rightvt);
4766
4767                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4768                     continue;
4769
4770                 memset(&left, 0, sizeof(left));
4771                 memset(&right, 0, sizeof(right));
4772                 V_VT(&left) = leftvt | ExtraFlags[i];
4773                 if (leftvt == VT_BSTR)
4774                     V_BSTR(&left) = lbstr;
4775                 V_VT(&right) = rightvt | ExtraFlags[i];
4776                 if (rightvt == VT_BSTR)
4777                     V_BSTR(&right) = rbstr;
4778                 V_VT(&result) = VT_EMPTY;
4779                 resvt = VT_ERROR;
4780
4781                 /* Don't ask me why but native VarAdd cannot handle:
4782                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
4783                    Tested with DCOM98, Win2k, WinXP */
4784                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4785                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4786                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4787                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4788                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4789                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4790                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
4791                     leftvt == VT_I1 || rightvt == VT_I1 ||
4792                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
4793                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
4794                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
4795                     leftvt == VT_INT || rightvt == VT_INT ||
4796                     leftvt == VT_UINT || rightvt == VT_UINT) {
4797                     bFail = TRUE;
4798                 }
4799
4800                 if (leftvt == VT_NULL || rightvt == VT_NULL)
4801                     resvt = VT_NULL;
4802                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
4803                     bFail = TRUE;
4804                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
4805                     resvt = VT_DECIMAL;
4806                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
4807                     resvt = VT_DATE;
4808                 else if (leftvt == VT_CY || rightvt == VT_CY)
4809                     resvt = VT_CY;
4810                 else if (leftvt == VT_R8 || rightvt == VT_R8)
4811                     resvt = VT_R8;
4812                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
4813                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
4814                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4815                         resvt = VT_BSTR;
4816                     else
4817                         resvt = VT_R8;
4818                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
4819                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
4820                         leftvt == VT_I8 || rightvt == VT_I8)
4821                         resvt = VT_R8;
4822                     else
4823                         resvt = VT_R4;
4824                 }
4825                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4826                     resvt = VT_I8;
4827                 else if (leftvt == VT_I4 || rightvt == VT_I4)
4828                     resvt = VT_I4;
4829                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
4830                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
4831                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
4832                     resvt = VT_I2;
4833                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4834                     resvt = VT_UI1;
4835
4836                 hres = pVarAdd(&left, &right, &result);
4837                 if (bFail) {
4838                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4839                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4840                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4841                        V_VT(&result));
4842                 } else {
4843                     ok(hres == S_OK && V_VT(&result) == resvt,
4844                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4845                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4846                        V_VT(&result));
4847                 }
4848             }
4849         }
4850     }
4851
4852     /* Test returned values */
4853     VARADD(I4,4,I4,2,I4,6);
4854     VARADD(I2,4,I2,2,I2,6);
4855     VARADD(I2,-13,I4,5,I4,-8);
4856     VARADD(I4,-13,I4,5,I4,-8);
4857     VARADD(I2,7,R4,0.5,R4,7.5);
4858     VARADD(R4,0.5,I4,5,R8,5.5);
4859     VARADD(R8,7.1,BOOL,0,R8,7.1);
4860     VARADD(BSTR,lbstr,I2,4,R8,16);
4861     VARADD(BSTR,lbstr,BOOL,1,R8,13);
4862     VARADD(BSTR,lbstr,R4,0.1,R8,12.1);
4863     VARADD(R4,0.2,BSTR,rbstr,R8,12.2);
4864     VARADD(DATE,2.25,I4,7,DATE,9.25);
4865     VARADD(DATE,1.25,R4,-1.7,DATE,-0.45);
4866
4867     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
4868     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
4869     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
4870     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
4871     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
4872     if (HAVE_OLEAUT32_I8) {
4873         VARADD(I4, I4_MAX, I4, I4_MAX, I8, (LONGLONG)I4_MAX + I4_MAX);
4874         VARADD(I4, I4_MIN, I4, I4_MIN, I8, (LONGLONG)I4_MIN + I4_MIN);
4875     } else {
4876         VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
4877         VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
4878     }
4879     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
4880     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
4881     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
4882     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
4883     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
4884
4885     /* Manualy test BSTR + BSTR */
4886     V_VT(&left) = VT_BSTR;
4887     V_BSTR(&left) = lbstr;
4888     V_VT(&right) = VT_BSTR;
4889     V_BSTR(&right) = rbstr;
4890     hres = VarAdd(&left, &right, &result);
4891     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n'", vtstr(V_VT(&result)));
4892     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
4893     ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
4894
4895     /* Manuly test some VT_CY and VT_DECIMAL variants */
4896     V_VT(&cy) = VT_CY;
4897     hres = VarCyFromI4(4711, &V_CY(&cy));
4898     ok(hres == S_OK, "VarCyFromI4 failed!\n");
4899     V_VT(&dec) = VT_DECIMAL;
4900     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
4901     ok(hres == S_OK, "VarDecFromR4 failed!\n");
4902     memset(&left, 0, sizeof(left));
4903     memset(&right, 0, sizeof(right));
4904     V_VT(&left) = VT_I4;
4905     V_I4(&left) = -11;
4906     V_VT(&right) = VT_UI1;
4907     V_UI1(&right) = 9;
4908
4909     hres = VarAdd(&cy, &right, &result);
4910     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n'", vtstr(V_VT(&result)));
4911     hres = VarR8FromCy(V_CY(&result), &r);
4912     ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
4913
4914     hres = VarAdd(&left, &dec, &result);
4915     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n'", vtstr(V_VT(&result)));
4916     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
4917     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
4918 }
4919
4920 START_TEST(vartest)
4921 {
4922   hOleaut32 = LoadLibraryA("oleaut32.dll");
4923
4924   test_VariantInit();
4925   test_VariantClear();
4926   test_VariantCopy();
4927   test_VariantCopyInd();
4928   test_VarParseNumFromStr();
4929   test_VarNumFromParseNum();
4930   test_VarUdateFromDate();
4931   test_VarDateFromUdate();
4932   test_SystemTimeToVariantTime();
4933   test_VariantTimeToSystemTime();
4934   test_DosDateTimeToVariantTime();
4935   test_VariantTimeToDosDateTime();
4936   test_VarFormatNumber();
4937   test_VarFormat();
4938   test_VarAbs();
4939   test_VarNot();
4940   test_VarSub();
4941   test_VarMod();
4942   test_VarFix();
4943   test_VarInt();
4944   test_VarNeg();
4945   test_VarRound();
4946   test_VarXor();
4947   test_VarOr();
4948   test_VarEqv();
4949   test_VarMul();
4950   test_VarAdd();
4951 }