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