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