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

   1 /*
   2  * VARIANT test program
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <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
1053 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1054
1055 /* Macros for converting and testing the result of VarNumFromParseNum */
1056 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1057 #undef CONVERT
1058 #define CONVERT(a,b,c,d,e,f,bits) \
1059     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1060     np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1061 static const char *szFailOverflow = "Expected overflow, hres = %08lx\n";
1062 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1063 static const char *szFailOk = "Call failed, hres = %08lx\n";
1064 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1065   if (hres == (HRESULT)S_OK)
1066 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1067 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1068   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1069 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1070   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1071 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1072   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1073 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1074   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1075 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1076   ok(V_I4(&vOut) == val, "Expected i4 = %ld, got %ld\n", (LONG)val, V_I4(&vOut)); }
1077 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1078   ok(V_UI4(&vOut) == val, "Expected ui4 = %ld, got %ld\n", (ULONG)val, V_UI4(&vOut)); }
1079 #define EXPECT_I8(val) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1080   ok(V_I8(&vOut) == val, "Expected i8 = %lld, got %lld\n", (LONG64)val, V_I8(&vOut)); }
1081 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1082   ok(V_UI8(&vOut) == val, "Expected ui8 = %lld, got %lld\n", (ULONG64)val, V_UI8(&vOut)); }
1083 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1084   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1085 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1086   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1087 #define CY_MULTIPLIER 10000
1088 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1089   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = %lld, got %lld\n", (LONG64)val, V_CY(&vOut).int64); }
1090
1091 static void test_VarNumFromParseNum(void)
1092 {
1093   HRESULT hres;
1094   NUMPARSE np;
1095   BYTE rgb[128];
1096   VARIANT vOut;
1097
1098   CHECKPTR(VarNumFromParseNum);
1099
1100   /* Convert the number 1 to different types */
1101   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1102   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1103   /* Prefers a signed type to unsigned of the same size */
1104   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1105   /* But takes the smaller size if possible */
1106   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1107
1108   /* Try different integer sizes */
1109 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1110
1111   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1112   /* 127 */
1113   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1114   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1115   /* 128 */
1116   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1117   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1118   /* 255 */
1119   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1120   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1121   /* 256 */
1122   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1123   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1124   /* 32767 */
1125   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1126   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1127   /* 32768 */
1128   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1129   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1130
1131   /* Assume the above pattern holds for remaining positive integers; test negative */
1132
1133   /* -128 */
1134   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1135   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1136   /* -129 */
1137   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1138   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1139   /* -32768 */
1140   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1141   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1142   /* -32768 */
1143   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1144   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1145
1146   /* Assume the above pattern holds for remaining negative integers */
1147
1148   /* Negative numbers overflow if we have only unsigned outputs */
1149   /* -1 */
1150   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1151   /* -0.6 */
1152   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1153
1154   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1155   /* -0.5 */
1156   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1157
1158   /* Float is acceptable for an integer input value */
1159   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1160   /* As is double */
1161   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1162   /* As is currency */
1163   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1164
1165   /* Float is preferred over double */
1166   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1167
1168   /* Double is preferred over currency */
1169   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1170
1171   /* Currency is preferred over decimal */
1172   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1173 }
1174
1175 static const char* szUdateFromDateFail = "%.16g expected %lx, %d,%d,%d,%d,%d,%d,%d  %d %d"
1176                                          ", got %lx, %d,%d,%d,%d,%d,%d,%d  %d %d\n";
1177 #define DT2UD(dt,flags,r,d,m,y,h,mn,s,ms,dw,dy) \
1178   memset(&ud, 0, sizeof(ud)); \
1179   res = pVarUdateFromDate(dt, flags, &ud); \
1180   ok(r == res && (FAILED(r) || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d && \
1181      ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s && \
1182      ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)), \
1183      szUdateFromDateFail, dt, r, d, m, y, h, mn, s, ms, dw, dy, res, ud.st.wDay, ud.st.wMonth, \
1184      ud.st.wYear, ud.st.wHour, ud.st.wMinute, ud.st.wSecond, \
1185      ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear)
1186
1187 static void test_VarUdateFromDate(void)
1188 {
1189   UDATE ud;
1190   HRESULT res;
1191
1192   CHECKPTR(VarUdateFromDate);
1193   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
1194   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
1195   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
1196   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
1197   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
1198   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1199   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
1200   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
1201
1202   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1203   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1204   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1205
1206   /* Times */
1207   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
1208   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
1209   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
1210   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1211   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1212 }
1213
1214 #define UD2T(d,m,y,h,mn,s,ms,dw,dy,flags,r,dt) \
1215   ud.st.wYear = (y); ud.st.wMonth = (m); ud.st.wDay = (d); ud.st.wHour = (h); \
1216   ud.st.wMinute = (mn); ud.st.wSecond = (s); ud.st.wMilliseconds = (ms); \
1217   ud.st.wDayOfWeek = (dw); ud.wDayOfYear = (dy); \
1218   res = pVarDateFromUdate(&ud, (flags), &out); \
1219   ok((r) == res && (FAILED(r) || fabs(out-(dt)) < 1.0e-11), \
1220      "expected %lx, %.16g, got %lx, %.16g\n", r, dt, res, out)
1221
1222 static void test_VarDateFromUdate(void)
1223 {
1224   UDATE ud;
1225   double out;
1226   HRESULT res;
1227
1228   CHECKPTR(VarDateFromUdate);
1229   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
1230   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
1231   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
1232   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
1233   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
1234   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
1235   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
1236   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
1237
1238   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963); /* 6:18:02 PM */
1239
1240   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);      /* Rolls back to 31 Dec 1899 */
1241   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);     /* Rolls fwd to 1/1/1981 */
1242 }
1243
1244 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) \
1245   st.wYear = y; st.wMonth = m; st.wDay = d; st.wHour = h; st.wMinute = mn; \
1246   st.wSecond = s; st.wMilliseconds = ms; st.wDayOfWeek = 0; \
1247   res = pSystemTimeToVariantTime(&st, &out); \
1248   ok(r == res && (!r || fabs(out-dt) < 1.0e-11), \
1249      "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out)
1250
1251 static void test_SystemTimeToVariantTime(void)
1252 {
1253   SYSTEMTIME st;
1254   double out;
1255   int res;
1256
1257   CHECKPTR(SystemTimeToVariantTime);
1258   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1259   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1260   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0);   /* Rolls back to 31 Dec 1899 */
1261   ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1262   ST2DT(31,12,90,0,0,0,0,TRUE,33238.0);   /* year < 100 is 1900+year! */
1263 }
1264
1265 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) \
1266   memset(&st, 0, sizeof(st)); \
1267   res = pVariantTimeToSystemTime(dt, &st); \
1268   ok(r == res && (!r || (st.wYear == y && st.wMonth == m && st.wDay == d && \
1269      st.wHour == h && st.wMinute == mn && st.wSecond == s && \
1270      st.wMilliseconds == ms)), \
1271      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n", \
1272      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth, st.wYear, \
1273      st.wHour, st.wMinute, st.wSecond, st.wMilliseconds)
1274
1275 static void test_VariantTimeToSystemTime(void)
1276 {
1277   SYSTEMTIME st;
1278   int res;
1279
1280   CHECKPTR(VariantTimeToSystemTime);
1281   DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1282   DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1283 }
1284
1285 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1286 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1287
1288 static const char *szDosDateToVarTimeFail = "expected %d, %.16g, got %d, %.16g\n";
1289 #define DOS2DT(d,m,y,h,mn,s,r,dt) out = 0.0; \
1290   dosDate = MKDOSDATE(d,m,y); \
1291   dosTime = MKDOSTIME(h,mn,s); \
1292   res = pDosDateTimeToVariantTime(dosDate, dosTime, &out); \
1293   ok(r == res && (!r || fabs(out-dt) < 1.0e-11), \
1294      szDosDateToVarTimeFail, r, dt, res, out)
1295
1296 static void test_DosDateTimeToVariantTime(void)
1297 {
1298   USHORT dosDate, dosTime;
1299   double out;
1300   INT res;
1301
1302   CHECKPTR(DosDateTimeToVariantTime);
1303
1304   /* Date */
1305   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1306   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1307   /* Dates are limited to the dos date max of 31/12/2099 */
1308   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1309   /* Days and months of 0 cause date to roll back 1 day or month */
1310   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1311   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
1312   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1313   /* Days > days in the month cause date to roll forward 1 month */
1314   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1315   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1316   /* Takes leap years into account when rolling forward */
1317   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1318   /* Months > 12 cause an error */
1319   DOS2DT(2,13,1980,0,0,0,0,0.0);
1320
1321   /* Time */
1322   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1323   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1324   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1325   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid seconds */
1326   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1327   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
1328 }
1329
1330 #define DT2DOS(dt,r,d,m,y,h,mn,s) dosTime = dosDate = 0; \
1331   expDosDate = MKDOSDATE(d,m,y); \
1332   expDosTime = MKDOSTIME(h,mn,s); \
1333   res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime); \
1334   ok(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)), \
1335      "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n", \
1336      dt, r, expDosDate, expDosDate & 0x1f, (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9), \
1337      expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f, (expDosTime & 0x1f), \
1338      res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf, 1980 + (dosDate >> 9), \
1339      dosTime, dosTime >> 11, (dosTime >> 5) & 0x3f, (dosTime & 0x1f))
1340
1341 static void test_VariantTimeToDosDateTime(void)
1342 {
1343   USHORT dosDate, dosTime, expDosDate, expDosTime;
1344   INT res;
1345
1346   CHECKPTR(VariantTimeToDosDateTime);
1347
1348   /* Date */
1349   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
1350   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1351   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
1352   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
1353
1354   /* Time */
1355   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1356   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1357   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1358   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1359 }
1360
1361 #define FMT_NUMBER(vt,val) \
1362   VariantInit(&v); V_VT(&v) = vt; val(&v) = 1; \
1363   hres = pVarFormatNumber(&v,2,0,0,0,0,&str); \
1364   ok(hres == S_OK, "VarFormatNumber (vt %d): returned %8lx\n", vt, hres); \
1365   if (hres == S_OK) \
1366     ok(str && strcmpW(str,szResult1) == 0, \
1367        "VarFormatNumber (vt %d): string different\n", vt)
1368
1369 static void test_VarFormatNumber(void)
1370 {
1371   static const WCHAR szSrc1[] = { '1','\0' };
1372   static const WCHAR szResult1[] = { '1','.','0','0','\0' };
1373   static const WCHAR szSrc2[] = { '-','1','\0' };
1374   static const WCHAR szResult2[] = { '(','1','.','0','0',')','\0' };
1375   char buff[8];
1376   HRESULT hres;
1377   VARIANT v;
1378   BSTR str = NULL;
1379
1380   CHECKPTR(VarFormatNumber);
1381
1382   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1383   if (buff[0] != '.' || buff[1])
1384   {
1385     trace("Skipping VarFormatNumber tests as decimal separator is '%s'\n", buff);
1386     return;
1387   }
1388
1389   FMT_NUMBER(VT_I1, V_I1);
1390   FMT_NUMBER(VT_UI1, V_UI1);
1391   FMT_NUMBER(VT_I2, V_I2);
1392   FMT_NUMBER(VT_UI2, V_UI2);
1393   FMT_NUMBER(VT_I4, V_I4);
1394   FMT_NUMBER(VT_UI4, V_UI4);
1395   if (HAVE_OLEAUT32_I8)
1396   {
1397     FMT_NUMBER(VT_I8, V_I8);
1398     FMT_NUMBER(VT_UI8, V_UI8);
1399   }
1400   FMT_NUMBER(VT_R4, V_R4);
1401   FMT_NUMBER(VT_R8, V_R8);
1402   FMT_NUMBER(VT_BOOL, V_BOOL);
1403
1404   V_VT(&v) = VT_BSTR;
1405   V_BSTR(&v) = SysAllocString(szSrc1);
1406
1407   hres = pVarFormatNumber(&v,2,0,0,0,0,&str);
1408   ok(hres == S_OK, "VarFormatNumber (bstr): returned %8lx\n", hres);
1409   if (hres == S_OK)
1410     ok(str && strcmpW(str, szResult1) == 0, "VarFormatNumber (bstr): string different\n");
1411   SysFreeString(V_BSTR(&v));
1412   SysFreeString(str);
1413
1414   V_BSTR(&v) = SysAllocString(szSrc2);
1415   hres = pVarFormatNumber(&v,2,0,-1,0,0,&str);
1416   ok(hres == S_OK, "VarFormatNumber (bstr): returned %8lx\n", hres);
1417   if (hres == S_OK)
1418     ok(str && strcmpW(str, szResult2) == 0, "VarFormatNumber (-bstr): string different\n");
1419   SysFreeString(V_BSTR(&v));
1420   SysFreeString(str);
1421 }
1422
1423 #define SIGNED_VTBITS (VTBIT_I1|VTBIT_I2|VTBIT_I4|VTBIT_I8|VTBIT_R4|VTBIT_R8)
1424
1425 static const char *szVarFmtFail = "VT %d|0x%04x Format %s: expected 0x%08lx, '%s', got 0x%08lx, '%s'\n";
1426 #define VARFMT(vt,v,val,fmt,ret,str) do { \
1427   if (out) SysFreeString(out); out = NULL; \
1428   V_VT(&in) = (vt); v(&in) = val; \
1429   if (fmt) MultiByteToWideChar(CP_ACP, 0, fmt, -1, buffW, sizeof(buffW)/sizeof(WCHAR)); \
1430   hres = pVarFormat(&in,fmt ? buffW : NULL,fd,fw,flags,&out); \
1431   if (SUCCEEDED(hres)) WideCharToMultiByte(CP_ACP, 0, out, -1, buff, sizeof(buff),0,0); \
1432   else buff[0] = '\0'; \
1433   ok(hres == ret && (FAILED(ret) || !strcmp(buff, str)), \
1434      szVarFmtFail, \
1435      (vt)&VT_TYPEMASK,(vt)&~VT_TYPEMASK,fmt?fmt:"<null>",ret,str,hres,buff); \
1436   } while(0)
1437
1438 typedef struct tagFMTRES
1439 {
1440   LPCSTR fmt;
1441   LPCSTR one_res;
1442   LPCSTR zero_res;
1443 } FMTRES;
1444
1445 static const FMTRES VarFormat_results[] =
1446 {
1447   { NULL, "1", "0" },
1448   { "", "1", "0" },
1449   { "General Number", "1", "0" },
1450   { "Percent", "100.00%", "0.00%" },
1451   { "Standard", "1.00", "0.00" },
1452   { "Scientific","1.00E+00", "0.00E+00" },
1453   { "True/False", "True", "False" },
1454   { "On/Off", "On", "Off" },
1455   { "Yes/No", "Yes", "No" },
1456   { "#", "1", "" },
1457   { "##", "1", "" },
1458   { "#.#", "1.", "." },
1459   { "0", "1", "0" },
1460   { "00", "01", "00" },
1461   { "0.0", "1.0", "0.0" },
1462   { "00\\c\\o\\p\\y", "01copy","00copy" },
1463   { "\"pos\";\"neg\"", "pos", "pos" },
1464   { "\"pos\";\"neg\";\"zero\"","pos", "zero" }
1465 };
1466
1467 typedef struct tagFMTDATERES
1468 {
1469   DATE   val;
1470   LPCSTR fmt;
1471   LPCSTR res;
1472 } FMTDATERES;
1473
1474 static const FMTDATERES VarFormat_date_results[] =
1475 {
1476   { 0.0, "w", "7" },
1477   { 0.0, "w", "6" },
1478   { 0.0, "w", "5" },
1479   { 0.0, "w", "4" },
1480   { 0.0, "w", "3" },
1481   { 0.0, "w", "2" },
1482   { 0.0, "w", "1" }, /* First 7 entries must remain in this order! */
1483   { 2.525, "am/pm", "pm" },
1484   { 2.525, "AM/PM", "PM" },
1485   { 2.525, "A/P", "P" },
1486   { 2.525, "a/p", "p" },
1487   { 2.525, "q", "1" },
1488   { 2.525, "d", "1" },
1489   { 2.525, "dd", "01" },
1490   { 2.525, "ddd", "Mon" },
1491   { 2.525, "dddd", "Monday" },
1492   { 2.525, "mmm", "Jan" },
1493   { 2.525, "mmmm", "January" },
1494   { 2.525, "y", "1" },
1495   { 2.525, "yy", "00" },
1496   { 2.525, "yyy", "001" },
1497   { 2.525, "yyyy", "1900" },
1498   { 2.525, "dd mm yyyy hh:mm:ss", "01 01 1900 12:36:00" },
1499   { 2.525, "dd mm yyyy mm", "01 01 1900 01" },
1500   { 2.525, "dd mm yyyy :mm", "01 01 1900 :01" },
1501   { 2.525, "dd mm yyyy hh:mm", "01 01 1900 12:36" },
1502   { 2.525, "mm mm", "01 01" },
1503   { 2.525, "mm :mm:ss", "01 :01:00" },
1504   { 2.525, "mm :ss:mm", "01 :00:01" },
1505   { 2.525, "hh:mm :ss:mm", "12:36 :00:01" },
1506   { 2.525, "hh:dd :mm:mm", "12:01 :01:01" },
1507   { 2.525, "dd:hh :mm:mm", "01:12 :36:01" },
1508   { 2.525, "hh :mm:mm", "12 :36:01" },
1509   { 2.525, "dd :mm:mm", "01 :01:01" },
1510   { 2.525, "dd :mm:nn", "01 :01:36" },
1511   { 2.725, "hh:nn:ss A/P", "05:24:00 P" }
1512 };
1513
1514 #define VNUMFMT(vt,v) \
1515   for (i = 0; i < sizeof(VarFormat_results)/sizeof(FMTRES); i++) \
1516   { \
1517     VARFMT(vt,v,1,VarFormat_results[i].fmt,S_OK,VarFormat_results[i].one_res); \
1518     VARFMT(vt,v,0,VarFormat_results[i].fmt,S_OK,VarFormat_results[i].zero_res); \
1519   } \
1520   if ((1 << vt) & SIGNED_VTBITS) \
1521   { \
1522     VARFMT(vt,v,-1,"\"pos\";\"neg\"",S_OK,"neg"); \
1523     VARFMT(vt,v,-1,"\"pos\";\"neg\";\"zero\"",S_OK,"neg"); \
1524   }
1525
1526 static void test_VarFormat(void)
1527 {
1528   static const WCHAR szTesting[] = { 't','e','s','t','i','n','g','\0' };
1529   size_t i;
1530   WCHAR buffW[256];
1531   char buff[256];
1532   VARIANT in;
1533   VARIANT_BOOL bTrue = VARIANT_TRUE, bFalse = VARIANT_FALSE;
1534   int fd = 0, fw = 0;
1535   ULONG flags = 0;
1536   BSTR bstrin, out = NULL;
1537   HRESULT hres;
1538
1539   CHECKPTR(VarFormat);
1540
1541   if (PRIMARYLANGID(LANGIDFROMLCID(GetUserDefaultLCID())) != LANG_ENGLISH)
1542   {
1543     trace("Skipping VarFormat tests for non english language\n");
1544     return;
1545   }
1546   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1547   if (buff[0] != '.' || buff[1])
1548   {
1549     trace("Skipping VarFormat tests as decimal separator is '%s'\n", buff);
1550     return;
1551   }
1552   GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IDIGITS, buff, sizeof(buff)/sizeof(char));
1553   if (buff[0] != '2' || buff[1])
1554   {
1555     trace("Skipping VarFormat tests as decimal places is '%s'\n", buff);
1556     return;
1557   }
1558
1559   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"True/False",S_OK,"True");
1560   VARFMT(VT_BOOL,V_BOOL,VARIANT_FALSE,"True/False",S_OK,"False");
1561
1562   VNUMFMT(VT_I1,V_I1);
1563   VNUMFMT(VT_I2,V_I2);
1564   VNUMFMT(VT_I4,V_I4);
1565   if (HAVE_OLEAUT32_I8)
1566   {
1567     VNUMFMT(VT_I8,V_I8);
1568   }
1569   VNUMFMT(VT_INT,V_INT);
1570   VNUMFMT(VT_UI1,V_UI1);
1571   VNUMFMT(VT_UI2,V_UI2);
1572   VNUMFMT(VT_UI4,V_UI4);
1573   if (HAVE_OLEAUT32_I8)
1574   {
1575     VNUMFMT(VT_UI8,V_UI8);
1576   }
1577   VNUMFMT(VT_UINT,V_UINT);
1578   VNUMFMT(VT_R4,V_R4);
1579   VNUMFMT(VT_R8,V_R8);
1580
1581   /* Reference types are dereferenced */
1582   VARFMT(VT_BOOL|VT_BYREF,V_BOOLREF,&bTrue,"True/False",S_OK,"True");
1583   VARFMT(VT_BOOL|VT_BYREF,V_BOOLREF,&bFalse,"True/False",S_OK,"False");
1584
1585   /* Dates */
1586   for (i = 0; i < sizeof(VarFormat_date_results)/sizeof(FMTDATERES); i++)
1587   {
1588     if (i < 7)
1589       fd = i + 1; /* Test first day */
1590     else
1591       fd = 0;
1592     VARFMT(VT_DATE,V_DATE,VarFormat_date_results[i].val,
1593            VarFormat_date_results[i].fmt,S_OK,
1594            VarFormat_date_results[i].res);
1595   }
1596
1597   /* Strings */
1598   bstrin = SysAllocString(szTesting);
1599   VARFMT(VT_BSTR,V_BSTR,bstrin,"",S_OK,"testing");
1600   VARFMT(VT_BSTR,V_BSTR,bstrin,"@",S_OK,"testing");
1601   VARFMT(VT_BSTR,V_BSTR,bstrin,"&",S_OK,"testing");
1602   VARFMT(VT_BSTR,V_BSTR,bstrin,"\\x@\\x@",S_OK,"xtxesting");
1603   VARFMT(VT_BSTR,V_BSTR,bstrin,"\\x&\\x&",S_OK,"xtxesting");
1604   VARFMT(VT_BSTR,V_BSTR,bstrin,"@\\x",S_OK,"txesting");
1605   VARFMT(VT_BSTR,V_BSTR,bstrin,"@@@@@@@@",S_OK," testing");
1606   VARFMT(VT_BSTR,V_BSTR,bstrin,"@\\x@@@@@@@",S_OK," xtesting");
1607   VARFMT(VT_BSTR,V_BSTR,bstrin,"&&&&&&&&",S_OK,"testing");
1608   VARFMT(VT_BSTR,V_BSTR,bstrin,"!&&&&&&&",S_OK,"testing");
1609   VARFMT(VT_BSTR,V_BSTR,bstrin,"&&&&&&&!",S_OK,"testing");
1610   VARFMT(VT_BSTR,V_BSTR,bstrin,">&&",S_OK,"TESTING");
1611   VARFMT(VT_BSTR,V_BSTR,bstrin,"<&&",S_OK,"testing");
1612   VARFMT(VT_BSTR,V_BSTR,bstrin,"<&>&",S_OK,"testing");
1613   SysFreeString(bstrin);
1614   /* Numeric values are converted to strings then output */
1615   VARFMT(VT_I1,V_I1,1,"<&>&",S_OK,"1");
1616
1617   /* 'out' is not cleared */
1618   out = (BSTR)0x1;
1619   pVarFormat(&in,NULL,fd,fw,flags,&out); /* Would crash if out is cleared */
1620   out = NULL;
1621
1622   /* Invalid args */
1623   hres = pVarFormat(&in,NULL,fd,fw,flags,NULL);
1624   ok(hres == E_INVALIDARG, "Null out: expected E_INVALIDARG, got 0x%08lx\n", hres);
1625   hres = pVarFormat(NULL,NULL,fd,fw,flags,&out);
1626   ok(hres == E_INVALIDARG, "Null in: expected E_INVALIDARG, got 0x%08lx\n", hres);
1627   fd = -1;
1628   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1629   fd = 8;
1630   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1631   fd = 0; fw = -1;
1632   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1633   fw = 4;
1634   VARFMT(VT_BOOL,V_BOOL,VARIANT_TRUE,"",E_INVALIDARG,"");
1635 }
1636
1637 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1638
1639 static const char *szVarAbsFail = "VarAbs: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
1640 #define VARABS(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
1641         memset(&vDst,0,sizeof(vDst)); hres = pVarAbs(&v,&vDst); \
1642         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
1643            szVarAbsFail, VT_##rvt, (int)(rval), \
1644            hres, V_VT(&vDst), (int)V_##rvt(&vDst))
1645
1646 static void test_VarAbs(void)
1647 {
1648     static const WCHAR szNum[] = {'-','1','.','1','\0' };
1649     char buff[8];
1650     HRESULT hres;
1651     VARIANT v, vDst;
1652     size_t i;
1653
1654     CHECKPTR(VarAbs);
1655
1656     /* Test all possible V_VT values.
1657      */
1658     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1659     {
1660         VARTYPE vt;
1661
1662         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1663         {
1664             HRESULT hExpected = DISP_E_BADVARTYPE;
1665
1666             SKIPTESTS(vt);
1667
1668             memset(&v, 0, sizeof(v));
1669             V_VT(&v) = vt | ExtraFlags[i];
1670             V_VT(&vDst) = VT_EMPTY;
1671
1672             hres = pVarAbs(&v,&vDst);
1673             if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1674                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1675                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1676             {
1677                 hExpected = DISP_E_TYPEMISMATCH;
1678             }
1679             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1680             {
1681                 hExpected = DISP_E_BADVARTYPE;
1682             }
1683             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1684                 hExpected = S_OK;
1685
1686             /* Native always fails on some vartypes that should be valid. don't
1687              * check that Wine does the same; these are bugs in native.
1688              */
1689             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1690                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1691                 continue;
1692             ok(hres == hExpected, "VarAbs: expected 0x%lX, got 0x%lX for vt %d | 0x%X\n",
1693                hExpected, hres, vt, ExtraFlags[i]);
1694         }
1695     }
1696
1697     /* BOOL->I2, BSTR->R8, all others remain the same */
1698     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1699     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1700     VARABS(EMPTY,0,I2,0);
1701     VARABS(EMPTY,1,I2,0);
1702     VARABS(NULL,0,NULL,0);
1703     VARABS(NULL,1,NULL,0);
1704     VARABS(I2,1,I2,1);
1705     VARABS(I2,-1,I2,1);
1706     VARABS(I4,1,I4,1);
1707     VARABS(I4,-1,I4,1);
1708     VARABS(UI1,1,UI1,1);
1709     VARABS(R4,1,R4,1);
1710     VARABS(R4,-1,R4,1);
1711     VARABS(R8,1,R8,1);
1712     VARABS(R8,-1,R8,1);
1713     VARABS(DATE,1,DATE,1);
1714     VARABS(DATE,-1,DATE,1);
1715     V_VT(&v) = VT_CY;
1716     V_CY(&v).int64 = -10000;
1717     memset(&vDst,0,sizeof(vDst));
1718     hres = pVarAbs(&v,&vDst);
1719     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1720        "VarAbs(CY): expected 0x0 got 0x%lX\n", hres);
1721     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1722     if (buff[0] != '.' || buff[1])
1723     {
1724         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1725         return;
1726     }
1727     V_VT(&v) = VT_BSTR;
1728     V_BSTR(&v) = (BSTR)szNum;
1729     memset(&vDst,0,sizeof(vDst));
1730     hres = pVarAbs(&v,&vDst);
1731     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1732        "VarAbs: expected 0x0,%d,%g, got 0x%lX,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1733 }
1734
1735 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
1736
1737 static const char *szVarNotFail = "VarNot: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
1738 #define VARNOT(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
1739         memset(&vDst,0,sizeof(vDst)); hres = pVarNot(&v,&vDst); \
1740         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
1741         szVarNotFail, VT_##rvt, (int)(rval), \
1742         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
1743
1744 static void test_VarNot(void)
1745 {
1746     static const WCHAR szNum0[] = {'0','\0' };
1747     static const WCHAR szNum1[] = {'1','\0' };
1748     HRESULT hres;
1749     VARIANT v, vDst;
1750     DECIMAL *pdec = &V_DECIMAL(&v);
1751     CY *pcy = &V_CY(&v);
1752     size_t i;
1753
1754     CHECKPTR(VarNot);
1755
1756     /* Test all possible V_VT values */
1757     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1758     {
1759         VARTYPE vt;
1760
1761         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1762         {
1763             HRESULT hExpected = DISP_E_BADVARTYPE;
1764
1765             SKIPTESTS(vt);
1766
1767             memset(&v, 0, sizeof(v));
1768             V_VT(&v) = vt | ExtraFlags[i];
1769             V_VT(&vDst) = VT_EMPTY;
1770
1771             switch (V_VT(&v))
1772             {
1773             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
1774             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
1775             case VT_R4:  case VT_R8:
1776             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
1777             case VT_DATE: case VT_CY:
1778                 hExpected = S_OK;
1779                 break;
1780             case VT_I8: case VT_UI8:
1781                 if (HAVE_OLEAUT32_I8)
1782                     hExpected = S_OK;
1783                 break;
1784             case VT_RECORD:
1785                 if (HAVE_OLEAUT32_RECORD)
1786                     hExpected = DISP_E_TYPEMISMATCH;
1787                 break;
1788             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
1789                 hExpected = DISP_E_TYPEMISMATCH;
1790                 break;
1791             default:
1792                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
1793                    hExpected = DISP_E_TYPEMISMATCH;
1794                 break;
1795             }
1796
1797             hres = pVarNot(&v,&vDst);
1798             ok(hres == hExpected, "VarNot: expected 0x%lX, got 0x%lX vt %d|0x%X\n",
1799                hExpected, hres, vt, ExtraFlags[i]);
1800         }
1801     }
1802     /* Test the values returned by all cases that can succeed */
1803     VARNOT(EMPTY,0,I2,-1);
1804     VARNOT(EMPTY,1,I2,-1);
1805     VARNOT(NULL,0,NULL,0);
1806     VARNOT(NULL,1,NULL,0);
1807     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
1808     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
1809     VARNOT(I1,-1,I4,0);
1810     VARNOT(I1,0,I4,-1);
1811     VARNOT(I2,-1,I2,0);
1812     VARNOT(I2,0,I2,-1);
1813     VARNOT(I2,1,I2,-2);
1814     VARNOT(I4,1,I4,-2);
1815     VARNOT(I4,0,I4,-1);
1816     VARNOT(UI1,1,UI1,254);
1817     VARNOT(UI1,0,UI1,255);
1818     VARNOT(UI2,0,I4,-1);
1819     VARNOT(UI2,1,I4,-2);
1820     VARNOT(UI4,0,I4,-1);
1821     VARNOT(UI4,1,I4,-2);
1822     VARNOT(INT,0,I4,-1);
1823     VARNOT(INT,1,I4,-2);
1824     VARNOT(UINT,0,I4,-1);
1825     VARNOT(UINT,1,I4,-2);
1826     if (HAVE_OLEAUT32_I8)
1827     {
1828         VARNOT(I8,1,I8,-2);
1829         VARNOT(I8,0,I8,-1);
1830         VARNOT(UI8,0,I4,-1);
1831         VARNOT(UI8,1,I4,-2);
1832     }
1833     VARNOT(R4,1,I4,-2);
1834     VARNOT(R4,0,I4,-1);
1835     VARNOT(R8,1,I4,-2);
1836     VARNOT(R8,0,I4,-1);
1837     VARNOT(DATE,1,I4,-2);
1838     VARNOT(DATE,0,I4,-1);
1839     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
1840     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
1841     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
1842     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
1843
1844     V_VT(&v) = VT_DECIMAL;
1845     S(U(*pdec)).sign = DECIMAL_NEG;
1846     S(U(*pdec)).scale = 0;
1847     pdec->Hi32 = 0;
1848     S1(U1(*pdec)).Mid32 = 0;
1849     S1(U1(*pdec)).Lo32 = 1;
1850     VARNOT(DECIMAL,*pdec,I4,0);
1851
1852     pcy->int64 = 10000;
1853     VARNOT(CY,*pcy,I4,-2);
1854
1855     pcy->int64 = 0;
1856     VARNOT(CY,*pcy,I4,-1);
1857
1858     pcy->int64 = -1;
1859     VARNOT(CY,*pcy,I4,-1);
1860 }
1861 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
1862
1863 static void test_VarSub(void)
1864 {
1865     VARIANT va, vb, vc;
1866     HRESULT hr;
1867
1868     CHECKPTR(VarSub);
1869
1870     V_VT(&va) = VT_DATE;
1871     V_DATE(&va) = 200000.0;
1872     V_VT(&vb) = VT_DATE;
1873     V_DATE(&vb) = 100000.0;
1874
1875     hr = pVarSub(&va, &vb, &vc);
1876     ok(hr == S_OK,"VarSub of VT_DATE - VT_DATE failed with %lx\n", hr);
1877     ok(V_VT(&vc) == VT_R8,"VarSub of VT_DATE - VT_DATE returned vt 0x%x\n", V_VT(&vc));
1878     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));
1879     /* fprintf(stderr,"VarSub of 10000-20000 returned: %g\n", V_R8(&vc)); */
1880 }
1881
1882 static const char *szVarModFail = "VarMod: expected 0x%lx,%d(%s),%d, got 0x%lX,%d(%s),%d\n";
1883 #define VARMOD(vt1,vt2,val1,val2,rvt,rval,hexpected) V_VT(&v1) = VT_##vt1; V_##vt1(&v1) = val1; \
1884         V_VT(&v2) = VT_##vt2; V_##vt2(&v2) = val2;                  \
1885         memset(&vDst,0,sizeof(vDst)); hres = pVarMod(&v1,&v2,&vDst);                    \
1886         ok(hres == hexpected && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
1887         szVarModFail, hexpected, VT_##rvt, vtstr(VT_##rvt), (int)(rval), \
1888         hres, V_VT(&vDst), vtstr(V_VT(&vDst)), (int)V_##rvt(&vDst))
1889
1890 static const char *szVarMod2Fail = "VarMod: expected 0x%lx,%d(%s),%d, got 0x%lX,%d(%s),%d\n";
1891 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected) V_VT(&v1) = VT_##vt1; V_I4(&v1) = val1; \
1892         V_VT(&v2) = VT_##vt2; V_I4(&v2) = val2;                                \
1893         memset(&vDst,0,sizeof(vDst)); hres = pVarMod(&v1,&v2,&vDst);                     \
1894         ok(hres == hexpected && V_VT(&vDst) == VT_##rvt && V_I4(&vDst) == (rval), \
1895         szVarMod2Fail, hexpected, VT_##rvt, vtstr(VT_##rvt), (int)(rval), \
1896         hres, V_VT(&vDst), vtstr(V_VT(&vDst)), (int)V_I4(&vDst))
1897
1898 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
1899
1900 static void test_VarMod(void)
1901 {
1902   VARIANT v1, v2, vDst;
1903   HRESULT hres;
1904   HRESULT hexpected = 0;
1905   static const WCHAR szNum0[] = {'1','2','5','\0'};
1906   static const WCHAR szNum1[] = {'1','0','\0'};
1907   int l, r;
1908   BOOL lFound, rFound;
1909   BOOL lValid, rValid;
1910   BSTR strNum0, strNum1;
1911
1912   CHECKPTR(VarMod);
1913
1914   VARMOD(I1,BOOL,100,10,I4,0,S_OK);
1915   VARMOD(I1,I1,100,10,I4,0,S_OK);
1916   VARMOD(I1,UI1,100,10,I4,0,S_OK);
1917   VARMOD(I1,I2,100,10,I4,0,S_OK);
1918   VARMOD(I1,UI2,100,10,I4,0,S_OK);
1919   VARMOD(I1,I4,100,10,I4,0,S_OK);
1920   VARMOD(I1,UI4,100,10,I4,0,S_OK);
1921   VARMOD(I1,R4,100,10,I4,0,S_OK);
1922   VARMOD(I1,R8,100,10,I4,0,S_OK);
1923   VARMOD(I1,I8,100,10,I8,0,S_OK);
1924
1925   VARMOD(UI1,BOOL,100,10,I2,0,S_OK);
1926   VARMOD(UI1,I1,100,10,I4,0,S_OK);
1927   VARMOD(UI1,UI1,100,10,UI1,0,S_OK);
1928   VARMOD(UI1,I2,100,10,I2,0,S_OK);
1929   VARMOD(UI1,UI2,100,10,I4,0,S_OK);
1930   VARMOD(UI1,I4,100,10,I4,0,S_OK);
1931   VARMOD(UI1,UI4,100,10,I4,0,S_OK);
1932   VARMOD(UI1,R4,100,10,I4,0,S_OK);
1933   VARMOD(UI1,R8,100,10,I4,0,S_OK);
1934   VARMOD(UI1,I8,100,10,I8,0,S_OK);
1935
1936   VARMOD(I2,BOOL,100,10,I2,0,S_OK);
1937   VARMOD(I2,I1,100,10,I4,0,S_OK);
1938   VARMOD(I2,UI1,100,10,I2,0,S_OK);
1939   VARMOD(I2,I2,100,10,I2,0,S_OK);
1940   VARMOD(I2,UI2,100,10,I4,0,S_OK);
1941   VARMOD(I2,I4,100,10,I4,0,S_OK);
1942   VARMOD(I2,UI4,100,10,I4,0,S_OK);
1943   VARMOD(I2,R4,100,10,I4,0,S_OK);
1944   VARMOD(I2,R8,100,10,I4,0,S_OK);
1945   VARMOD(I2,I8,100,10,I8,0,S_OK);
1946
1947   VARMOD(I4,BOOL,100,10,I4,0,S_OK);
1948   VARMOD(I4,I1,100,10,I4,0,S_OK);
1949   VARMOD(I4,UI1,100,10,I4,0,S_OK);
1950   VARMOD(I4,I2,100,10,I4,0,S_OK);
1951   VARMOD(I4,UI2,100,10,I4,0,S_OK);
1952   VARMOD(I4,I4,100,10,I4,0,S_OK);
1953   VARMOD(I4,UI4,100,10,I4,0,S_OK);
1954   VARMOD(I4,R4,100,10,I4,0,S_OK);
1955   VARMOD(I4,R8,100,10,I4,0,S_OK);
1956   VARMOD(I4,I8,100,10,I8,0,S_OK);
1957
1958   VARMOD(UI4,BOOL,100,10,I4,0,S_OK);
1959   VARMOD(UI4,I1,100,10,I4,0,S_OK);
1960   VARMOD(UI4,UI1,100,10,I4,0,S_OK);
1961   VARMOD(UI4,I2,100,10,I4,0,S_OK);
1962   VARMOD(UI4,UI2,100,10,I4,0,S_OK);
1963   VARMOD(UI4,I4,100,10,I4,0,S_OK);
1964   VARMOD(UI4,UI4,100,10,I4,0,S_OK);
1965   VARMOD(UI4,R4,100,10,I4,0,S_OK);
1966   VARMOD(UI4,R8,100,10,I4,0,S_OK);
1967   VARMOD(UI4,I8,100,10,I8,0,S_OK);
1968
1969   VARMOD(R4,BOOL,100,10,I4,0,S_OK);
1970   VARMOD(R4,I1,100,10,I4,0,S_OK);
1971   VARMOD(R4,UI1,100,10,I4,0,S_OK);
1972   VARMOD(R4,I2,100,10,I4,0,S_OK);
1973   VARMOD(R4,UI2,100,10,I4,0,S_OK);
1974   VARMOD(R4,I4,100,10,I4,0,S_OK);
1975   VARMOD(R4,UI4,100,10,I4,0,S_OK);
1976   VARMOD(R4,R4,100,10,I4,0,S_OK);
1977   VARMOD(R4,R8,100,10,I4,0,S_OK);
1978   VARMOD(R4,I8,100,10,I8,0,S_OK);
1979
1980   VARMOD(R8,BOOL,100,10,I4,0,S_OK);
1981   VARMOD(R8,I1,100,10,I4,0,S_OK);
1982   VARMOD(R8,UI1,100,10,I4,0,S_OK);
1983   VARMOD(R8,I2,100,10,I4,0,S_OK);
1984   VARMOD(R8,UI2,100,10,I4,0,S_OK);
1985   VARMOD(R8,I4,100,10,I4,0,S_OK);
1986   VARMOD(R8,UI4,100,10,I4,0,S_OK);
1987   VARMOD(R8,R4,100,10,I4,0,S_OK);
1988   VARMOD(R8,R8,100,10,I4,0,S_OK);
1989   VARMOD(R8,I8,100,10,I8,0,S_OK);
1990
1991   VARMOD(I8,BOOL,100,10,I8,0,S_OK);
1992   VARMOD(I8,I1,100,10,I8,0,S_OK);
1993   VARMOD(I8,UI1,100,10,I8,0,S_OK);
1994   VARMOD(I8,I2,100,10,I8,0,S_OK);
1995   VARMOD(I8,UI2,100,10,I8,0,S_OK);
1996   VARMOD(I8,I4,100,10,I8,0,S_OK);
1997   VARMOD(I8,UI4,100,10,I8,0,S_OK);
1998   VARMOD(I8,R4,100,10,I8,0,S_OK);
1999   VARMOD(I8,R8,100,10,I8,0,S_OK);
2000   VARMOD(I8,I8,100,10,I8,0,S_OK);
2001
2002   VARMOD(INT,INT,100,10,I4,0,S_OK);
2003   VARMOD(INT,UINT,100,10,I4,0,S_OK);
2004
2005   VARMOD(BOOL,BOOL,100,10,I2,0,S_OK);
2006   VARMOD(BOOL,I1,100,10,I4,0,S_OK);
2007   VARMOD(BOOL,UI1,100,10,I2,0,S_OK);
2008   VARMOD(BOOL,I2,100,10,I2,0,S_OK);
2009   VARMOD(BOOL,UI2,100,10,I4,0,S_OK);
2010   VARMOD(BOOL,I4,100,10,I4,0,S_OK);
2011   VARMOD(BOOL,UI4,100,10,I4,0,S_OK);
2012   VARMOD(BOOL,R4,100,10,I4,0,S_OK);
2013   VARMOD(BOOL,R8,100,10,I4,0,S_OK);
2014   VARMOD(BOOL,I8,100,10,I8,0,S_OK);
2015   VARMOD(BOOL,DATE,100,10,I4,0,S_OK);
2016
2017   VARMOD(DATE,BOOL,100,10,I4,0,S_OK);
2018   VARMOD(DATE,I1,100,10,I4,0,S_OK);
2019   VARMOD(DATE,UI1,100,10,I4,0,S_OK);
2020   VARMOD(DATE,I2,100,10,I4,0,S_OK);
2021   VARMOD(DATE,UI2,100,10,I4,0,S_OK);
2022   VARMOD(DATE,I4,100,10,I4,0,S_OK);
2023   VARMOD(DATE,UI4,100,10,I4,0,S_OK);
2024   VARMOD(DATE,R4,100,10,I4,0,S_OK);
2025   VARMOD(DATE,R8,100,10,I4,0,S_OK);
2026   VARMOD(DATE,I8,100,10,I8,0,S_OK);
2027   VARMOD(DATE,DATE,100,10,I4,0,S_OK);
2028
2029   strNum0 = SysAllocString(szNum0);
2030   strNum1 = SysAllocString(szNum1);
2031   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5,S_OK);
2032   VARMOD(BSTR,I1,strNum0,10,I4,5,S_OK);
2033   VARMOD(BSTR,I2,strNum0,10,I4,5,S_OK);
2034   VARMOD(BSTR,I4,strNum0,10,I4,5,S_OK);
2035   VARMOD(BSTR,R4,strNum0,10,I4,5,S_OK);
2036   VARMOD(BSTR,R8,strNum0,10,I4,5,S_OK);
2037   VARMOD(BSTR,I8,strNum0,10,I8,5,S_OK);
2038   VARMOD(I4,BSTR,125,strNum1,I4,5,S_OK);
2039
2040   /* test all combinations of types */
2041   for(l = 0; l < VT_BSTR_BLOB; l++)
2042   {
2043     SKIPTESTS(l);
2044
2045     for(r = 0; r < VT_BSTR_BLOB; r++)
2046     {
2047       SKIPTESTS(r);
2048
2049       if(l == VT_BSTR) continue;
2050       if(l == VT_DISPATCH) continue;
2051       if(r == VT_BSTR) continue;
2052       if(r == VT_DISPATCH) continue;
2053
2054       lFound = TRUE;
2055       lValid = TRUE;
2056       switch(l)
2057         {
2058         case VT_EMPTY:
2059         case VT_NULL:
2060         case VT_I1:
2061         case VT_UI1:
2062         case VT_I2:
2063         case VT_UI2:
2064         case VT_I4:
2065         case VT_I8:
2066         case VT_UI4:
2067         case VT_UI8:
2068         case VT_INT:
2069         case VT_UINT:
2070         case VT_R4:
2071         case VT_R8:
2072         case VT_BOOL:
2073         case VT_DATE:
2074         case VT_CY:
2075           hexpected = S_OK;
2076           break;
2077         case VT_ERROR:
2078         case VT_VARIANT:
2079         case VT_UNKNOWN:
2080         case VT_DECIMAL:
2081         case VT_RECORD:
2082           lValid = FALSE;
2083           break;
2084         default:
2085           lFound = FALSE;
2086           hexpected = DISP_E_BADVARTYPE;
2087           break;
2088         }
2089
2090       rFound = TRUE;
2091       rValid = TRUE;
2092       switch(r)
2093         {
2094         case VT_EMPTY:
2095         case VT_NULL:
2096         case VT_I1:
2097         case VT_UI1:
2098         case VT_I2:
2099         case VT_UI2:
2100         case VT_I4:
2101         case VT_I8:
2102         case VT_UI4:
2103         case VT_UI8:
2104         case VT_INT:
2105         case VT_UINT:
2106         case VT_R4:
2107         case VT_R8:
2108         case VT_BOOL:
2109         case VT_DATE:
2110         case VT_CY:
2111           hexpected = S_OK;
2112           break;
2113         case VT_ERROR:
2114         case VT_VARIANT:
2115         case VT_UNKNOWN:
2116         case VT_DECIMAL:
2117         case VT_RECORD:
2118           rValid = FALSE;
2119           break;
2120         default:
2121           rFound = FALSE;
2122           break;
2123         }
2124
2125       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2126       {
2127         hexpected = DISP_E_TYPEMISMATCH;
2128       } else if((l == VT_EMPTY) && (r == VT_NULL))
2129       {
2130         hexpected = S_OK;
2131       } else if((l == VT_NULL) && (r == VT_EMPTY))
2132       {
2133         hexpected = S_OK;
2134       } else if((l == VT_EMPTY) && (r == VT_CY))
2135       {
2136         hexpected = S_OK;
2137       } else if((l == VT_EMPTY) && (r == VT_RECORD))
2138       {
2139         hexpected = DISP_E_TYPEMISMATCH;
2140       } else if((r == VT_EMPTY) && lFound && lValid)
2141       {
2142         hexpected = DISP_E_DIVBYZERO;
2143       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2144       {
2145         hexpected = DISP_E_TYPEMISMATCH;
2146       } else if((l == VT_NULL) && (r == VT_NULL))
2147       {
2148         hexpected = S_OK;
2149       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2150       {
2151         hexpected = DISP_E_TYPEMISMATCH;
2152       } else if((l == VT_NULL) && (r == VT_RECORD))
2153       {
2154         hexpected = DISP_E_TYPEMISMATCH;
2155       } else if((l == VT_NULL) && (r == VT_DECIMAL))
2156       {
2157         hexpected = E_INVALIDARG;
2158       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2159       {
2160         hexpected = DISP_E_TYPEMISMATCH;
2161       } else if((l == VT_NULL) && rFound)
2162       {
2163         hexpected = S_OK;
2164       } else if((l == VT_DECIMAL) || ((r == VT_DECIMAL) && lFound && lValid))
2165       {
2166         hexpected = E_INVALIDARG;
2167       } else if(l == VT_RECORD)
2168       {
2169         hexpected = DISP_E_TYPEMISMATCH;
2170       } else if((r == VT_RECORD) && lValid && lFound)
2171       {
2172         hexpected = DISP_E_TYPEMISMATCH;
2173       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2174       {
2175         hexpected = DISP_E_DIVBYZERO;
2176       } else if((l == VT_CY) && !rFound)
2177       {
2178         hexpected = DISP_E_BADVARTYPE;
2179       } else if(lFound && !rFound)
2180       {
2181         hexpected = DISP_E_BADVARTYPE;
2182       } else if(!lFound && rFound)
2183       {
2184         hexpected = DISP_E_BADVARTYPE;
2185       } else if((r == VT_NULL) && lFound && lValid)
2186       {
2187         hexpected = S_OK;
2188       } else if((l == VT_NULL) || (r == VT_NULL))
2189       {
2190         hexpected = DISP_E_BADVARTYPE;
2191       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2192       {
2193         hexpected = DISP_E_BADVARTYPE;
2194       } else if(lFound && !rFound)
2195       {
2196         hexpected = DISP_E_BADVARTYPE;
2197       } else if(!lFound && !rFound)
2198       {
2199         hexpected = DISP_E_BADVARTYPE;
2200       }
2201
2202       V_VT(&v1) = l;
2203       V_VT(&v2) = r;
2204
2205       if(l == VT_CY)
2206         V_CY(&v1).int64 = 1000000;
2207       else if(l == VT_R4)
2208         V_R4(&v1) = 100;
2209       else if(l == VT_R8)
2210         V_R8(&v1) = 100;
2211       else if(l == VT_UI8)
2212         V_UI8(&v1) = 100;
2213       else if(l == VT_DATE)
2214         V_DATE(&v1) = 1000;
2215       else
2216         V_I4(&v1) = 10000;
2217
2218       if(r == VT_CY)
2219         V_CY(&v2).int64 = 10000;
2220       else if(r == VT_R4)
2221         V_R4(&v2) = 100;
2222       else if(r == VT_R8)
2223         V_R8(&v2) = 100;
2224       else if(r == VT_UI8)
2225         V_UI8(&v2) = 100;
2226       else if(r == VT_DATE)
2227         V_DATE(&v2) = 1000;
2228       else
2229         V_I4(&v2) = 10000;
2230
2231       hres = pVarMod(&v1,&v2,&vDst);
2232       ok(hres == hexpected,
2233          "VarMod: expected 0x%lx, got 0x%lX for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2234     }
2235   }
2236
2237
2238   /****************************/
2239   /* test some bad parameters */
2240   VARMOD(I4,I4,-1,-1,I4,0,S_OK);
2241
2242   /* test modulus with zero */
2243   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2244
2245   VARMOD(I4,I4,0,10,I4,0,S_OK); /* test 0 mod 10 */
2246
2247   /* right parameter is type empty */
2248   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2249
2250   /* left parameter is type empty */
2251   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2252
2253   /* mod with a null left value */
2254   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2255
2256   /* mod with a null right value */
2257   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2258
2259   /* void left value */
2260   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2261
2262   /* void right value */
2263   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2264
2265   /* null left value, void right value */
2266   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2267
2268   /* void left value, null right value */
2269   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2270
2271   /* some currencies */
2272   V_VT(&v1) = VT_CY;
2273   V_VT(&v2) = VT_CY;
2274   V_CY(&v1).int64 = 100000;
2275   V_CY(&v2).int64 = 100000;
2276   hres = pVarMod(&v1,&v2,&vDst);
2277   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2278      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2279
2280   V_VT(&v1) = VT_I4;
2281   V_VT(&v2) = VT_CY;
2282   V_I4(&v1) = 100;
2283   V_CY(&v2).int64 = 100000;
2284   hres = pVarMod(&v1,&v2,&vDst);
2285   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2286      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2287
2288   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2289
2290   /* test that an error results in the type of the result changing but not its value */
2291   V_VT(&v1) = VT_UNKNOWN;
2292   V_VT(&v2) = VT_EMPTY;
2293   V_I4(&v1) = 100;
2294   V_CY(&v2).int64 = 100000;
2295   V_VT(&vDst) = VT_I4;
2296   V_I4(&vDst) = 1231;
2297   hres = pVarMod(&v1,&v2,&vDst);
2298   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2299      "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));
2300
2301
2302   /* test some invalid types */
2303   /*TODO: not testing VT_DISPATCH */
2304   VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2305   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2306   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2307   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2308   VARMOD2(DECIMAL,I4,100,10,EMPTY,0,E_INVALIDARG);
2309   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2310   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2311   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2312   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2313   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2314   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2315   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2316   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2317   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2318   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2319   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2320   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2321   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2322   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2323   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2324   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2325   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2326   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2327   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2328   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2329   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2330
2331   /* test some more invalid types */
2332   V_VT(&v1) = 456;
2333   V_VT(&v2) = 234;
2334   V_I4(&v1) = 100;
2335   V_I4(&v2)=  10;
2336   hres = pVarMod(&v1,&v2,&vDst);
2337   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 0,
2338      "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));
2339 }
2340
2341 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2342
2343 static const char *szVarFixFail = "VarFix: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2344 #define VARFIX(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2345         memset(&vDst,0,sizeof(vDst)); hres = pVarFix(&v,&vDst); \
2346         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2347         szVarFixFail, VT_##rvt, (int)(rval), \
2348         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2349
2350 static void test_VarFix(void)
2351 {
2352     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2353     HRESULT hres;
2354     VARIANT v, vDst;
2355     DECIMAL *pdec = &V_DECIMAL(&v);
2356     CY *pcy = &V_CY(&v);
2357     size_t i;
2358
2359     CHECKPTR(VarFix);
2360
2361     /* Test all possible V_VT values */
2362     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2363     {
2364         VARTYPE vt;
2365
2366         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2367         {
2368             HRESULT bFail = TRUE;
2369
2370             SKIPTESTS(vt);
2371
2372             memset(&v, 0, sizeof(v));
2373             V_VT(&v) = vt | ExtraFlags[i];
2374             V_VT(&vDst) = VT_EMPTY;
2375
2376             switch (V_VT(&v))
2377             {
2378               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2379               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2380               case VT_DATE: case VT_CY:
2381                 bFail = FALSE;
2382                 break;
2383               case VT_I8:
2384                 if (HAVE_OLEAUT32_I8)
2385                   bFail = FALSE;
2386                 break;
2387             }
2388
2389             hres = pVarFix(&v,&vDst);
2390             if (bFail)
2391               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2392                  "VarFix: expected failure, got 0x%lX vt %d|0x%X\n",
2393                  hres, vt, ExtraFlags[i]);
2394             else
2395                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%lX vt %d|0x%X\n",
2396                     hres, vt, ExtraFlags[i]);
2397         }
2398     }
2399
2400     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2401     VARFIX(BOOL,VARIANT_FALSE,I2,0);
2402     VARFIX(BOOL,1,I2,1);
2403     VARFIX(UI1,1,UI1,1);
2404     VARFIX(I2,-1,I2,-1);
2405     VARFIX(I4,-1,I4,-1);
2406     if (HAVE_OLEAUT32_I8)
2407     {
2408         VARFIX(I8,-1,I8,-1);
2409     }
2410     VARFIX(R4,1.4,R4,1);
2411     VARFIX(R4,1.5,R4,1);
2412     VARFIX(R4,1.6,R4,1);
2413     VARFIX(R4,-1.4,R4,-1);
2414     VARFIX(R4,-1.5,R4,-1);
2415     VARFIX(R4,-1.6,R4,-1);
2416     /* DATE & R8 round as for R4 */
2417     VARFIX(DATE,-1,DATE,-1);
2418     VARFIX(R8,-1,R8,-1);
2419     VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2420
2421     V_VT(&v) = VT_EMPTY;
2422     hres = pVarFix(&v,&vDst);
2423     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2424        "VarFix: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2425        hres, V_VT(&vDst), V_I2(&vDst));
2426
2427     V_VT(&v) = VT_NULL;
2428     hres = pVarFix(&v,&vDst);
2429     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2430        "VarFix: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2431
2432     V_VT(&v) = VT_DECIMAL;
2433     S(U(*pdec)).sign = DECIMAL_NEG;
2434     S(U(*pdec)).scale = 0;
2435     pdec->Hi32 = 0;
2436     S1(U1(*pdec)).Mid32 = 0;
2437     S1(U1(*pdec)).Lo32 = 1;
2438     hres = pVarFix(&v,&vDst);
2439     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2440        "VarFix: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
2441        hres, V_VT(&vDst));
2442
2443     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2444
2445     V_VT(&v) = VT_CY;
2446     pcy->int64 = -10000;
2447     hres = pVarFix(&v,&vDst);
2448     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2449        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
2450
2451     V_VT(&v) = VT_CY;
2452     pcy->int64 = -16000;
2453     hres = pVarFix(&v,&vDst);
2454     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2455        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
2456 }
2457
2458 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2459
2460 static const char *szVarIntFail = "VarInt: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2461 #define VARINT(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2462         memset(&vDst,0,sizeof(vDst)); hres = pVarInt(&v,&vDst); \
2463         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2464         szVarIntFail, VT_##rvt, (int)(rval), \
2465         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2466
2467 static void test_VarInt(void)
2468 {
2469     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2470     HRESULT hres;
2471     VARIANT v, vDst;
2472     DECIMAL *pdec = &V_DECIMAL(&v);
2473     CY *pcy = &V_CY(&v);
2474     size_t i;
2475
2476     CHECKPTR(VarInt);
2477
2478     /* Test all possible V_VT values */
2479     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2480     {
2481         VARTYPE vt;
2482
2483         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2484         {
2485             HRESULT bFail = TRUE;
2486
2487             SKIPTESTS(vt);
2488
2489             memset(&v, 0, sizeof(v));
2490             V_VT(&v) = vt | ExtraFlags[i];
2491             V_VT(&vDst) = VT_EMPTY;
2492
2493             switch (V_VT(&v))
2494             {
2495               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
2496               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2497               case VT_DATE: case VT_CY:
2498                 bFail = FALSE;
2499                 break;
2500               case VT_I8:
2501                 if (HAVE_OLEAUT32_I8)
2502                   bFail = FALSE;
2503                 break;
2504             }
2505
2506             hres = pVarInt(&v,&vDst);
2507             if (bFail)
2508               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2509                  "VarInt: expected failure, got 0x%lX vt %d|0x%X\n",
2510                  hres, vt, ExtraFlags[i]);
2511             else
2512                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%lX vt %d|0x%X\n",
2513                     hres, vt, ExtraFlags[i]);
2514         }
2515     }
2516
2517     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2518     VARINT(BOOL,VARIANT_FALSE,I2,0);
2519     VARINT(BOOL,1,I2,1);
2520     VARINT(UI1,1,UI1,1);
2521     VARINT(I2,-1,I2,-1);
2522     VARINT(I4,-1,I4,-1);
2523     if (HAVE_OLEAUT32_I8)
2524     {
2525         VARINT(I8,-1,I8,-1);
2526     }
2527     VARINT(R4,1.4,R4,1);
2528     VARINT(R4,1.5,R4,1);
2529     VARINT(R4,1.6,R4,1);
2530     VARINT(R4,-1.4,R4,-2); /* Note these 3 are different from VarFix */
2531     VARINT(R4,-1.5,R4,-2);
2532     VARINT(R4,-1.6,R4,-2);
2533     /* DATE & R8 round as for R4 */
2534     VARINT(DATE,-1,DATE,-1);
2535     VARINT(R8,-1,R8,-1);
2536     VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
2537
2538     V_VT(&v) = VT_EMPTY;
2539     hres = pVarInt(&v,&vDst);
2540     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2541        "VarInt: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2542        hres, V_VT(&vDst), V_I2(&vDst));
2543
2544     V_VT(&v) = VT_NULL;
2545     hres = pVarInt(&v,&vDst);
2546     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2547        "VarInt: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2548
2549     V_VT(&v) = VT_DECIMAL;
2550     S(U(*pdec)).sign = DECIMAL_NEG;
2551     S(U(*pdec)).scale = 0;
2552     pdec->Hi32 = 0;
2553     S1(U1(*pdec)).Mid32 = 0;
2554     S1(U1(*pdec)).Lo32 = 1;
2555     hres = pVarInt(&v,&vDst);
2556     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&v, &vDst, sizeof(v)),
2557        "VarInt: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
2558        hres, V_VT(&vDst));
2559
2560     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
2561
2562     V_VT(&v) = VT_CY;
2563     pcy->int64 = -10000;
2564     hres = pVarInt(&v,&vDst);
2565     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2566        "VarInt: VT_CY wrong, hres=0x%lX\n", hres);
2567
2568     V_VT(&v) = VT_CY;
2569     pcy->int64 = -11000;
2570     hres = pVarInt(&v,&vDst);
2571     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
2572        "VarInt: VT_CY wrong, hres=0x%lX %lld\n", hres,V_CY(&vDst).int64);
2573 }
2574
2575 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
2576
2577 static const char *szVarNegFail = "VarNeg: expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2578 #define VARNEG(vt,val,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2579         memset(&vDst,0,sizeof(vDst)); hres = pVarNeg(&v,&vDst); \
2580         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2581         szVarNegFail, VT_##rvt, (int)(rval), \
2582         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2583
2584 static void test_VarNeg(void)
2585 {
2586     static const WCHAR szNumMinus1[] = {'-','1','\0' };
2587     static const WCHAR szNum1[] = {'1','\0' };
2588     HRESULT hres;
2589     VARIANT v, vDst;
2590     DECIMAL *pdec = &V_DECIMAL(&v);
2591     CY *pcy = &V_CY(&v);
2592     size_t i;
2593
2594     CHECKPTR(VarNeg);
2595
2596     /* Test all possible V_VT values. But don't test the exact return values
2597      * except for success/failure, since M$ made a hash of them in the
2598      * native version. This at least ensures (as with all tests here) that
2599      * we will notice if/when new vtypes/flags are added in native.
2600      */
2601     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2602     {
2603         VARTYPE vt;
2604
2605         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2606         {
2607             HRESULT bFail = TRUE;
2608
2609             SKIPTESTS(vt);
2610
2611             memset(&v, 0, sizeof(v));
2612             V_VT(&v) = vt | ExtraFlags[i];
2613             V_VT(&vDst) = VT_EMPTY;
2614
2615             switch (V_VT(&v))
2616             {
2617             case VT_UI1: case VT_I2: case VT_I4:
2618             case VT_R4:  case VT_R8:
2619             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2620             case VT_DATE: case VT_CY:
2621                 bFail = FALSE;
2622                 break;
2623             case VT_I8:
2624                 if (HAVE_OLEAUT32_I8)
2625                     bFail = FALSE;
2626             }
2627
2628             hres = pVarNeg(&v,&vDst);
2629             if (bFail)
2630                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2631                    "VarNeg: expected failure, got 0x%lX vt %d|0x%X\n",
2632                    hres, vt, ExtraFlags[i]);
2633             else
2634                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%lX vt %d|0x%X\n",
2635                     hres, vt, ExtraFlags[i]);
2636         }
2637     }
2638
2639     VARNEG(BOOL,VARIANT_TRUE,I2,1);
2640     VARNEG(BOOL,VARIANT_FALSE,I2,0);
2641     VARNEG(BOOL,1,I2,-1);
2642     VARNEG(UI1,1,I2,-1);
2643     VARNEG(UI1,254,I2,-254);
2644     VARNEG(I2,-32768,I4,32768);
2645     VARNEG(I2,-1,I2,1);
2646     VARNEG(I2,1,I2,-1);
2647     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
2648     VARNEG(I4,-1,I4,1);
2649     VARNEG(I4,1,I4,-1);
2650     if (HAVE_OLEAUT32_I8)
2651     {
2652         VARNEG(I8,1,I8,-1);
2653         VARNEG(I8,-1,I8,1);
2654     }
2655     VARNEG(R4,1,R4,-1);
2656     VARNEG(R4,-1,R4,1);
2657     VARNEG(DATE,1,DATE,-1);
2658     VARNEG(DATE,-1,DATE,1);
2659     VARNEG(R8,1,R8,-1);
2660     VARNEG(R8,-1,R8,1);
2661     VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
2662     VARNEG(BSTR,(BSTR)szNum1,R8,-1);
2663
2664     V_VT(&v) = VT_EMPTY;
2665     hres = pVarNeg(&v,&vDst);
2666     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2667        "VarNeg: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2668        hres, V_VT(&vDst), V_I2(&vDst));
2669
2670     V_VT(&v) = VT_NULL;
2671     hres = pVarNeg(&v,&vDst);
2672     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2673        "VarNeg: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2674
2675     V_VT(&v) = VT_DECIMAL;
2676     S(U(*pdec)).sign = DECIMAL_NEG;
2677     S(U(*pdec)).scale = 0;
2678     pdec->Hi32 = 0;
2679     S1(U1(*pdec)).Mid32 = 0;
2680     S1(U1(*pdec)).Lo32 = 1;
2681     hres = pVarNeg(&v,&vDst);
2682     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2683        S(U(V_DECIMAL(&vDst))).sign == 0,
2684        "VarNeg: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2685        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2686
2687     S(U(*pdec)).sign = 0;
2688     hres = pVarNeg(&v,&vDst);
2689     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2690        S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
2691        "VarNeg: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2692        hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2693
2694     V_VT(&v) = VT_CY;
2695     pcy->int64 = -10000;
2696     hres = pVarNeg(&v,&vDst);
2697     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
2698        "VarNeg: VT_CY wrong, hres=0x%lX\n", hres);
2699 }
2700
2701 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
2702
2703 #define VARROUND(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2704         memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \
2705         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2706         "VarRound: expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##rvt, (int)(rval), \
2707         hres, V_VT(&vDst), (int)V_##rvt(&vDst))
2708
2709 #define VARROUNDF(vt,val,deci,rvt,rval) V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2710         memset(&vDst,0,sizeof(vDst)); hres = pVarRound(&v,deci,&vDst); \
2711         ok(hres == S_OK && V_VT(&vDst) == VT_##rvt && V_##rvt(&vDst) == (rval), \
2712         "VarRound: expected 0x0,%d,%f, got 0x%lX,%d,%f\n", VT_##rvt, rval, \
2713         hres, V_VT(&vDst), V_##rvt(&vDst))
2714
2715 static void test_VarRound(void)
2716 {
2717     /* static const WCHAR szNumMin[] = {'-','1','.','4','5','\0' };
2718        static const WCHAR szNum[] = {'1','.','4','5','\0' }; */
2719     HRESULT hres;
2720     VARIANT v, vDst;
2721     CY *pcy = &V_CY(&v);
2722
2723     CHECKPTR(VarRound);
2724
2725     /* first check valid integer types */
2726     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
2727     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
2728     VARROUND(BOOL,1,0,I2,1);
2729     VARROUND(UI1,1,0,UI1,1);
2730     VARROUND(UI1,254,0,UI1,254);
2731     VARROUND(I2,-32768,0,I2,-32768);
2732     VARROUND(I2,-1,0,I2,-1);
2733     VARROUND(I2,1,0,I2,1);
2734     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
2735     VARROUND(I4,-1,0,I4,-1);
2736     VARROUND(I4,1,0,I4,1);
2737
2738
2739     /* MSDN states that rounding of R4/R8 is dependent on the underlying
2740      * bit pattern of the number and so is architecture dependent. In this
2741      * case Wine returns .2 (which is more correct) and Native returns .3
2742      */
2743
2744     VARROUNDF(R4,1.0,0,R4,1.0);
2745     VARROUNDF(R4,-1.0,0,R4,-1.0);
2746     VARROUNDF(R8,1.0,0,R8,1.0);
2747     VARROUNDF(R8,-1.0,0,R8,-1.0);
2748
2749     /* floating point numbers aren't exactly equal and we can't just
2750      * compare the first few digits.
2751     todo_wine {
2752         VARROUNDF(DATE,1.451,1,DATE,1.5);
2753         VARROUNDF(DATE,-1.45,1,DATE,-1.4);
2754         VARROUNDF(BSTR,(BSTR)szNumMin,1,R8,-1.40);
2755         VARROUNDF(BSTR,(BSTR)szNum,1,R8,1.50);
2756
2757         VARROUNDF(R4,1.23456,0,R4,1.0);
2758         VARROUNDF(R4,1.23456,1,R4,1.2);
2759         VARROUNDF(R4,1.23456,2,R4,1.23);
2760         VARROUNDF(R4,1.23456,3,R4,1.235);
2761         VARROUNDF(R4,1.23456,4,R4,1.2346);
2762         VARROUNDF(R4,-1.23456,0,R4,-1.0);
2763         VARROUNDF(R4,-1.23456,1,R4,-1.2);
2764         VARROUNDF(R4,-1.23456,2,R4,-1.23);
2765         VARROUNDF(R4,-1.23456,3,R4,-1.235);
2766         VARROUNDF(R4,-1.23456,4,R4,-1.2346);
2767
2768         VARROUNDF(R8,1.23456,0,R8,1.0);
2769         VARROUNDF(R8,1.23456,1,R8,1.2);
2770         VARROUNDF(R8,1.23456,2,R8,1.23);
2771         VARROUNDF(R8,1.23456,3,R8,1.235);
2772         VARROUNDF(R8,1.23456,4,R8,1.2346);
2773         VARROUNDF(R8,-1.23456,0,R8,-1.0);
2774         VARROUNDF(R8,-1.23456,1,R8,-1.2);
2775         VARROUNDF(R8,-1.23456,2,R8,-1.23);
2776         VARROUNDF(R8,-1.23456,3,R8,-1.235);
2777         VARROUNDF(R8,-1.23456,4,R8,-1.2346);
2778     }
2779     */
2780
2781     V_VT(&v) = VT_EMPTY;
2782     hres = pVarRound(&v,0,&vDst);
2783     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2784         "VarRound: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
2785         hres, V_VT(&vDst), V_I2(&vDst));
2786
2787     V_VT(&v) = VT_NULL;
2788     hres = pVarRound(&v,0,&vDst);
2789     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2790         "VarRound: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
2791
2792     /* not yet implemented so no use testing yet
2793     todo_wine {
2794         DECIMAL *pdec = &V_DECIMAL(&v);
2795         V_VT(&v) = VT_DECIMAL;
2796         S(U(*pdec)).sign = DECIMAL_NEG;
2797         S(U(*pdec)).scale = 0;
2798         pdec->Hi32 = 0;
2799         S1(U1(*pdec)).Mid32 = 0;
2800         S1(U1(*pdec)).Lo32 = 1;
2801         hres = pVarRound(&v,0,&vDst);
2802         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2803             S(U(V_DECIMAL(&vDst))).sign == 0,
2804             "VarRound: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2805             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2806
2807         S(U(*pdec)).sign = 0;
2808         hres = pVarRound(&v,0,&vDst);
2809         ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
2810             S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
2811             "VarRound: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
2812             hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
2813     }
2814     */
2815
2816     V_VT(&v) = VT_CY;
2817     pcy->int64 = 10000;
2818     hres = pVarRound(&v,0,&vDst);
2819     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
2820         "VarRound: VT_CY wrong, hres=0x%lX\n", hres);
2821
2822 }
2823
2824 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
2825
2826 static const char *szVarXorFail = "VarXor(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
2827 #define VARXOR(vt1,val1,vt2,val2,rvt,rval) \
2828         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
2829         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2830         memset(&result,0,sizeof(result)); hres = pVarXor(&left,&right,&result); \
2831         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
2832         szVarXorFail, VT_##vt1, VT_##vt2, \
2833         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
2834         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
2835            V_VT(&right) == VT_##vt2 && V_##vt2(&right) == val2, \
2836            "VarXor(%d,%d): Modified input arguments\n",VT_##vt1,VT_##vt2)
2837 #define VARXORCY(vt1,val1,val2,rvt,rval) \
2838         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
2839         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
2840         memset(&result,0,sizeof(result)); hres = pVarXor(&left,&right,&result); \
2841         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
2842         "VarXor(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##vt1, VT_CY, \
2843         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
2844         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
2845            V_VT(&right) == VT_CY && V_CY(&right).int64 == val2, \
2846            "VarXor(%d,%d): Modified input arguments\n",VT_##vt1,VT_CY)
2847
2848 static void test_VarXor(void)
2849 {
2850     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
2851     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
2852     VARIANT left, right, result;
2853     BSTR lbstr, rbstr;
2854     VARTYPE i;
2855     HRESULT hres;
2856
2857     CHECKPTR(VarXor);
2858
2859     /* Test all possible flag/vt combinations & the resulting vt type */
2860     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2861     {
2862         VARTYPE leftvt, rightvt, resvt;
2863
2864         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
2865         {
2866
2867             SKIPTESTS(leftvt);
2868
2869             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
2870             {
2871                 BOOL bFail = FALSE;
2872
2873                 SKIPTESTS(rightvt);
2874
2875                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
2876                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
2877                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
2878                     continue;
2879
2880                 memset(&left, 0, sizeof(left));
2881                 memset(&right, 0, sizeof(right));
2882                 V_VT(&left) = leftvt | ExtraFlags[i];
2883                 V_VT(&right) = rightvt | ExtraFlags[i];
2884                 V_VT(&result) = VT_EMPTY;
2885                 resvt = VT_I4;
2886
2887                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
2888                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
2889                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
2890                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
2891                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
2892                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
2893                     leftvt == VT_ERROR || rightvt == VT_ERROR)
2894                 {
2895                     bFail = TRUE;
2896                 }
2897                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
2898                 {
2899                     if (leftvt == rightvt ||
2900                         leftvt == VT_I2 || rightvt == VT_I2 ||
2901                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
2902                         leftvt == VT_BOOL || rightvt == VT_BOOL)
2903                         resvt = VT_I2;
2904                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
2905                         resvt = VT_NULL;
2906                     else if (leftvt == VT_I8 || rightvt == VT_I8)
2907                         resvt = VT_I8;
2908                 }
2909                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
2910                 {
2911                     resvt = VT_NULL;
2912                 }
2913                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
2914                 {
2915                     if (leftvt == rightvt)
2916                         resvt = VT_UI1;
2917                     else if (leftvt == rightvt ||
2918                         leftvt == VT_I2 || rightvt == VT_I2 ||
2919                         leftvt == VT_BOOL || rightvt == VT_BOOL)
2920                     {
2921                         resvt = VT_I2;
2922                     }
2923                     else if (leftvt == VT_I8 || rightvt == VT_I8)
2924                         resvt = VT_I8;
2925                 }
2926                 else if (leftvt == VT_I2 || rightvt == VT_I2)
2927                 {
2928                     if (leftvt == rightvt ||
2929                         leftvt == VT_BOOL || rightvt == VT_BOOL)
2930                         resvt = VT_I2;
2931                     else if (leftvt == VT_I8 || rightvt == VT_I8)
2932                         resvt = VT_I8;
2933                 }
2934                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
2935                 {
2936                     resvt = VT_BOOL;
2937                 }
2938                 else if (leftvt == VT_I8 || rightvt == VT_I8)
2939                 {
2940                     if (leftvt == VT_INT || rightvt == VT_INT)
2941                         bFail = TRUE;
2942                     else
2943                         resvt = VT_I8;
2944                 }
2945                 hres = pVarXor(&left, &right, &result);
2946                 if (bFail)
2947                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2948                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
2949                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
2950                        V_VT(&result));
2951                 else
2952                     ok(hres == S_OK && V_VT(&result) == resvt,
2953                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
2954                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
2955                        V_VT(&result));
2956             }
2957         }
2958     }
2959
2960     /* Test returned values
2961      * FIXME: Test VT_DECIMAL/VT_DISPATCH
2962      */
2963     VARXOR(EMPTY,0,EMPTY,0,I2,0);
2964     VARXOR(EMPTY,1,EMPTY,0,I2,0);
2965     VARXOR(EMPTY,0,NULL,0,NULL,0);
2966     VARXOR(EMPTY,0,I1,0,I4,0);
2967     VARXOR(EMPTY,0,I1,1,I4,1);
2968     VARXOR(EMPTY,0,UI1,0,I2,0);
2969     VARXOR(EMPTY,0,UI1,1,I2,1);
2970     VARXOR(EMPTY,0,I2,0,I2,0);
2971     VARXOR(EMPTY,0,I2,1,I2,1);
2972     VARXOR(EMPTY,0,UI2,0,I4,0);
2973     VARXOR(EMPTY,0,UI2,1,I4,1);
2974     VARXOR(EMPTY,0,I4,0,I4,0);
2975     VARXOR(EMPTY,0,I4,1,I4,1);
2976     VARXOR(EMPTY,0,UI4,0,I4,0);
2977     VARXOR(EMPTY,0,UI4,1,I4,1);
2978     if (HAVE_OLEAUT32_I8)
2979     {
2980         VARXOR(EMPTY,0,I8,0,I8,0);
2981         VARXOR(EMPTY,0,I8,1,I8,1);
2982         VARXOR(EMPTY,0,UI8,0,I4,0);
2983         VARXOR(EMPTY,0,UI8,1,I4,1);
2984     }
2985     VARXOR(EMPTY,0,INT,0,I4,0);
2986     VARXOR(EMPTY,0,INT,1,I4,1);
2987     VARXOR(EMPTY,0,UINT,0,I4,0);
2988     VARXOR(EMPTY,0,UINT,1,I4,1);
2989     VARXOR(EMPTY,0,BOOL,0,I2,0);
2990     VARXOR(EMPTY,0,BOOL,1,I2,1);
2991     VARXOR(EMPTY,0,R4,0,I4,0);
2992     VARXOR(EMPTY,0,R4,1,I4,1);
2993     VARXOR(EMPTY,0,R8,0,I4,0);
2994     VARXOR(EMPTY,0,R8,1,I4,1);
2995     rbstr = SysAllocString(szFalse);
2996     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
2997     rbstr = SysAllocString(szTrue);
2998     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
2999     VARXORCY(EMPTY,0,10000,I4,1);
3000
3001     /* NULL OR 0 = NULL. NULL OR n = n */
3002     VARXOR(NULL,0,NULL,0,NULL,0);
3003     VARXOR(NULL,1,NULL,0,NULL,0);
3004     VARXOR(NULL,0,I1,0,NULL,0);
3005     VARXOR(NULL,0,I1,1,NULL,0);
3006     VARXOR(NULL,0,UI1,0,NULL,0);
3007     VARXOR(NULL,0,UI1,1,NULL,0);
3008     VARXOR(NULL,0,I2,0,NULL,0);
3009     VARXOR(NULL,0,I2,1,NULL,0);
3010     VARXOR(NULL,0,UI2,0,NULL,0);
3011     VARXOR(NULL,0,UI2,1,NULL,0);
3012     VARXOR(NULL,0,I4,0,NULL,0);
3013     VARXOR(NULL,0,I4,1,NULL,0);
3014     VARXOR(NULL,0,UI4,0,NULL,0);
3015     VARXOR(NULL,0,UI4,1,NULL,0);
3016     if (HAVE_OLEAUT32_I8)
3017     {
3018         VARXOR(NULL,0,I8,0,NULL,0);
3019         VARXOR(NULL,0,I8,1,NULL,0);
3020         VARXOR(NULL,0,UI8,0,NULL,0);
3021         VARXOR(NULL,0,UI8,1,NULL,0);
3022     }
3023     VARXOR(NULL,0,INT,0,NULL,0);
3024     VARXOR(NULL,0,INT,1,NULL,0);
3025     VARXOR(NULL,0,UINT,0,NULL,0);
3026     VARXOR(NULL,0,UINT,1,NULL,0);
3027     VARXOR(NULL,0,BOOL,0,NULL,0);
3028     VARXOR(NULL,0,BOOL,1,NULL,0);
3029     VARXOR(NULL,0,R4,0,NULL,0);
3030     VARXOR(NULL,0,R4,1,NULL,0);
3031     VARXOR(NULL,0,R8,0,NULL,0);
3032     VARXOR(NULL,0,R8,1,NULL,0);
3033     rbstr = SysAllocString(szFalse);
3034     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3035     rbstr = SysAllocString(szTrue);
3036     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3037     VARXORCY(NULL,0,10000,NULL,0);
3038     VARXORCY(NULL,0,0,NULL,0);
3039
3040     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3041     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3042     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3043     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3044     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3045     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3046     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3047     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3048     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3049     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3050     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3051     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3052     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3053     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3054     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3055     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3056     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3057     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3058     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3059     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3060     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3061     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3062     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3063     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3064     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3065     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3066     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3067     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3068     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3069     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3070     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3071     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3072     if (HAVE_OLEAUT32_I8)
3073     {
3074         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3075         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3076         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3077         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3078          * to I4 is performed.
3079          */
3080         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3081         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3082         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3083     }
3084     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3085     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3086     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3087     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3088     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3089     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3090     rbstr = SysAllocString(szFalse);
3091     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3092     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3093     rbstr = SysAllocString(szTrue);
3094     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3095     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3096     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3097     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3098     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3099
3100     VARXOR(I1,-1,I1,-1,I4,0);
3101     VARXOR(I1,-1,I1,0,I4,-1);
3102     VARXOR(I1,0,I1,0,I4,0);
3103     VARXOR(I1,-1,UI1,255,I4,-256);
3104     VARXOR(I1,-1,UI1,0,I4,-1);
3105     VARXOR(I1,0,UI1,0,I4,0);
3106     VARXOR(I1,-1,I2,-1,I4,0);
3107     VARXOR(I1,-1,I2,0,I4,-1);
3108     VARXOR(I1,0,I2,0,I4,0);
3109     VARXOR(I1,-1,UI2,65535,I4,-65536);
3110     VARXOR(I1,-1,UI2,0,I4,-1);
3111     VARXOR(I1,0,UI2,0,I4,0);
3112     VARXOR(I1,-1,I4,-1,I4,0);
3113     VARXOR(I1,-1,I4,0,I4,-1);
3114     VARXOR(I1,0,I4,0,I4,0);
3115     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3116     VARXOR(I1,-1,UI4,0,I4,-1);
3117     VARXOR(I1,0,UI4,0,I4,0);
3118     VARXOR(I1,-1,R4,-1,I4,0);
3119     VARXOR(I1,-1,R4,0,I4,-1);
3120     VARXOR(I1,0,R4,0,I4,0);
3121     VARXOR(I1,-1,R8,-1,I4,0);
3122     VARXOR(I1,-1,R8,0,I4,-1);
3123     VARXOR(I1,0,R8,0,I4,0);
3124     VARXOR(I1,-1,DATE,-1,I4,0);
3125     VARXOR(I1,-1,DATE,0,I4,-1);
3126     VARXOR(I1,0,DATE,0,I4,0);
3127     if (HAVE_OLEAUT32_I8)
3128     {
3129         VARXOR(I1,-1,I8,-1,I8,0);
3130         VARXOR(I1,-1,I8,0,I8,-1);
3131         VARXOR(I1,0,I8,0,I8,0);
3132         VARXOR(I1,-1,UI8,0,I4,-1);
3133         VARXOR(I1,0,UI8,0,I4,0);
3134     }
3135     VARXOR(I1,-1,INT,-1,I4,0);
3136     VARXOR(I1,-1,INT,0,I4,-1);
3137     VARXOR(I1,0,INT,0,I4,0);
3138     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3139     VARXOR(I1,-1,UINT,0,I4,-1);
3140     VARXOR(I1,0,UINT,0,I4,0);
3141     rbstr = SysAllocString(szFalse);
3142     VARXOR(I1,0,BSTR,rbstr,I4,0);
3143     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3144     rbstr = SysAllocString(szTrue);
3145     VARXOR(I1,0,BSTR,rbstr,I4,-1);
3146     VARXOR(I1,-1,BSTR,rbstr,I4,0);
3147     VARXORCY(I1,-1,10000,I4,-2);
3148     VARXORCY(I1,-1,0,I4,-1);
3149     VARXORCY(I1,0,0,I4,0);
3150
3151     VARXOR(UI1,255,UI1,255,UI1,0);
3152     VARXOR(UI1,255,UI1,0,UI1,255);
3153     VARXOR(UI1,0,UI1,0,UI1,0);
3154     VARXOR(UI1,255,I2,-1,I2,-256);
3155     VARXOR(UI1,255,I2,0,I2,255);
3156     VARXOR(UI1,0,I2,0,I2,0);
3157     VARXOR(UI1,255,UI2,65535,I4,65280);
3158     VARXOR(UI1,255,UI2,0,I4,255);
3159     VARXOR(UI1,0,UI2,0,I4,0);
3160     VARXOR(UI1,255,I4,-1,I4,-256);
3161     VARXOR(UI1,255,I4,0,I4,255);
3162     VARXOR(UI1,0,I4,0,I4,0);
3163     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3164     VARXOR(UI1,255,UI4,0,I4,255);
3165     VARXOR(UI1,0,UI4,0,I4,0);
3166     VARXOR(UI1,255,R4,-1,I4,-256);
3167     VARXOR(UI1,255,R4,0,I4,255);
3168     VARXOR(UI1,0,R4,0,I4,0);
3169     VARXOR(UI1,255,R8,-1,I4,-256);
3170     VARXOR(UI1,255,R8,0,I4,255);
3171     VARXOR(UI1,0,R8,0,I4,0);
3172     VARXOR(UI1,255,DATE,-1,I4,-256);
3173     VARXOR(UI1,255,DATE,0,I4,255);
3174     VARXOR(UI1,0,DATE,0,I4,0);
3175     if (HAVE_OLEAUT32_I8)
3176     {
3177         VARXOR(UI1,255,I8,-1,I8,-256);
3178         VARXOR(UI1,255,I8,0,I8,255);
3179         VARXOR(UI1,0,I8,0,I8,0);
3180         VARXOR(UI1,255,UI8,0,I4,255);
3181         VARXOR(UI1,0,UI8,0,I4,0);
3182     }
3183     VARXOR(UI1,255,INT,-1,I4,-256);
3184     VARXOR(UI1,255,INT,0,I4,255);
3185     VARXOR(UI1,0,INT,0,I4,0);
3186     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3187     VARXOR(UI1,255,UINT,0,I4,255);
3188     VARXOR(UI1,0,UINT,0,I4,0);
3189     rbstr = SysAllocString(szFalse);
3190     VARXOR(UI1,0,BSTR,rbstr,I2,0);
3191     VARXOR(UI1,255,BSTR,rbstr,I2,255);
3192     rbstr = SysAllocString(szTrue);
3193     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3194     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3195     VARXORCY(UI1,255,10000,I4,254);
3196     VARXORCY(UI1,255,0,I4,255);
3197     VARXORCY(UI1,0,0,I4,0);
3198
3199     VARXOR(I2,-1,I2,-1,I2,0);
3200     VARXOR(I2,-1,I2,0,I2,-1);
3201     VARXOR(I2,0,I2,0,I2,0);
3202     VARXOR(I2,-1,UI2,65535,I4,-65536);
3203     VARXOR(I2,-1,UI2,0,I4,-1);
3204     VARXOR(I2,0,UI2,0,I4,0);
3205     VARXOR(I2,-1,I4,-1,I4,0);
3206     VARXOR(I2,-1,I4,0,I4,-1);
3207     VARXOR(I2,0,I4,0,I4,0);
3208     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3209     VARXOR(I2,-1,UI4,0,I4,-1);
3210     VARXOR(I2,0,UI4,0,I4,0);
3211     VARXOR(I2,-1,R4,-1,I4,0);
3212     VARXOR(I2,-1,R4,0,I4,-1);
3213     VARXOR(I2,0,R4,0,I4,0);
3214     VARXOR(I2,-1,R8,-1,I4,0);
3215     VARXOR(I2,-1,R8,0,I4,-1);
3216     VARXOR(I2,0,R8,0,I4,0);
3217     VARXOR(I2,-1,DATE,-1,I4,0);
3218     VARXOR(I2,-1,DATE,0,I4,-1);
3219     VARXOR(I2,0,DATE,0,I4,0);
3220     if (HAVE_OLEAUT32_I8)
3221     {
3222         VARXOR(I2,-1,I8,-1,I8,0);
3223         VARXOR(I2,-1,I8,0,I8,-1);
3224         VARXOR(I2,0,I8,0,I8,0);
3225         VARXOR(I2,-1,UI8,0,I4,-1);
3226         VARXOR(I2,0,UI8,0,I4,0);
3227     }
3228     VARXOR(I2,-1,INT,-1,I4,0);
3229     VARXOR(I2,-1,INT,0,I4,-1);
3230     VARXOR(I2,0,INT,0,I4,0);
3231     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3232     VARXOR(I2,-1,UINT,0,I4,-1);
3233     VARXOR(I2,0,UINT,0,I4,0);
3234     rbstr = SysAllocString(szFalse);
3235     VARXOR(I2,0,BSTR,rbstr,I2,0);
3236     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3237     rbstr = SysAllocString(szTrue);
3238     VARXOR(I2,0,BSTR,rbstr,I2,-1);
3239     VARXOR(I2,-1,BSTR,rbstr,I2,0);
3240     VARXORCY(I2,-1,10000,I4,-2);
3241     VARXORCY(I2,-1,0,I4,-1);
3242     VARXORCY(I2,0,0,I4,0);
3243
3244     VARXOR(UI2,65535,UI2,65535,I4,0);
3245     VARXOR(UI2,65535,UI2,0,I4,65535);
3246     VARXOR(UI2,0,UI2,0,I4,0);
3247     VARXOR(UI2,65535,I4,-1,I4,-65536);
3248     VARXOR(UI2,65535,I4,0,I4,65535);
3249     VARXOR(UI2,0,I4,0,I4,0);
3250     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3251     VARXOR(UI2,65535,UI4,0,I4,65535);
3252     VARXOR(UI2,0,UI4,0,I4,0);
3253     VARXOR(UI2,65535,R4,-1,I4,-65536);
3254     VARXOR(UI2,65535,R4,0,I4,65535);
3255     VARXOR(UI2,0,R4,0,I4,0);
3256     VARXOR(UI2,65535,R8,-1,I4,-65536);
3257     VARXOR(UI2,65535,R8,0,I4,65535);
3258     VARXOR(UI2,0,R8,0,I4,0);
3259     VARXOR(UI2,65535,DATE,-1,I4,-65536);
3260     VARXOR(UI2,65535,DATE,0,I4,65535);
3261     VARXOR(UI2,0,DATE,0,I4,0);
3262     if (HAVE_OLEAUT32_I8)
3263     {
3264         VARXOR(UI2,65535,I8,-1,I8,-65536);
3265         VARXOR(UI2,65535,I8,0,I8,65535);
3266         VARXOR(UI2,0,I8,0,I8,0);
3267         VARXOR(UI2,65535,UI8,0,I4,65535);
3268         VARXOR(UI2,0,UI8,0,I4,0);
3269     }
3270     VARXOR(UI2,65535,INT,-1,I4,-65536);
3271     VARXOR(UI2,65535,INT,0,I4,65535);
3272     VARXOR(UI2,0,INT,0,I4,0);
3273     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3274     VARXOR(UI2,65535,UINT,0,I4,65535);
3275     VARXOR(UI2,0,UINT,0,I4,0);
3276     rbstr = SysAllocString(szFalse);
3277     VARXOR(UI2,0,BSTR,rbstr,I4,0);
3278     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3279     rbstr = SysAllocString(szTrue);
3280     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3281     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3282     VARXORCY(UI2,65535,10000,I4,65534);
3283     VARXORCY(UI2,65535,0,I4,65535);
3284     VARXORCY(UI2,0,0,I4,0);
3285
3286     VARXOR(I4,-1,I4,-1,I4,0);
3287     VARXOR(I4,-1,I4,0,I4,-1);
3288     VARXOR(I4,0,I4,0,I4,0);
3289     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3290     VARXOR(I4,-1,UI4,0,I4,-1);
3291     VARXOR(I4,0,UI4,0,I4,0);
3292     VARXOR(I4,-1,R4,-1,I4,0);
3293     VARXOR(I4,-1,R4,0,I4,-1);
3294     VARXOR(I4,0,R4,0,I4,0);
3295     VARXOR(I4,-1,R8,-1,I4,0);
3296     VARXOR(I4,-1,R8,0,I4,-1);
3297     VARXOR(I4,0,R8,0,I4,0);
3298     VARXOR(I4,-1,DATE,-1,I4,0);
3299     VARXOR(I4,-1,DATE,0,I4,-1);
3300     VARXOR(I4,0,DATE,0,I4,0);
3301     if (HAVE_OLEAUT32_I8)
3302     {
3303         VARXOR(I4,-1,I8,-1,I8,0);
3304         VARXOR(I4,-1,I8,0,I8,-1);
3305         VARXOR(I4,0,I8,0,I8,0);
3306         VARXOR(I4,-1,UI8,0,I4,-1);
3307         VARXOR(I4,0,UI8,0,I4,0);
3308     }
3309     VARXOR(I4,-1,INT,-1,I4,0);
3310     VARXOR(I4,-1,INT,0,I4,-1);
3311     VARXOR(I4,0,INT,0,I4,0);
3312     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3313     VARXOR(I4,-1,UINT,0,I4,-1);
3314     VARXOR(I4,0,UINT,0,I4,0);
3315     rbstr = SysAllocString(szFalse);
3316     VARXOR(I4,0,BSTR,rbstr,I4,0);
3317     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3318     rbstr = SysAllocString(szTrue);
3319     VARXOR(I4,0,BSTR,rbstr,I4,-1);
3320     VARXOR(I4,-1,BSTR,rbstr,I4,0);
3321     VARXORCY(I4,-1,10000,I4,-2);
3322     VARXORCY(I4,-1,0,I4,-1);
3323     VARXORCY(I4,0,0,I4,0);
3324
3325     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3326     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3327     VARXOR(UI4,0,UI4,0,I4,0);
3328     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3329     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3330     VARXOR(UI4,0,R4,0,I4,0);
3331     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3332     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3333     VARXOR(UI4,0,R8,0,I4,0);
3334     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3335     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3336     VARXOR(UI4,0,DATE,0,I4,0);
3337     if (HAVE_OLEAUT32_I8)
3338     {
3339         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3340         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3341         VARXOR(UI4,0,I8,0,I8,0);
3342         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3343         VARXOR(UI4,0,UI8,0,I4,0);
3344     }
3345     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3346     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3347     VARXOR(UI4,0,INT,0,I4,0);
3348     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3349     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3350     VARXOR(UI4,0,UINT,0,I4,0);
3351     rbstr = SysAllocString(szFalse);
3352     VARXOR(UI4,0,BSTR,rbstr,I4,0);
3353     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3354     rbstr = SysAllocString(szTrue);
3355     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3356     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3357     VARXORCY(UI4,0xffffffff,10000,I4,-2);
3358     VARXORCY(UI4,0xffffffff,0,I4,-1);
3359     VARXORCY(UI4,0,0,I4,0);
3360
3361     VARXOR(R4,-1,R4,-1,I4,0);
3362     VARXOR(R4,-1,R4,0,I4,-1);
3363     VARXOR(R4,0,R4,0,I4,0);
3364     VARXOR(R4,-1,R8,-1,I4,0);
3365     VARXOR(R4,-1,R8,0,I4,-1);
3366     VARXOR(R4,0,R8,0,I4,0);
3367     VARXOR(R4,-1,DATE,-1,I4,0);
3368     VARXOR(R4,-1,DATE,0,I4,-1);
3369     VARXOR(R4,0,DATE,0,I4,0);
3370     if (HAVE_OLEAUT32_I8)
3371     {
3372         VARXOR(R4,-1,I8,-1,I8,0);
3373         VARXOR(R4,-1,I8,0,I8,-1);
3374         VARXOR(R4,0,I8,0,I8,0);
3375         VARXOR(R4,-1,UI8,0,I4,-1);
3376         VARXOR(R4,0,UI8,0,I4,0);
3377     }
3378     VARXOR(R4,-1,INT,-1,I4,0);
3379     VARXOR(R4,-1,INT,0,I4,-1);
3380     VARXOR(R4,0,INT,0,I4,0);
3381     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3382     VARXOR(R4,-1,UINT,0,I4,-1);
3383     VARXOR(R4,0,UINT,0,I4,0);
3384     rbstr = SysAllocString(szFalse);
3385     VARXOR(R4,0,BSTR,rbstr,I4,0);
3386     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3387     rbstr = SysAllocString(szTrue);
3388     VARXOR(R4,0,BSTR,rbstr,I4,-1);
3389     VARXOR(R4,-1,BSTR,rbstr,I4,0);
3390     VARXORCY(R4,-1,10000,I4,-2);
3391     VARXORCY(R4,-1,0,I4,-1);
3392     VARXORCY(R4,0,0,I4,0);
3393
3394     VARXOR(R8,-1,R8,-1,I4,0);
3395     VARXOR(R8,-1,R8,0,I4,-1);
3396     VARXOR(R8,0,R8,0,I4,0);
3397     VARXOR(R8,-1,DATE,-1,I4,0);
3398     VARXOR(R8,-1,DATE,0,I4,-1);
3399     VARXOR(R8,0,DATE,0,I4,0);
3400     if (HAVE_OLEAUT32_I8)
3401     {
3402         VARXOR(R8,-1,I8,-1,I8,0);
3403         VARXOR(R8,-1,I8,0,I8,-1);
3404         VARXOR(R8,0,I8,0,I8,0);
3405         VARXOR(R8,-1,UI8,0,I4,-1);
3406         VARXOR(R8,0,UI8,0,I4,0);
3407     }
3408     VARXOR(R8,-1,INT,-1,I4,0);
3409     VARXOR(R8,-1,INT,0,I4,-1);
3410     VARXOR(R8,0,INT,0,I4,0);
3411     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3412     VARXOR(R8,-1,UINT,0,I4,-1);
3413     VARXOR(R8,0,UINT,0,I4,0);
3414     rbstr = SysAllocString(szFalse);
3415     VARXOR(R8,0,BSTR,rbstr,I4,0);
3416     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3417     rbstr = SysAllocString(szTrue);
3418     VARXOR(R8,0,BSTR,rbstr,I4,-1);
3419     VARXOR(R8,-1,BSTR,rbstr,I4,0);
3420     VARXORCY(R8,-1,10000,I4,-2);
3421     VARXORCY(R8,-1,0,I4,-1);
3422     VARXORCY(R8,0,0,I4,0);
3423
3424     VARXOR(DATE,-1,DATE,-1,I4,0);
3425     VARXOR(DATE,-1,DATE,0,I4,-1);
3426     VARXOR(DATE,0,DATE,0,I4,0);
3427     if (HAVE_OLEAUT32_I8)
3428     {
3429         VARXOR(DATE,-1,I8,-1,I8,0);
3430         VARXOR(DATE,-1,I8,0,I8,-1);
3431         VARXOR(DATE,0,I8,0,I8,0);
3432         VARXOR(DATE,-1,UI8,0,I4,-1);
3433         VARXOR(DATE,0,UI8,0,I4,0);
3434     }
3435     VARXOR(DATE,-1,INT,-1,I4,0);
3436     VARXOR(DATE,-1,INT,0,I4,-1);
3437     VARXOR(DATE,0,INT,0,I4,0);
3438     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3439     VARXOR(DATE,-1,UINT,0,I4,-1);
3440     VARXOR(DATE,0,UINT,0,I4,0);
3441     rbstr = SysAllocString(szFalse);
3442     VARXOR(DATE,0,BSTR,rbstr,I4,0);
3443     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3444     rbstr = SysAllocString(szTrue);
3445     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3446     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3447     VARXORCY(DATE,-1,10000,I4,-2);
3448     VARXORCY(DATE,-1,0,I4,-1);
3449     VARXORCY(DATE,0,0,I4,0);
3450
3451     if (HAVE_OLEAUT32_I8)
3452     {
3453         VARXOR(I8,-1,I8,-1,I8,0);
3454         VARXOR(I8,-1,I8,0,I8,-1);
3455         VARXOR(I8,0,I8,0,I8,0);
3456         VARXOR(I8,-1,UI8,0,I8,-1);
3457         VARXOR(I8,0,UI8,0,I8,0);
3458         VARXOR(I8,-1,UINT,0,I8,-1);
3459         VARXOR(I8,0,UINT,0,I8,0);
3460         rbstr = SysAllocString(szFalse);
3461         VARXOR(I8,0,BSTR,rbstr,I8,0);
3462         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
3463         rbstr = SysAllocString(szTrue);
3464         VARXOR(I8,0,BSTR,rbstr,I8,-1);
3465         VARXOR(I8,-1,BSTR,rbstr,I8,0);
3466         VARXORCY(I8,-1,10000,I8,-2);
3467         VARXORCY(I8,-1,0,I8,-1);
3468         VARXORCY(I8,0,0,I8,0);
3469
3470         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
3471         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
3472         VARXOR(UI8,0,UI8,0,I4,0);
3473         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
3474         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
3475         VARXOR(UI8,0,INT,0,I4,0);
3476         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
3477         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
3478         VARXOR(UI8,0,UINT,0,I4,0);
3479         rbstr = SysAllocString(szFalse);
3480         VARXOR(UI8,0,BSTR,rbstr,I4,0);
3481         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
3482         rbstr = SysAllocString(szTrue);
3483         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
3484         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
3485         VARXORCY(UI8,0xffff,10000,I4,65534);
3486         VARXORCY(UI8,0xffff,0,I4,0xffff);
3487         VARXORCY(UI8,0,0,I4,0);
3488     }
3489
3490     VARXOR(INT,-1,INT,-1,I4,0);
3491     VARXOR(INT,-1,INT,0,I4,-1);
3492     VARXOR(INT,0,INT,0,I4,0);
3493     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
3494     VARXOR(INT,-1,UINT,0,I4,-1);
3495     VARXOR(INT,0,UINT,0,I4,0);
3496     rbstr = SysAllocString(szFalse);
3497     VARXOR(INT,0,BSTR,rbstr,I4,0);
3498     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
3499     rbstr = SysAllocString(szTrue);
3500     VARXOR(INT,0,BSTR,rbstr,I4,-1);
3501     VARXOR(INT,-1,BSTR,rbstr,I4,0);
3502     VARXORCY(INT,-1,10000,I4,-2);
3503     VARXORCY(INT,-1,0,I4,-1);
3504     VARXORCY(INT,0,0,I4,0);
3505
3506     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
3507     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
3508     VARXOR(UINT,0,UINT,0,I4,0);
3509     rbstr = SysAllocString(szFalse);
3510     VARXOR(UINT,0,BSTR,rbstr,I4,0);
3511     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
3512     rbstr = SysAllocString(szTrue);
3513     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
3514     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
3515     VARXORCY(UINT,0xffff,10000,I4,65534);
3516     VARXORCY(UINT,0xffff,0,I4,0xffff);
3517     VARXORCY(UINT,0,0,I4,0);
3518
3519     lbstr = SysAllocString(szFalse);
3520     rbstr = SysAllocString(szFalse);
3521     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
3522     rbstr = SysAllocString(szTrue);
3523     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
3524     lbstr = SysAllocString(szTrue);
3525     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
3526     VARXORCY(BSTR,lbstr,10000,I4,-2);
3527     lbstr = SysAllocString(szFalse);
3528     VARXORCY(BSTR,lbstr,10000,I4,1);
3529 }
3530
3531 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
3532
3533 static const char *szVarOrFail = "VarOr(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
3534 static const char *szVarOrChanged = "VarOr(%d,%d): Modified input arguments\n";
3535 #define VAROR(vt1,val1,vt2,val2,rvt,rval) \
3536         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3537         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3538         memset(&result,0,sizeof(result)); hres = pVarOr(&left,&right,&result); \
3539         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3540         szVarOrFail, VT_##vt1, VT_##vt2, \
3541         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3542         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3543            V_VT(&right) == VT_##vt2 && V_##vt2(&right) == val2, \
3544            szVarOrChanged,VT_##vt1,VT_##vt2)
3545 #define VARORCY(vt1,val1,val2,rvt,rval) \
3546         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3547         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3548         memset(&result,0,sizeof(result)); hres = pVarOr(&left,&right,&result); \
3549         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
3550         "VarOr(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n", VT_##vt1, VT_CY, \
3551         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result)); \
3552         ok(V_VT(&left) == VT_##vt1 && V_##vt1(&left) == val1 && \
3553            V_VT(&right) == VT_CY && V_CY(&right).int64 == val2, \
3554            "VarOr(%d,%d): Modified input arguments\n",VT_##vt1,VT_CY)
3555
3556 static void test_VarOr(void)
3557 {
3558     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3559     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3560     VARIANT left, right, result;
3561     BSTR lbstr, rbstr;
3562     VARTYPE i;
3563     HRESULT hres;
3564
3565     CHECKPTR(VarOr);
3566
3567     /* Test all possible flag/vt combinations & the resulting vt type */
3568     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3569     {
3570         VARTYPE leftvt, rightvt, resvt;
3571
3572         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3573         {
3574
3575             SKIPTESTS(leftvt);
3576
3577             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3578             {
3579                 BOOL bFail = FALSE;
3580
3581                 SKIPTESTS(rightvt);
3582
3583                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3584                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3585                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3586                     continue;
3587
3588                 memset(&left, 0, sizeof(left));
3589                 memset(&right, 0, sizeof(right));
3590                 V_VT(&left) = leftvt | ExtraFlags[i];
3591                 V_VT(&right) = rightvt | ExtraFlags[i];
3592                 V_VT(&result) = VT_EMPTY;
3593                 resvt = VT_I4;
3594
3595                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3596                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3597                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3598                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3599                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
3600                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3601                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3602                 {
3603                     bFail = TRUE;
3604                 }
3605                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3606                 {
3607                     if (leftvt == rightvt ||
3608                         leftvt == VT_I2 || rightvt == VT_I2 ||
3609                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
3610                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3611                         resvt = VT_I2;
3612                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
3613                         resvt = VT_NULL;
3614                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3615                         resvt = VT_I8;
3616                 }
3617                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3618                 {
3619                     resvt = VT_NULL;
3620                 }
3621                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3622                 {
3623                     if (leftvt == rightvt)
3624                         resvt = VT_UI1;
3625                     else if (leftvt == rightvt ||
3626                         leftvt == VT_I2 || rightvt == VT_I2 ||
3627                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3628                     {
3629                         resvt = VT_I2;
3630                     }
3631                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3632                         resvt = VT_I8;
3633                 }
3634                 else if (leftvt == VT_I2 || rightvt == VT_I2)
3635                 {
3636                     if (leftvt == rightvt ||
3637                         leftvt == VT_BOOL || rightvt == VT_BOOL)
3638                         resvt = VT_I2;
3639                     else if (leftvt == VT_I8 || rightvt == VT_I8)
3640                         resvt = VT_I8;
3641                 }
3642                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3643                 {
3644                     resvt = VT_BOOL;
3645                 }
3646                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3647                 {
3648                     if (leftvt == VT_INT || rightvt == VT_INT)
3649                         bFail = TRUE;
3650                     else
3651                         resvt = VT_I8;
3652                 }
3653                 hres = pVarOr(&left, &right, &result);
3654                 if (bFail)
3655                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3656                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
3657                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3658                        V_VT(&result));
3659                 else
3660                     ok(hres == S_OK && V_VT(&result) == resvt,
3661                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
3662                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3663                        V_VT(&result));
3664             }
3665         }
3666     }
3667
3668     /* Test returned values. Since we know the returned type is correct
3669      * and that we handle all combinations of invalid types, just check
3670      * that good type combinations produce the desired value.
3671      * FIXME: Test VT_DECIMAL/VT_DISPATCH
3672      */
3673     VAROR(EMPTY,0,EMPTY,0,I2,0);
3674     VAROR(EMPTY,1,EMPTY,0,I2,0);
3675     VAROR(EMPTY,0,NULL,0,NULL,0);
3676     VAROR(EMPTY,0,I1,0,I4,0);
3677     VAROR(EMPTY,0,I1,1,I4,1);
3678     VAROR(EMPTY,0,UI1,0,I2,0);
3679     VAROR(EMPTY,0,UI1,1,I2,1);
3680     VAROR(EMPTY,0,I2,0,I2,0);
3681     VAROR(EMPTY,0,I2,1,I2,1);
3682     VAROR(EMPTY,0,UI2,0,I4,0);
3683     VAROR(EMPTY,0,UI2,1,I4,1);
3684     VAROR(EMPTY,0,I4,0,I4,0);
3685     VAROR(EMPTY,0,I4,1,I4,1);
3686     VAROR(EMPTY,0,UI4,0,I4,0);
3687     VAROR(EMPTY,0,UI4,1,I4,1);
3688     if (HAVE_OLEAUT32_I8)
3689     {
3690         VAROR(EMPTY,0,I8,0,I8,0);
3691         VAROR(EMPTY,0,I8,1,I8,1);
3692         VAROR(EMPTY,0,UI8,0,I4,0);
3693         VAROR(EMPTY,0,UI8,1,I4,1);
3694     }
3695     VAROR(EMPTY,0,INT,0,I4,0);
3696     VAROR(EMPTY,0,INT,1,I4,1);
3697     VAROR(EMPTY,0,UINT,0,I4,0);
3698     VAROR(EMPTY,0,UINT,1,I4,1);
3699     VAROR(EMPTY,0,BOOL,0,I2,0);
3700     VAROR(EMPTY,0,BOOL,1,I2,1);
3701     VAROR(EMPTY,0,R4,0,I4,0);
3702     VAROR(EMPTY,0,R4,1,I4,1);
3703     VAROR(EMPTY,0,R8,0,I4,0);
3704     VAROR(EMPTY,0,R8,1,I4,1);
3705     rbstr = SysAllocString(szFalse);
3706     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
3707     rbstr = SysAllocString(szTrue);
3708     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
3709     VARORCY(EMPTY,0,10000,I4,1);
3710
3711     /* NULL OR 0 = NULL. NULL OR n = n */
3712     VAROR(NULL,0,NULL,0,NULL,0);
3713     VAROR(NULL,1,NULL,0,NULL,0);
3714     VAROR(NULL,0,I1,0,NULL,0);
3715     VAROR(NULL,0,I1,1,I4,1);
3716     VAROR(NULL,0,UI1,0,NULL,0);
3717     VAROR(NULL,0,UI1,1,UI1,1);
3718     VAROR(NULL,0,I2,0,NULL,0);
3719     VAROR(NULL,0,I2,1,I2,1);
3720     VAROR(NULL,0,UI2,0,NULL,0);
3721     VAROR(NULL,0,UI2,1,I4,1);
3722     VAROR(NULL,0,I4,0,NULL,0);
3723     VAROR(NULL,0,I4,1,I4,1);
3724     VAROR(NULL,0,UI4,0,NULL,0);
3725     VAROR(NULL,0,UI4,1,I4,1);
3726     if (HAVE_OLEAUT32_I8)
3727     {
3728         VAROR(NULL,0,I8,0,NULL,0);
3729         VAROR(NULL,0,I8,1,I8,1);
3730         VAROR(NULL,0,UI8,0,NULL,0);
3731         VAROR(NULL,0,UI8,1,I4,1);
3732     }
3733     VAROR(NULL,0,INT,0,NULL,0);
3734     VAROR(NULL,0,INT,1,I4,1);
3735     VAROR(NULL,0,UINT,0,NULL,0);
3736     VAROR(NULL,0,UINT,1,I4,1);
3737     VAROR(NULL,0,BOOL,0,NULL,0);
3738     VAROR(NULL,0,BOOL,1,BOOL,1);
3739     VAROR(NULL,0,R4,0,NULL,0);
3740     VAROR(NULL,0,R4,1,I4,1);
3741     VAROR(NULL,0,R8,0,NULL,0);
3742     VAROR(NULL,0,R8,1,I4,1);
3743     rbstr = SysAllocString(szFalse);
3744     VAROR(NULL,0,BSTR,rbstr,NULL,0);
3745     rbstr = SysAllocString(szTrue);
3746     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
3747     VARORCY(NULL,0,10000,I4,1);
3748     VARORCY(NULL,0,0,NULL,0);
3749
3750     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3751     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3752     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3753     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3754     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3755     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
3756     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3757     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3758     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
3759     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3760     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3761     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
3762     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3763     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3764     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
3765     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3766     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3767     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
3768     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3769     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3770     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
3771     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3772     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3773     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
3774     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3775     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3776     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
3777     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3778     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3779     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
3780     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3781     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3782     if (HAVE_OLEAUT32_I8)
3783     {
3784         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
3785         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3786         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3787         /* This returns DISP_E_OVERFLOW which indicates that a conversion
3788          * to I4 is performed.
3789          */
3790         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3791         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3792         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3793     }
3794     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
3795     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3796     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3797     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
3798     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3799     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3800     rbstr = SysAllocString(szFalse);
3801     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3802     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3803     rbstr = SysAllocString(szTrue);
3804     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3805     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3806     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
3807     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3808     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
3809
3810     VAROR(I1,-1,I1,-1,I4,-1);
3811     VAROR(I1,-1,I1,0,I4,-1);
3812     VAROR(I1,0,I1,0,I4,0);
3813     VAROR(I1,-1,UI1,255,I4,-1);
3814     VAROR(I1,-1,UI1,0,I4,-1);
3815     VAROR(I1,0,UI1,0,I4,0);
3816     VAROR(I1,-1,I2,-1,I4,-1);
3817     VAROR(I1,-1,I2,0,I4,-1);
3818     VAROR(I1,0,I2,0,I4,0);
3819     VAROR(I1,-1,UI2,65535,I4,-1);
3820     VAROR(I1,-1,UI2,0,I4,-1);
3821     VAROR(I1,0,UI2,0,I4,0);
3822     VAROR(I1,-1,I4,-1,I4,-1);
3823     VAROR(I1,-1,I4,0,I4,-1);
3824     VAROR(I1,0,I4,0,I4,0);
3825     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
3826     VAROR(I1,-1,UI4,0,I4,-1);
3827     VAROR(I1,0,UI4,0,I4,0);
3828     VAROR(I1,-1,R4,-1,I4,-1);
3829     VAROR(I1,-1,R4,0,I4,-1);
3830     VAROR(I1,0,R4,0,I4,0);
3831     VAROR(I1,-1,R8,-1,I4,-1);
3832     VAROR(I1,-1,R8,0,I4,-1);
3833     VAROR(I1,0,R8,0,I4,0);
3834     VAROR(I1,-1,DATE,-1,I4,-1);
3835     VAROR(I1,-1,DATE,0,I4,-1);
3836     VAROR(I1,0,DATE,0,I4,0);
3837     if (HAVE_OLEAUT32_I8)
3838     {
3839         VAROR(I1,-1,I8,-1,I8,-1);
3840         VAROR(I1,-1,I8,0,I8,-1);
3841         VAROR(I1,0,I8,0,I8,0);
3842         VAROR(I1,-1,UI8,0,I4,-1);
3843         VAROR(I1,0,UI8,0,I4,0);
3844     }
3845     VAROR(I1,-1,INT,-1,I4,-1);
3846     VAROR(I1,-1,INT,0,I4,-1);
3847     VAROR(I1,0,INT,0,I4,0);
3848     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
3849     VAROR(I1,-1,UINT,0,I4,-1);
3850     VAROR(I1,0,UINT,0,I4,0);
3851     rbstr = SysAllocString(szFalse);
3852     VAROR(I1,0,BSTR,rbstr,I4,0);
3853     VAROR(I1,-1,BSTR,rbstr,I4,-1);
3854     rbstr = SysAllocString(szTrue);
3855     VAROR(I1,0,BSTR,rbstr,I4,-1);
3856     VAROR(I1,-1,BSTR,rbstr,I4,-1);
3857     VARORCY(I1,-1,10000,I4,-1);
3858     VARORCY(I1,-1,0,I4,-1);
3859     VARORCY(I1,0,0,I4,0);
3860
3861     VAROR(UI1,255,UI1,255,UI1,255);
3862     VAROR(UI1,255,UI1,0,UI1,255);
3863     VAROR(UI1,0,UI1,0,UI1,0);
3864     VAROR(UI1,255,I2,-1,I2,-1);
3865     VAROR(UI1,255,I2,0,I2,255);
3866     VAROR(UI1,0,I2,0,I2,0);
3867     VAROR(UI1,255,UI2,65535,I4,65535);
3868     VAROR(UI1,255,UI2,0,I4,255);
3869     VAROR(UI1,0,UI2,0,I4,0);
3870     VAROR(UI1,255,I4,-1,I4,-1);
3871     VAROR(UI1,255,I4,0,I4,255);
3872     VAROR(UI1,0,I4,0,I4,0);
3873     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
3874     VAROR(UI1,255,UI4,0,I4,255);
3875     VAROR(UI1,0,UI4,0,I4,0);
3876     VAROR(UI1,255,R4,-1,I4,-1);
3877     VAROR(UI1,255,R4,0,I4,255);
3878     VAROR(UI1,0,R4,0,I4,0);
3879     VAROR(UI1,255,R8,-1,I4,-1);
3880     VAROR(UI1,255,R8,0,I4,255);
3881     VAROR(UI1,0,R8,0,I4,0);
3882     VAROR(UI1,255,DATE,-1,I4,-1);
3883     VAROR(UI1,255,DATE,0,I4,255);
3884     VAROR(UI1,0,DATE,0,I4,0);
3885     if (HAVE_OLEAUT32_I8)
3886     {
3887         VAROR(UI1,255,I8,-1,I8,-1);
3888         VAROR(UI1,255,I8,0,I8,255);
3889         VAROR(UI1,0,I8,0,I8,0);
3890         VAROR(UI1,255,UI8,0,I4,255);
3891         VAROR(UI1,0,UI8,0,I4,0);
3892     }
3893     VAROR(UI1,255,INT,-1,I4,-1);
3894     VAROR(UI1,255,INT,0,I4,255);
3895     VAROR(UI1,0,INT,0,I4,0);
3896     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
3897     VAROR(UI1,255,UINT,0,I4,255);
3898     VAROR(UI1,0,UINT,0,I4,0);
3899     rbstr = SysAllocString(szFalse);
3900     VAROR(UI1,0,BSTR,rbstr,I2,0);
3901     VAROR(UI1,255,BSTR,rbstr,I2,255);
3902     rbstr = SysAllocString(szTrue);
3903     VAROR(UI1,0,BSTR,rbstr,I2,-1);
3904     VAROR(UI1,255,BSTR,rbstr,I2,-1);
3905     VARORCY(UI1,255,10000,I4,255);
3906     VARORCY(UI1,255,0,I4,255);
3907     VARORCY(UI1,0,0,I4,0);
3908
3909     VAROR(I2,-1,I2,-1,I2,-1);
3910     VAROR(I2,-1,I2,0,I2,-1);
3911     VAROR(I2,0,I2,0,I2,0);
3912     VAROR(I2,-1,UI2,65535,I4,-1);
3913     VAROR(I2,-1,UI2,0,I4,-1);
3914     VAROR(I2,0,UI2,0,I4,0);
3915     VAROR(I2,-1,I4,-1,I4,-1);
3916     VAROR(I2,-1,I4,0,I4,-1);
3917     VAROR(I2,0,I4,0,I4,0);
3918     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
3919     VAROR(I2,-1,UI4,0,I4,-1);
3920     VAROR(I2,0,UI4,0,I4,0);
3921     VAROR(I2,-1,R4,-1,I4,-1);
3922     VAROR(I2,-1,R4,0,I4,-1);
3923     VAROR(I2,0,R4,0,I4,0);
3924     VAROR(I2,-1,R8,-1,I4,-1);
3925     VAROR(I2,-1,R8,0,I4,-1);
3926     VAROR(I2,0,R8,0,I4,0);
3927     VAROR(I2,-1,DATE,-1,I4,-1);
3928     VAROR(I2,-1,DATE,0,I4,-1);
3929     VAROR(I2,0,DATE,0,I4,0);
3930     if (HAVE_OLEAUT32_I8)
3931     {
3932         VAROR(I2,-1,I8,-1,I8,-1);
3933         VAROR(I2,-1,I8,0,I8,-1);
3934         VAROR(I2,0,I8,0,I8,0);
3935         VAROR(I2,-1,UI8,0,I4,-1);
3936         VAROR(I2,0,UI8,0,I4,0);
3937     }
3938     VAROR(I2,-1,INT,-1,I4,-1);
3939     VAROR(I2,-1,INT,0,I4,-1);
3940     VAROR(I2,0,INT,0,I4,0);
3941     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
3942     VAROR(I2,-1,UINT,0,I4,-1);
3943     VAROR(I2,0,UINT,0,I4,0);
3944     rbstr = SysAllocString(szFalse);
3945     VAROR(I2,0,BSTR,rbstr,I2,0);
3946     VAROR(I2,-1,BSTR,rbstr,I2,-1);
3947     rbstr = SysAllocString(szTrue);
3948     VAROR(I2,0,BSTR,rbstr,I2,-1);
3949     VAROR(I2,-1,BSTR,rbstr,I2,-1);
3950     VARORCY(I2,-1,10000,I4,-1);
3951     VARORCY(I2,-1,0,I4,-1);
3952     VARORCY(I2,0,0,I4,0);
3953
3954     VAROR(UI2,65535,UI2,65535,I4,65535);
3955     VAROR(UI2,65535,UI2,0,I4,65535);
3956     VAROR(UI2,0,UI2,0,I4,0);
3957     VAROR(UI2,65535,I4,-1,I4,-1);
3958     VAROR(UI2,65535,I4,0,I4,65535);
3959     VAROR(UI2,0,I4,0,I4,0);
3960     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
3961     VAROR(UI2,65535,UI4,0,I4,65535);
3962     VAROR(UI2,0,UI4,0,I4,0);
3963     VAROR(UI2,65535,R4,-1,I4,-1);
3964     VAROR(UI2,65535,R4,0,I4,65535);
3965     VAROR(UI2,0,R4,0,I4,0);
3966     VAROR(UI2,65535,R8,-1,I4,-1);
3967     VAROR(UI2,65535,R8,0,I4,65535);
3968     VAROR(UI2,0,R8,0,I4,0);
3969     VAROR(UI2,65535,DATE,-1,I4,-1);
3970     VAROR(UI2,65535,DATE,0,I4,65535);
3971     VAROR(UI2,0,DATE,0,I4,0);
3972     if (HAVE_OLEAUT32_I8)
3973     {
3974         VAROR(UI2,65535,I8,-1,I8,-1);
3975         VAROR(UI2,65535,I8,0,I8,65535);
3976         VAROR(UI2,0,I8,0,I8,0);
3977         VAROR(UI2,65535,UI8,0,I4,65535);
3978         VAROR(UI2,0,UI8,0,I4,0);
3979     }
3980     VAROR(UI2,65535,INT,-1,I4,-1);
3981     VAROR(UI2,65535,INT,0,I4,65535);
3982     VAROR(UI2,0,INT,0,I4,0);
3983     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
3984     VAROR(UI2,65535,UINT,0,I4,65535);
3985     VAROR(UI2,0,UINT,0,I4,0);
3986     rbstr = SysAllocString(szFalse);
3987     VAROR(UI2,0,BSTR,rbstr,I4,0);
3988     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
3989     rbstr = SysAllocString(szTrue);
3990     VAROR(UI2,0,BSTR,rbstr,I4,-1);
3991     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
3992     VARORCY(UI2,65535,10000,I4,65535);
3993     VARORCY(UI2,65535,0,I4,65535);
3994     VARORCY(UI2,0,0,I4,0);
3995
3996     VAROR(I4,-1,I4,-1,I4,-1);
3997     VAROR(I4,-1,I4,0,I4,-1);
3998     VAROR(I4,0,I4,0,I4,0);
3999     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4000     VAROR(I4,-1,UI4,0,I4,-1);
4001     VAROR(I4,0,UI4,0,I4,0);
4002     VAROR(I4,-1,R4,-1,I4,-1);
4003     VAROR(I4,-1,R4,0,I4,-1);
4004     VAROR(I4,0,R4,0,I4,0);
4005     VAROR(I4,-1,R8,-1,I4,-1);
4006     VAROR(I4,-1,R8,0,I4,-1);
4007     VAROR(I4,0,R8,0,I4,0);
4008     VAROR(I4,-1,DATE,-1,I4,-1);
4009     VAROR(I4,-1,DATE,0,I4,-1);
4010     VAROR(I4,0,DATE,0,I4,0);
4011     if (HAVE_OLEAUT32_I8)
4012     {
4013         VAROR(I4,-1,I8,-1,I8,-1);
4014         VAROR(I4,-1,I8,0,I8,-1);
4015         VAROR(I4,0,I8,0,I8,0);
4016         VAROR(I4,-1,UI8,0,I4,-1);
4017         VAROR(I4,0,UI8,0,I4,0);
4018     }
4019     VAROR(I4,-1,INT,-1,I4,-1);
4020     VAROR(I4,-1,INT,0,I4,-1);
4021     VAROR(I4,0,INT,0,I4,0);
4022     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4023     VAROR(I4,-1,UINT,0,I4,-1);
4024     VAROR(I4,0,UINT,0,I4,0);
4025     rbstr = SysAllocString(szFalse);
4026     VAROR(I4,0,BSTR,rbstr,I4,0);
4027     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4028     rbstr = SysAllocString(szTrue);
4029     VAROR(I4,0,BSTR,rbstr,I4,-1);
4030     VAROR(I4,-1,BSTR,rbstr,I4,-1);
4031     VARORCY(I4,-1,10000,I4,-1);
4032     VARORCY(I4,-1,0,I4,-1);
4033     VARORCY(I4,0,0,I4,0);
4034
4035     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4036     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4037     VAROR(UI4,0,UI4,0,I4,0);
4038     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4039     VAROR(UI4,0xffffffff,R4,0,I4,-1);
4040     VAROR(UI4,0,R4,0,I4,0);
4041     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4042     VAROR(UI4,0xffffffff,R8,0,I4,-1);
4043     VAROR(UI4,0,R8,0,I4,0);
4044     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4045     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4046     VAROR(UI4,0,DATE,0,I4,0);
4047     if (HAVE_OLEAUT32_I8)
4048     {
4049         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4050         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4051         VAROR(UI4,0,I8,0,I8,0);
4052         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4053         VAROR(UI4,0,UI8,0,I4,0);
4054     }
4055     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4056     VAROR(UI4,0xffffffff,INT,0,I4,-1);
4057     VAROR(UI4,0,INT,0,I4,0);
4058     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4059     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4060     VAROR(UI4,0,UINT,0,I4,0);
4061     rbstr = SysAllocString(szFalse);
4062     VAROR(UI4,0,BSTR,rbstr,I4,0);
4063     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4064     rbstr = SysAllocString(szTrue);
4065     VAROR(UI4,0,BSTR,rbstr,I4,-1);
4066     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4067     VARORCY(UI4,0xffffffff,10000,I4,-1);
4068     VARORCY(UI4,0xffffffff,0,I4,-1);
4069     VARORCY(UI4,0,0,I4,0);
4070
4071     VAROR(R4,-1,R4,-1,I4,-1);
4072     VAROR(R4,-1,R4,0,I4,-1);
4073     VAROR(R4,0,R4,0,I4,0);
4074     VAROR(R4,-1,R8,-1,I4,-1);
4075     VAROR(R4,-1,R8,0,I4,-1);
4076     VAROR(R4,0,R8,0,I4,0);
4077     VAROR(R4,-1,DATE,-1,I4,-1);
4078     VAROR(R4,-1,DATE,0,I4,-1);
4079     VAROR(R4,0,DATE,0,I4,0);
4080     if (HAVE_OLEAUT32_I8)
4081     {
4082         VAROR(R4,-1,I8,-1,I8,-1);
4083         VAROR(R4,-1,I8,0,I8,-1);
4084         VAROR(R4,0,I8,0,I8,0);
4085         VAROR(R4,-1,UI8,0,I4,-1);
4086         VAROR(R4,0,UI8,0,I4,0);
4087     }
4088     VAROR(R4,-1,INT,-1,I4,-1);
4089     VAROR(R4,-1,INT,0,I4,-1);
4090     VAROR(R4,0,INT,0,I4,0);
4091     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4092     VAROR(R4,-1,UINT,0,I4,-1);
4093     VAROR(R4,0,UINT,0,I4,0);
4094     rbstr = SysAllocString(szFalse);
4095     VAROR(R4,0,BSTR,rbstr,I4,0);
4096     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4097     rbstr = SysAllocString(szTrue);
4098     VAROR(R4,0,BSTR,rbstr,I4,-1);
4099     VAROR(R4,-1,BSTR,rbstr,I4,-1);
4100     VARORCY(R4,-1,10000,I4,-1);
4101     VARORCY(R4,-1,0,I4,-1);
4102     VARORCY(R4,0,0,I4,0);
4103
4104     VAROR(R8,-1,R8,-1,I4,-1);
4105     VAROR(R8,-1,R8,0,I4,-1);
4106     VAROR(R8,0,R8,0,I4,0);
4107     VAROR(R8,-1,DATE,-1,I4,-1);
4108     VAROR(R8,-1,DATE,0,I4,-1);
4109     VAROR(R8,0,DATE,0,I4,0);
4110     if (HAVE_OLEAUT32_I8)
4111     {
4112         VAROR(R8,-1,I8,-1,I8,-1);
4113         VAROR(R8,-1,I8,0,I8,-1);
4114         VAROR(R8,0,I8,0,I8,0);
4115         VAROR(R8,-1,UI8,0,I4,-1);
4116         VAROR(R8,0,UI8,0,I4,0);
4117     }
4118     VAROR(R8,-1,INT,-1,I4,-1);
4119     VAROR(R8,-1,INT,0,I4,-1);
4120     VAROR(R8,0,INT,0,I4,0);
4121     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4122     VAROR(R8,-1,UINT,0,I4,-1);
4123     VAROR(R8,0,UINT,0,I4,0);
4124     rbstr = SysAllocString(szFalse);
4125     VAROR(R8,0,BSTR,rbstr,I4,0);
4126     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4127     rbstr = SysAllocString(szTrue);
4128     VAROR(R8,0,BSTR,rbstr,I4,-1);
4129     VAROR(R8,-1,BSTR,rbstr,I4,-1);
4130     VARORCY(R8,-1,10000,I4,-1);
4131     VARORCY(R8,-1,0,I4,-1);
4132     VARORCY(R8,0,0,I4,0);
4133
4134     VAROR(DATE,-1,DATE,-1,I4,-1);
4135     VAROR(DATE,-1,DATE,0,I4,-1);
4136     VAROR(DATE,0,DATE,0,I4,0);
4137     if (HAVE_OLEAUT32_I8)
4138     {
4139         VAROR(DATE,-1,I8,-1,I8,-1);
4140         VAROR(DATE,-1,I8,0,I8,-1);
4141         VAROR(DATE,0,I8,0,I8,0);
4142         VAROR(DATE,-1,UI8,0,I4,-1);
4143         VAROR(DATE,0,UI8,0,I4,0);
4144     }
4145     VAROR(DATE,-1,INT,-1,I4,-1);
4146     VAROR(DATE,-1,INT,0,I4,-1);
4147     VAROR(DATE,0,INT,0,I4,0);
4148     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4149     VAROR(DATE,-1,UINT,0,I4,-1);
4150     VAROR(DATE,0,UINT,0,I4,0);
4151     rbstr = SysAllocString(szFalse);
4152     VAROR(DATE,0,BSTR,rbstr,I4,0);
4153     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4154     rbstr = SysAllocString(szTrue);
4155     VAROR(DATE,0,BSTR,rbstr,I4,-1);
4156     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4157     VARORCY(DATE,-1,10000,I4,-1);
4158     VARORCY(DATE,-1,0,I4,-1);
4159     VARORCY(DATE,0,0,I4,0);
4160
4161     if (HAVE_OLEAUT32_I8)
4162     {
4163         VAROR(I8,-1,I8,-1,I8,-1);
4164         VAROR(I8,-1,I8,0,I8,-1);
4165         VAROR(I8,0,I8,0,I8,0);
4166         VAROR(I8,-1,UI8,0,I8,-1);
4167         VAROR(I8,0,UI8,0,I8,0);
4168         /* These overflow under native and Wine
4169         VAROR(I8,-1,INT,-1,I4,-1);
4170         VAROR(I8,-1,INT,0,I4,-1);
4171         VAROR(I8,0,INT,0,I4,0); */
4172         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4173         VAROR(I8,-1,UINT,0,I8,-1);
4174         VAROR(I8,0,UINT,0,I8,0);
4175         rbstr = SysAllocString(szFalse);
4176         VAROR(I8,0,BSTR,rbstr,I8,0);
4177         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4178         rbstr = SysAllocString(szTrue);
4179         VAROR(I8,0,BSTR,rbstr,I8,-1);
4180         VAROR(I8,-1,BSTR,rbstr,I8,-1);
4181         VARORCY(I8,-1,10000,I8,-1);
4182         VARORCY(I8,-1,0,I8,-1);
4183         VARORCY(I8,0,0,I8,0);
4184
4185         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4186         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4187         VAROR(UI8,0,UI8,0,I4,0);
4188         VAROR(UI8,0xffff,INT,-1,I4,-1);
4189         VAROR(UI8,0xffff,INT,0,I4,0xffff);
4190         VAROR(UI8,0,INT,0,I4,0);
4191         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4192         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4193         VAROR(UI8,0,UINT,0,I4,0);
4194         rbstr = SysAllocString(szFalse);
4195         VAROR(UI8,0,BSTR,rbstr,I4,0);
4196         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4197         rbstr = SysAllocString(szTrue);
4198         VAROR(UI8,0,BSTR,rbstr,I4,-1);
4199         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4200         VARORCY(UI8,0xffff,10000,I4,0xffff);
4201         VARORCY(UI8,0xffff,0,I4,0xffff);
4202         VARORCY(UI8,0,0,I4,0);
4203     }
4204
4205     VAROR(INT,-1,INT,-1,I4,-1);
4206     VAROR(INT,-1,INT,0,I4,-1);
4207     VAROR(INT,0,INT,0,I4,0);
4208     VAROR(INT,-1,UINT,0xffff,I4,-1);
4209     VAROR(INT,-1,UINT,0,I4,-1);
4210     VAROR(INT,0,UINT,0,I4,0);
4211     rbstr = SysAllocString(szFalse);
4212     VAROR(INT,0,BSTR,rbstr,I4,0);
4213     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4214     rbstr = SysAllocString(szTrue);
4215     VAROR(INT,0,BSTR,rbstr,I4,-1);
4216     VAROR(INT,-1,BSTR,rbstr,I4,-1);
4217     VARORCY(INT,-1,10000,I4,-1);
4218     VARORCY(INT,-1,0,I4,-1);
4219     VARORCY(INT,0,0,I4,0);
4220
4221     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4222     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4223     VAROR(UINT,0,UINT,0,I4,0);
4224     rbstr = SysAllocString(szFalse);
4225     VAROR(UINT,0,BSTR,rbstr,I4,0);
4226     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4227     rbstr = SysAllocString(szTrue);
4228     VAROR(UINT,0,BSTR,rbstr,I4,-1);
4229     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4230     VARORCY(UINT,0xffff,10000,I4,0xffff);
4231     VARORCY(UINT,0xffff,0,I4,0xffff);
4232     VARORCY(UINT,0,0,I4,0);
4233
4234     lbstr = SysAllocString(szFalse);
4235     rbstr = SysAllocString(szFalse);
4236     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4237     rbstr = SysAllocString(szTrue);
4238     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4239     lbstr = SysAllocString(szTrue);
4240     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4241     VARORCY(BSTR,lbstr,10000,I4,-1);
4242     lbstr = SysAllocString(szFalse);
4243     VARORCY(BSTR,lbstr,10000,I4,1);
4244 }
4245
4246 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4247
4248 static const char *szVarEqvFail = "VarEqv(%d,%d): expected 0x0,%d,%d, got 0x%lX,%d,%d\n";
4249 #define VAREQV(vt1,val1,vt2,val2,rvt,rval) \
4250         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4251         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4252         memset(&result,0,sizeof(result)); hres = pVarEqv(&left,&right,&result); \
4253         ok(hres == S_OK && V_VT(&result) == VT_##rvt && V_##rvt(&result) == (rval), \
4254         szVarEqvFail, VT_##vt1, VT_##vt2, \
4255         VT_##rvt, (int)(rval), hres, V_VT(&result), (int)V_##rvt(&result))
4256
4257 static void test_VarEqv(void)
4258 {
4259     VARIANT left, right, result;
4260     VARTYPE i;
4261     HRESULT hres;
4262
4263     CHECKPTR(VarEqv);
4264
4265     /* Test all possible flag/vt combinations & the resulting vt type */
4266     for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4267     {
4268         VARTYPE leftvt, rightvt, resvt;
4269
4270         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4271         {
4272             SKIPTESTS(leftvt);
4273
4274             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4275             {
4276                 BOOL bFail = FALSE;
4277
4278                 SKIPTESTS(rightvt);
4279
4280                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4281                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4282                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4283                     continue;
4284
4285                 memset(&left, 0, sizeof(left));
4286                 memset(&right, 0, sizeof(right));
4287                 V_VT(&left) = leftvt | ExtraFlags[i];
4288                 V_VT(&right) = rightvt | ExtraFlags[i];
4289                 V_VT(&result) = VT_EMPTY;
4290                 resvt = VT_I4;
4291
4292                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4293                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4294                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4295                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4296                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4297                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4298                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4299                 {
4300                     bFail = TRUE;
4301                 }
4302                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4303                 {
4304                     if (leftvt == rightvt ||
4305                         leftvt == VT_I2 || rightvt == VT_I2 ||
4306                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4307                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4308                         resvt = VT_I2;
4309                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4310                         resvt = VT_NULL;
4311                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4312                         resvt = VT_I8;
4313                 }
4314                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4315                 {
4316                     resvt = VT_NULL;
4317                 }
4318                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4319                 {
4320                     if (leftvt == rightvt)
4321                         resvt = VT_UI1;
4322                     else if (leftvt == rightvt ||
4323                         leftvt == VT_I2 || rightvt == VT_I2 ||
4324                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4325                     {
4326                         resvt = VT_I2;
4327                     }
4328                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4329                         resvt = VT_I8;
4330                 }
4331                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4332                 {
4333                     if (leftvt == rightvt ||
4334                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4335                         resvt = VT_I2;
4336                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4337                         resvt = VT_I8;
4338                 }
4339                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4340                 {
4341                     resvt = VT_BOOL;
4342                 }
4343                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4344                 {
4345                     if (leftvt == VT_INT || rightvt == VT_INT)
4346                         bFail = TRUE;
4347                     else
4348                         resvt = VT_I8;
4349                 }
4350                 hres = pVarEqv(&left, &right, &result);
4351                 if (bFail)
4352                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4353                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4354                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4355                        V_VT(&result));
4356                 else
4357                     ok(hres == S_OK && V_VT(&result) == resvt,
4358                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4359                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4360                        V_VT(&result));
4361             }
4362         }
4363     }
4364
4365     /* Test returned values */
4366     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4367     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4368     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4369     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4370     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4371     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4372     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4373     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4374     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4375     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4376     VAREQV(BOOL,6,I2,7,I2,-2);
4377     VAREQV(UI1,1,UI1,1,UI1,255);
4378     VAREQV(UI1,1,UI1,0,UI1,254);
4379     VAREQV(UI1,0,UI1,1,UI1,254);
4380     if (HAVE_OLEAUT32_I8)
4381     {
4382         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4383         VAREQV(UI4,5,I8,19,I8,-23);
4384         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4385     }
4386 }
4387
4388 START_TEST(vartest)
4389 {
4390   hOleaut32 = LoadLibraryA("oleaut32.dll");
4391
4392   test_VariantInit();
4393   test_VariantClear();
4394   test_VariantCopy();
4395   test_VariantCopyInd();
4396   test_VarParseNumFromStr();
4397   test_VarNumFromParseNum();
4398   test_VarUdateFromDate();
4399   test_VarDateFromUdate();
4400   test_SystemTimeToVariantTime();
4401   test_VariantTimeToSystemTime();
4402   test_DosDateTimeToVariantTime();
4403   test_VariantTimeToDosDateTime();
4404   test_VarFormatNumber();
4405   test_VarFormat();
4406   test_VarAbs();
4407   test_VarNot();
4408   test_VarSub();
4409   test_VarMod();
4410   test_VarFix();
4411   test_VarInt();
4412   test_VarNeg();
4413   test_VarRound();
4414   test_VarXor();
4415   test_VarOr();
4416   test_VarEqv();
4417 }