dlls/oleaut32/tests/vartest.c

   1 /*
   2  * VARIANT test program
   3  *
   4  * Copyright 1998 Jean-Claude Cote
   5  * Copyright 2006 Google (Benjamin Arai)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #define COBJMACROS
  28 #define CONST_VTABLE
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winsock2.h"
  33 #include "winuser.h"
  34 #include "wingdi.h"
  35 #include "winnls.h"
  36 #include "winerror.h"
  37 #include "winnt.h"
  38
  39 #include "wtypes.h"
  40 #include "oleauto.h"
  41
  42 #include "wine/test.h"
  43
  44 static HMODULE hOleaut32;
  45
  46 static const WCHAR sz12[] = {'1','2','\0'};
  47 /* the strings are localized */
  48 static WCHAR sz12_false[32];
  49 static WCHAR sz12_true[32];
  50
  51 /* Get a conversion function ptr, return if function not available */
  52 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
  53   if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }
  54
  55 /* Has I8/UI8 data type? */
  56 static BOOL has_i8;
  57
  58 /* When comparing floating point values we cannot expect an exact match
  59  * because the rounding errors depend on the exact algorithm.
  60  */
  61 #define EQ_DOUBLE(a,b)     (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)
  62 #define EQ_FLOAT(a,b)      (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)
  63
  64 #define SKIPTESTS(a)  if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue
  65
  66 /* Allow our test macros to work for VT_NULL and VT_EMPTY too */
  67 #define V_EMPTY(v) V_I4(v)
  68 #define V_NULL(v) V_I4(v)
  69
  70 /* Size constraints for overflow tests */
  71 #define I1_MAX   0x7f
  72 #define I1_MIN   ((-I1_MAX)-1)
  73 #define UI1_MAX  0xff
  74 #define UI1_MIN  0
  75 #define I2_MAX   0x7fff
  76 #define I2_MIN   ((-I2_MAX)-1)
  77 #define UI2_MAX  0xffff
  78 #define UI2_MIN  0
  79 #define I4_MAX   0x7fffffff
  80 #define I4_MIN   ((-I4_MAX)-1)
  81 #define UI4_MAX  0xffffffff
  82 #define UI4_MIN  0
  83 #define I8_MAX   (((LONGLONG)I4_MAX << 32) | UI4_MAX)
  84 #define I8_MIN   ((-I8_MAX)-1)
  85 #define UI8_MAX  (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
  86 #define UI8_MIN  0
  87 #define DATE_MAX 2958465
  88 #define DATE_MIN -657434
  89 #define R4_MAX FLT_MAX
  90 #define R4_MIN FLT_MIN
  91 #define R8_MAX DBL_MAX
  92 #define R8_MIN DBL_MIN
  93
  94 #define DEFINE_EXPECT(func) \
  95     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
  96
  97 #define SET_EXPECT(func) \
  98     do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
  99
 100 #define CHECK_EXPECT2(func) \
 101     do { \
 102         ok(expect_ ##func, "unexpected call " #func "\n"); \
 103         called_ ## func = TRUE; \
 104     }while(0)
 105
 106 #define CHECK_EXPECT(func) \
 107     do { \
 108         CHECK_EXPECT2(func); \
 109         expect_ ## func = FALSE; \
 110     }while(0)
 111
 112 #define CHECK_CALLED(func) \
 113     do { \
 114         ok(called_ ## func, "expected " #func "\n"); \
 115         expect_ ## func = called_ ## func = FALSE; \
 116     }while(0)
 117
 118 DEFINE_EXPECT(dispatch_invoke);
 119
 120 typedef struct
 121 {
 122     IDispatch IDispatch_iface;
 123     VARTYPE vt;
 124     HRESULT result;
 125 } DummyDispatch;
 126
 127 static inline DummyDispatch *impl_from_IDispatch(IDispatch *iface)
 128 {
 129     return CONTAINING_RECORD(iface, DummyDispatch, IDispatch_iface);
 130 }
 131
 132 static ULONG WINAPI DummyDispatch_AddRef(IDispatch *iface)
 133 {
 134     return 2;
 135 }
 136
 137 static ULONG WINAPI DummyDispatch_Release(IDispatch *iface)
 138 {
 139     return 1;
 140 }
 141
 142 static HRESULT WINAPI DummyDispatch_QueryInterface(IDispatch *iface,
 143                                                    REFIID riid,
 144                                                    void** ppvObject)
 145 {
 146     *ppvObject = NULL;
 147
 148     if (IsEqualIID(riid, &IID_IDispatch) ||
 149         IsEqualIID(riid, &IID_IUnknown))
 150     {
 151         *ppvObject = iface;
 152         IDispatch_AddRef(iface);
 153     }
 154
 155     return *ppvObject ? S_OK : E_NOINTERFACE;
 156 }
 157
 158 static HRESULT WINAPI DummyDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
 159 {
 160     ok(0, "Unexpected call\n");
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI DummyDispatch_GetTypeInfo(IDispatch *iface, UINT tinfo, LCID lcid, ITypeInfo **ti)
 165 {
 166     ok(0, "Unexpected call\n");
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI DummyDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *names,
 171     UINT cnames, LCID lcid, DISPID *dispid)
 172 {
 173     ok(0, "Unexpected call\n");
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI DummyDispatch_Invoke(IDispatch *iface,
 178                                            DISPID dispid, REFIID riid,
 179                                            LCID lcid, WORD wFlags,
 180                                            DISPPARAMS *params,
 181                                            VARIANT *res,
 182                                            EXCEPINFO *ei,
 183                                            UINT *arg_err)
 184 {
 185     DummyDispatch *This = impl_from_IDispatch(iface);
 186
 187     CHECK_EXPECT(dispatch_invoke);
 188
 189     ok(dispid == DISPID_VALUE, "got dispid %ld\n", dispid);
 190     ok(IsEqualIID(riid, &IID_NULL), "go riid %s\n", wine_dbgstr_guid(riid));
 191     ok(wFlags == DISPATCH_PROPERTYGET, "Flags wrong\n");
 192
 193     ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
 194     ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
 195     ok(params->cArgs == 0, "got %d\n", params->cArgs);
 196     ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
 197
 198     ok(res != NULL, "got %p\n", res);
 199     ok(V_VT(res) == VT_EMPTY, "got %d\n", V_VT(res));
 200     ok(ei == NULL, "got %p\n", ei);
 201     ok(arg_err == NULL, "got %p\n", arg_err);
 202
 203     if (FAILED(This->result))
 204         return This->result;
 205
 206     V_VT(res) = This->vt;
 207     if (This->vt == VT_UI1)
 208         V_UI1(res) = 34;
 209     else if (This->vt == VT_NULL)
 210     {
 211         V_VT(res) = VT_NULL;
 212         V_BSTR(res) = NULL;
 213     }
 214     else
 215         memset(res, 0, sizeof(*res));
 216
 217     return S_OK;
 218 }
 219
 220 static const IDispatchVtbl DummyDispatch_VTable =
 221 {
 222     DummyDispatch_QueryInterface,
 223     DummyDispatch_AddRef,
 224     DummyDispatch_Release,
 225     DummyDispatch_GetTypeInfoCount,
 226     DummyDispatch_GetTypeInfo,
 227     DummyDispatch_GetIDsOfNames,
 228     DummyDispatch_Invoke
 229 };
 230
 231 static void init_test_dispatch(VARTYPE vt, DummyDispatch *dispatch)
 232 {
 233     dispatch->IDispatch_iface.lpVtbl = &DummyDispatch_VTable;
 234     dispatch->vt = vt;
 235     dispatch->result = S_OK;
 236 }
 237
 238 typedef struct IRecordInfoImpl
 239 {
 240     IRecordInfo IRecordInfo_iface;
 241     LONG ref;
 242     unsigned int recordclear;
 243     unsigned int getsize;
 244     unsigned int recordcopy;
 245     VARIANT *v;
 246 } IRecordInfoImpl;
 247
 248 static inline IRecordInfoImpl *impl_from_IRecordInfo(IRecordInfo *iface)
 249 {
 250     return CONTAINING_RECORD(iface, IRecordInfoImpl, IRecordInfo_iface);
 251 }
 252
 253 static HRESULT WINAPI RecordInfo_QueryInterface(IRecordInfo *iface, REFIID riid, void **obj)
 254 {
 255     *obj = NULL;
 256
 257     if (IsEqualIID(riid, &IID_IUnknown) ||
 258         IsEqualIID(riid, &IID_IRecordInfo))
 259     {
 260         *obj = iface;
 261         IRecordInfo_AddRef(iface);
 262         return S_OK;
 263     }
 264
 265     return E_NOINTERFACE;
 266 }
 267
 268 static ULONG WINAPI RecordInfo_AddRef(IRecordInfo *iface)
 269 {
 270     IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
 271     return InterlockedIncrement(&This->ref);
 272 }
 273
 274 static ULONG WINAPI RecordInfo_Release(IRecordInfo *iface)
 275 {
 276     IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
 277     ULONG ref = InterlockedDecrement(&This->ref);
 278
 279     if (!ref)
 280         HeapFree(GetProcessHeap(), 0, This);
 281
 282     return ref;
 283 }
 284
 285 static HRESULT WINAPI RecordInfo_RecordInit(IRecordInfo *iface, PVOID pvNew)
 286 {
 287     ok(0, "unexpected call\n");
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI RecordInfo_RecordClear(IRecordInfo *iface, void *data)
 292 {
 293     IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
 294     This->recordclear++;
 295     V_RECORD(This->v) = NULL;
 296     return S_OK;
 297 }
 298
 299 static HRESULT WINAPI RecordInfo_RecordCopy(IRecordInfo *iface, void *src, void *dest)
 300 {
 301     IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
 302     This->recordcopy++;
 303     ok(src == (void*)0xdeadbeef, "wrong src pointer %p\n", src);
 304     return S_OK;
 305 }
 306
 307 static HRESULT WINAPI RecordInfo_GetGuid(IRecordInfo *iface, GUID *pguid)
 308 {
 309     ok(0, "unexpected call\n");
 310     return E_NOTIMPL;
 311 }
 312
 313 static HRESULT WINAPI RecordInfo_GetName(IRecordInfo *iface, BSTR *pbstrName)
 314 {
 315     ok(0, "unexpected call\n");
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI RecordInfo_GetSize(IRecordInfo *iface, ULONG* size)
 320 {
 321     IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
 322     This->getsize++;
 323     *size = 0;
 324     return S_OK;
 325 }
 326
 327 static HRESULT WINAPI RecordInfo_GetTypeInfo(IRecordInfo *iface, ITypeInfo **ppTypeInfo)
 328 {
 329     ok(0, "unexpected call\n");
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI RecordInfo_GetField(IRecordInfo *iface, PVOID pvData,
 334                                                 LPCOLESTR szFieldName, VARIANT *pvarField)
 335 {
 336     ok(0, "unexpected call\n");
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI RecordInfo_GetFieldNoCopy(IRecordInfo *iface, PVOID pvData,
 341                             LPCOLESTR szFieldName, VARIANT *pvarField, PVOID *ppvDataCArray)
 342 {
 343     ok(0, "unexpected call\n");
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI RecordInfo_PutField(IRecordInfo *iface, ULONG wFlags, PVOID pvData,
 348                                             LPCOLESTR szFieldName, VARIANT *pvarField)
 349 {
 350     ok(0, "unexpected call\n");
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI RecordInfo_PutFieldNoCopy(IRecordInfo *iface, ULONG wFlags,
 355                 PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
 356 {
 357     ok(0, "unexpected call\n");
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI RecordInfo_GetFieldNames(IRecordInfo *iface, ULONG *pcNames,
 362                                                 BSTR *rgBstrNames)
 363 {
 364     ok(0, "unexpected call\n");
 365     return E_NOTIMPL;
 366 }
 367
 368 static BOOL WINAPI RecordInfo_IsMatchingType(IRecordInfo *iface, IRecordInfo *info2)
 369 {
 370     ok(0, "unexpected call\n");
 371     return FALSE;
 372 }
 373
 374 static PVOID WINAPI RecordInfo_RecordCreate(IRecordInfo *iface)
 375 {
 376     ok(0, "unexpected call\n");
 377     return NULL;
 378 }
 379
 380 static HRESULT WINAPI RecordInfo_RecordCreateCopy(IRecordInfo *iface, PVOID pvSource,
 381                                                     PVOID *ppvDest)
 382 {
 383     ok(0, "unexpected call\n");
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI RecordInfo_RecordDestroy(IRecordInfo *iface, PVOID pvRecord)
 388 {
 389     ok(0, "unexpected call\n");
 390     return E_NOTIMPL;
 391 }
 392
 393 static const IRecordInfoVtbl RecordInfoVtbl =
 394 {
 395     RecordInfo_QueryInterface,
 396     RecordInfo_AddRef,
 397     RecordInfo_Release,
 398     RecordInfo_RecordInit,
 399     RecordInfo_RecordClear,
 400     RecordInfo_RecordCopy,
 401     RecordInfo_GetGuid,
 402     RecordInfo_GetName,
 403     RecordInfo_GetSize,
 404     RecordInfo_GetTypeInfo,
 405     RecordInfo_GetField,
 406     RecordInfo_GetFieldNoCopy,
 407     RecordInfo_PutField,
 408     RecordInfo_PutFieldNoCopy,
 409     RecordInfo_GetFieldNames,
 410     RecordInfo_IsMatchingType,
 411     RecordInfo_RecordCreate,
 412     RecordInfo_RecordCreateCopy,
 413     RecordInfo_RecordDestroy
 414 };
 415
 416 static IRecordInfoImpl *get_test_recordinfo(void)
 417 {
 418     IRecordInfoImpl *rec;
 419
 420     rec = HeapAlloc(GetProcessHeap(), 0, sizeof(IRecordInfoImpl));
 421     rec->IRecordInfo_iface.lpVtbl = &RecordInfoVtbl;
 422     rec->ref = 1;
 423     rec->recordclear = 0;
 424     rec->getsize = 0;
 425     rec->recordcopy = 0;
 426
 427     return rec;
 428 }
 429
 430 static void init(void)
 431 {
 432     BSTR bstr;
 433     HRESULT res;
 434
 435     res = VarBstrFromBool(VARIANT_TRUE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
 436     ok(res == S_OK && bstr[0], "Expected localized string for 'True'\n");
 437     /* lstrcpyW / lstrcatW do not work on win95 */
 438     memcpy(sz12_true, sz12, sizeof(sz12));
 439     if (bstr) memcpy(&sz12_true[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
 440     SysFreeString(bstr);
 441
 442     res = VarBstrFromBool(VARIANT_FALSE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
 443     ok(res == S_OK && bstr[0], "Expected localized string for 'False'\n");
 444     memcpy(sz12_false, sz12, sizeof(sz12));
 445     if (bstr) memcpy(&sz12_false[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
 446     SysFreeString(bstr);
 447
 448     hOleaut32 = GetModuleHandleA("oleaut32.dll");
 449     has_i8 = GetProcAddress(hOleaut32, "VarI8FromI1") != NULL;
 450     if (!has_i8)
 451         skip("No support for I8 and UI8 data types\n");
 452 }
 453
 454 /* Functions to set a DECIMAL */
 455 static void setdec(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG64 lo64)
 456 {
 457     dec->scale = scl;
 458     dec->sign = sgn;
 459     dec->Hi32 = hi32;
 460     dec->Lo64 = lo64;
 461 }
 462
 463 static void setdec64(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG mid32, ULONG lo32)
 464 {
 465     dec->scale = scl;
 466     dec->sign = sgn;
 467     dec->Hi32 = hi32;
 468     dec->Mid32 = mid32;
 469     dec->Lo32 = lo32;
 470 }
 471
 472 static BOOL is_expected_variant( const VARIANT *result, const VARIANT *expected )
 473 {
 474     if (V_VT(result) != V_VT(expected)) return FALSE;
 475     switch(V_VT(expected))
 476     {
 477     case VT_EMPTY:
 478     case VT_NULL:
 479         return TRUE;
 480
 481 #define CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))
 482     CASE(BOOL);
 483     CASE(I1);
 484     CASE(UI1);
 485     CASE(I2);
 486     CASE(UI2);
 487     CASE(I4);
 488     CASE(UI4);
 489     CASE(I8);
 490     CASE(UI8);
 491     CASE(INT);
 492     CASE(UINT);
 493 #undef CASE
 494
 495     case VT_DATE:
 496         return EQ_FLOAT(V_DATE(result), V_DATE(expected));
 497     case VT_R4:
 498         return EQ_FLOAT(V_R4(result), V_R4(expected));
 499     case VT_R8:
 500         return EQ_FLOAT(V_R8(result), V_R8(expected));
 501     case VT_CY:
 502         return (V_CY(result).int64 == V_CY(expected).int64);
 503     case VT_BSTR:
 504         return !lstrcmpW( V_BSTR(result), V_BSTR(expected) );
 505     case VT_DECIMAL:
 506         return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
 507     default:
 508         ok(0, "unhandled variant type %s\n",wine_dbgstr_vt(V_VT(expected)));
 509         return FALSE;
 510     }
 511 }
 512
 513 static void test_var_call1( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT),
 514                            VARIANT *arg, VARIANT *expected )
 515 {
 516     VARIANT old_arg = *arg;
 517     VARIANT result;
 518     HRESULT hres;
 519
 520     memset( &result, 0, sizeof(result) );
 521     hres = func( arg, &result );
 522     ok_(__FILE__,line)( hres == S_OK, "wrong result %lx\n", hres );
 523     if (hres == S_OK)
 524         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 525                             "got %s expected %s\n", wine_dbgstr_variant(&result), wine_dbgstr_variant(expected) );
 526     ok_(__FILE__,line)( is_expected_variant( arg, &old_arg ), "Modified argument %s / %s\n",
 527                         wine_dbgstr_variant(&old_arg), wine_dbgstr_variant(arg));
 528     VariantClear( &result );
 529 }
 530
 531 static void test_var_call2( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT,LPVARIANT),
 532                             VARIANT *left, VARIANT *right, VARIANT *expected )
 533 {
 534     VARIANT old_left = *left, old_right = *right;
 535     VARIANT result;
 536     HRESULT hres;
 537
 538     memset( &result, 0, sizeof(result) );
 539     hres = func( left, right, &result );
 540     ok_(__FILE__,line)( hres == S_OK, "wrong result %lx\n", hres );
 541     if (hres == S_OK)
 542         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
 543                             "got %s expected %s\n", wine_dbgstr_variant(&result), wine_dbgstr_variant(expected) );
 544     ok_(__FILE__,line)( is_expected_variant( left, &old_left ), "Modified left argument %s / %s\n",
 545                         wine_dbgstr_variant(&old_left), wine_dbgstr_variant(left));
 546     ok_(__FILE__,line)( is_expected_variant( right, &old_right ), "Modified right argument %s / %s\n",
 547                         wine_dbgstr_variant(&old_right), wine_dbgstr_variant(right));
 548     VariantClear( &result );
 549 }
 550
 551 #define test_bstr_var(a,b) _test_bstr_var(__LINE__,a,b)
 552 static void _test_bstr_var(unsigned line, const VARIANT *v, const WCHAR *str)
 553 {
 554     ok_(__FILE__,line)(V_VT(v) == VT_BSTR, "unexpected vt=%d\n", V_VT(v));
 555     if(V_VT(v) == VT_BSTR)
 556         ok(!lstrcmpW(V_BSTR(v), str), "v=%s, expected %s\n", wine_dbgstr_w(V_BSTR(v)),
 557            wine_dbgstr_w(str));
 558 }
 559
 560 static void test_VariantInit(void)
 561 {
 562     VARIANT v, v2, v3;
 563
 564     memset(&v, -1, sizeof(v));
 565     memset(&v2, 0, sizeof(v2));
 566     memset(&v3, -1, sizeof(v3));
 567     V_VT(&v3) = VT_EMPTY;
 568
 569     VariantInit(&v);
 570     ok(!memcmp(&v, &v2, sizeof(v)) ||
 571             broken(!memcmp(&v, &v3, sizeof(v3)) /* pre Win8 */), "Unexpected contents.\n");
 572 }
 573
 574 /* All possible combinations of extra V_VT() flags */
 575 static const VARTYPE ExtraFlags[16] =
 576 {
 577   0,
 578   VT_VECTOR,
 579   VT_ARRAY,
 580   VT_BYREF,
 581   VT_RESERVED,
 582   VT_VECTOR|VT_ARRAY,
 583   VT_VECTOR|VT_BYREF,
 584   VT_VECTOR|VT_RESERVED,
 585   VT_VECTOR|VT_ARRAY|VT_BYREF,
 586   VT_VECTOR|VT_ARRAY|VT_RESERVED,
 587   VT_VECTOR|VT_BYREF|VT_RESERVED,
 588   VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
 589   VT_ARRAY|VT_BYREF,
 590   VT_ARRAY|VT_RESERVED,
 591   VT_ARRAY|VT_BYREF|VT_RESERVED,
 592   VT_BYREF|VT_RESERVED,
 593 };
 594
 595 /* Determine if a vt is valid for VariantClear() */
 596 static BOOL IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
 597 {
 598   BOOL ret = FALSE;
 599
 600   /* Only the following flags/types are valid */
 601   if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
 602       vt != (VARTYPE)15 &&
 603       (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
 604       (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
 605       (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
 606        extraFlags == (VT_ARRAY|VT_BYREF)))
 607     ret = TRUE; /* ok */
 608
 609   if (!has_i8 && (vt == VT_I8 || vt == VT_UI8))
 610     ret = FALSE; /* Old versions of oleaut32 */
 611   return ret;
 612 }
 613
 614 typedef struct
 615 {
 616     IUnknown IUnknown_iface;
 617     LONG     ref;
 618     LONG     events;
 619 } test_VariantClearImpl;
 620
 621 static inline test_VariantClearImpl *impl_from_IUnknown(IUnknown *iface)
 622 {
 623     return CONTAINING_RECORD(iface, test_VariantClearImpl, IUnknown_iface);
 624 }
 625
 626 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
 627 {
 628     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 629     This->events |= 0x1;
 630     return E_NOINTERFACE;
 631 }
 632
 633 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
 634     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 635     This->events |= 0x2;
 636     return InterlockedIncrement(&This->ref);
 637 }
 638
 639 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
 640     test_VariantClearImpl *This = impl_from_IUnknown(iface);
 641     /* static class, won't be  freed */
 642     This->events |= 0x4;
 643     return InterlockedDecrement(&This->ref);
 644 }
 645
 646 static const IUnknownVtbl test_VariantClear_vtbl = {
 647     VC_QueryInterface,
 648     VC_AddRef,
 649     VC_Release,
 650 };
 651
 652 static test_VariantClearImpl test_myVariantClearImpl = {{&test_VariantClear_vtbl}, 1, 0};
 653
 654 static void test_VariantClear(void)
 655 {
 656   IRecordInfoImpl *recinfo;
 657   HRESULT hres;
 658   VARIANTARG v;
 659   VARIANT v2;
 660   size_t i;
 661   LONG i4;
 662   IUnknown *punk;
 663
 664   /* Crashes: Native does not test input for NULL, so neither does Wine */
 665   if (0)
 666       VariantClear(NULL);
 667
 668   /* Only the type field is set, to VT_EMPTY */
 669   V_VT(&v) = VT_UI4;
 670   V_UI4(&v) = ~0u;
 671   hres = VariantClear(&v);
 672   ok((hres == S_OK && V_VT(&v) == VT_EMPTY),
 673      "VariantClear: Type set to %d, res %08lx\n", V_VT(&v), hres);
 674   ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
 675
 676   /* Test all possible V_VT values.
 677    * Also demonstrates that null pointers in 'v' are not dereferenced.
 678    * Individual variant tests should test VariantClear() with non-NULL values.
 679    */
 680   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
 681   {
 682     VARTYPE vt;
 683
 684     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 685     {
 686       HRESULT hExpected = DISP_E_BADVARTYPE;
 687
 688       SKIPTESTS(vt);
 689
 690       memset(&v, 0, sizeof(v));
 691       V_VT(&v) = vt | ExtraFlags[i];
 692
 693       hres = VariantClear(&v);
 694
 695       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 696         hExpected = S_OK;
 697
 698       ok(hres == hExpected, "VariantClear: expected 0x%lX, got 0x%lX for vt %d | 0x%X\n",
 699          hExpected, hres, vt, ExtraFlags[i]);
 700     }
 701   }
 702
 703   /* Some BYREF tests with non-NULL ptrs */
 704
 705   /* VARIANT BYREF */
 706   V_VT(&v2) = VT_I4;
 707   V_I4(&v2) = 0x1234;
 708   V_VT(&v) = VT_VARIANT | VT_BYREF;
 709   V_VARIANTREF(&v) = &v2;
 710
 711   hres = VariantClear(&v);
 712   ok(hres == S_OK, "ret %08lx\n", hres);
 713   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 714   ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
 715   ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
 716   ok(V_I4(&v2) == 0x1234, "i4 %04lx\n", V_I4(&v2));
 717
 718   /* I4 BYREF */
 719   i4 = 0x4321;
 720   V_VT(&v) = VT_I4 | VT_BYREF;
 721   V_I4REF(&v) = &i4;
 722
 723   hres = VariantClear(&v);
 724   ok(hres == S_OK, "ret %08lx\n", hres);
 725   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 726   ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
 727   ok(i4 == 0x4321, "i4 changed %08lx\n", i4);
 728
 729
 730   /* UNKNOWN */
 731   V_VT(&v) = VT_UNKNOWN;
 732   V_UNKNOWN(&v) = &test_myVariantClearImpl.IUnknown_iface;
 733   test_myVariantClearImpl.events = 0;
 734   hres = VariantClear(&v);
 735   ok(hres == S_OK, "ret %08lx\n", hres);
 736   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 737   ok(V_UNKNOWN(&v) == &test_myVariantClearImpl.IUnknown_iface, "unknown %p\n", V_UNKNOWN(&v));
 738   /* Check that Release got called, but nothing else */
 739   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 740
 741   /* UNKNOWN BYREF */
 742   punk = &test_myVariantClearImpl.IUnknown_iface;
 743   V_VT(&v) = VT_UNKNOWN | VT_BYREF;
 744   V_UNKNOWNREF(&v) = &punk;
 745   test_myVariantClearImpl.events = 0;
 746   hres = VariantClear(&v);
 747   ok(hres == S_OK, "ret %08lx\n", hres);
 748   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 749   ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
 750   /* Check that nothing got called */
 751   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 752
 753   /* DISPATCH */
 754   V_VT(&v) = VT_DISPATCH;
 755   V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl.IUnknown_iface;
 756   test_myVariantClearImpl.events = 0;
 757   hres = VariantClear(&v);
 758   ok(hres == S_OK, "ret %08lx\n", hres);
 759   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 760   ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl.IUnknown_iface,
 761      "dispatch %p\n", V_DISPATCH(&v));
 762   /* Check that Release got called, but nothing else */
 763   ok(test_myVariantClearImpl.events ==  0x4, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 764
 765   /* DISPATCH BYREF */
 766   punk = &test_myVariantClearImpl.IUnknown_iface;
 767   V_VT(&v) = VT_DISPATCH | VT_BYREF;
 768   V_DISPATCHREF(&v) = (IDispatch**)&punk;
 769   test_myVariantClearImpl.events = 0;
 770   hres = VariantClear(&v);
 771   ok(hres == S_OK, "ret %08lx\n", hres);
 772   ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
 773   ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
 774   /* Check that nothing got called */
 775   ok(test_myVariantClearImpl.events ==  0, "Unexpected call. events %08lx\n", test_myVariantClearImpl.events);
 776
 777   /* RECORD */
 778   recinfo = get_test_recordinfo();
 779   V_VT(&v) = VT_RECORD;
 780   V_RECORDINFO(&v) = &recinfo->IRecordInfo_iface;
 781   V_RECORD(&v) = (void*)0xdeadbeef;
 782   recinfo->recordclear = 0;
 783   recinfo->ref = 2;
 784   recinfo->v = &v;
 785   hres = VariantClear(&v);
 786   ok(hres == S_OK, "ret %08lx\n", hres);
 787   ok(V_RECORD(&v) == NULL, "got %p\n", V_RECORD(&v));
 788   ok(recinfo->recordclear == 1, "got %d\n", recinfo->recordclear);
 789   ok(recinfo->ref == 1, "got %ld\n", recinfo->ref);
 790   IRecordInfo_Release(&recinfo->IRecordInfo_iface);
 791 }
 792
 793 static void test_VariantCopy(void)
 794 {
 795   IRecordInfoImpl *recinfo;
 796   VARIANTARG vSrc, vDst;
 797   VARTYPE vt;
 798   size_t i;
 799   HRESULT hres, hExpected;
 800
 801   /* Establish that the failure/other cases are dealt with. Individual tests
 802    * for each type should verify that data is copied correctly, references
 803    * are updated, etc.
 804    */
 805
 806   /* vSrc == vDst */
 807   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
 808   {
 809     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 810     {
 811       SKIPTESTS(vt);
 812
 813       memset(&vSrc, 0, sizeof(vSrc));
 814       V_VT(&vSrc) = vt | ExtraFlags[i];
 815
 816       hExpected = DISP_E_BADVARTYPE;
 817       /* src is allowed to be a VT_CLSID */
 818       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 819         hExpected = S_OK;
 820
 821       hres = VariantCopy(&vSrc, &vSrc);
 822
 823       ok(hres == hExpected,
 824          "Copy(src==dst): expected 0x%lX, got 0x%lX for src==dest vt %d|0x%X\n",
 825          hExpected, hres, vt, ExtraFlags[i]);
 826     }
 827   }
 828
 829   /* Test that if VariantClear() fails on dest, the function fails. This also
 830    * shows that dest is in fact cleared and not just overwritten
 831    */
 832   memset(&vSrc, 0, sizeof(vSrc));
 833   V_VT(&vSrc) = VT_UI1;
 834
 835   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
 836   {
 837     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 838     {
 839       SKIPTESTS(vt);
 840
 841       hExpected = DISP_E_BADVARTYPE;
 842
 843       memset(&vDst, 0, sizeof(vDst));
 844       V_VT(&vDst) = vt | ExtraFlags[i];
 845
 846       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
 847         hExpected = S_OK;
 848
 849       hres = VariantCopy(&vDst, &vSrc);
 850
 851       ok(hres == hExpected,
 852          "Copy(bad dst): expected 0x%lX, got 0x%lX for dest vt %d|0x%X\n",
 853          hExpected, hres, vt, ExtraFlags[i]);
 854       if (hres == S_OK)
 855         ok(V_VT(&vDst) == VT_UI1,
 856            "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
 857     }
 858   }
 859
 860   /* Test that VariantClear() checks vSrc for validity before copying */
 861   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
 862   {
 863     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 864     {
 865       SKIPTESTS(vt);
 866
 867       hExpected = DISP_E_BADVARTYPE;
 868
 869       memset(&vDst, 0, sizeof(vDst));
 870       V_VT(&vDst) = VT_EMPTY;
 871
 872       memset(&vSrc, 0, sizeof(vSrc));
 873       V_VT(&vSrc) = vt | ExtraFlags[i];
 874
 875       /* src is allowed to be a VT_CLSID */
 876       if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 877         hExpected = S_OK;
 878
 879       hres = VariantCopy(&vDst, &vSrc);
 880
 881       ok(hres == hExpected,
 882          "Copy(bad src): expected 0x%lX, got 0x%lX for src vt %d|0x%X\n",
 883          hExpected, hres, vt, ExtraFlags[i]);
 884       if (hres == S_OK)
 885       {
 886         ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
 887            "Copy(bad src): expected vt = %d, got %d\n",
 888            vt | ExtraFlags[i], V_VT(&vDst));
 889         VariantClear(&vDst);
 890       }
 891     }
 892   }
 893
 894   /* Test that copying a NULL BSTR results in an empty BSTR */
 895   memset(&vDst, 0, sizeof(vDst));
 896   V_VT(&vDst) = VT_EMPTY;
 897   memset(&vSrc, 0, sizeof(vSrc));
 898   V_VT(&vSrc) = VT_BSTR;
 899   hres = VariantCopy(&vDst, &vSrc);
 900   ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
 901   if (hres == S_OK)
 902   {
 903     ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
 904        "Copy(NULL BSTR): should have non-NULL result\n");
 905     if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
 906     {
 907       ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
 908     }
 909     VariantClear(&vDst);
 910   }
 911
 912   /* copy RECORD */
 913   recinfo = get_test_recordinfo();
 914
 915   memset(&vDst, 0, sizeof(vDst));
 916   V_VT(&vDst) = VT_EMPTY;
 917
 918   V_VT(&vSrc) = VT_RECORD;
 919   V_RECORDINFO(&vSrc) = &recinfo->IRecordInfo_iface;
 920   V_RECORD(&vSrc) = (void*)0xdeadbeef;
 921
 922   recinfo->recordclear = 0;
 923   recinfo->recordcopy = 0;
 924   recinfo->getsize = 0;
 925   recinfo->v = &vSrc;
 926   hres = VariantCopy(&vDst, &vSrc);
 927   ok(hres == S_OK, "ret %08lx\n", hres);
 928
 929   ok(V_RECORD(&vDst) != (void*)0xdeadbeef && V_RECORD(&vDst) != NULL, "got %p\n", V_RECORD(&vDst));
 930   ok(V_RECORDINFO(&vDst) == &recinfo->IRecordInfo_iface, "got %p\n", V_RECORDINFO(&vDst));
 931   ok(recinfo->getsize == 1, "got %d\n", recinfo->recordclear);
 932   ok(recinfo->recordcopy == 1, "got %d\n", recinfo->recordclear);
 933
 934   VariantClear(&vDst);
 935   VariantClear(&vSrc);
 936 }
 937
 938 /* Determine if a vt is valid for VariantCopyInd() */
 939 static BOOL IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
 940 {
 941   BOOL ret = FALSE;
 942
 943   if ((extraFlags & VT_ARRAY) ||
 944      (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
 945      !(extraFlags & (VT_VECTOR|VT_RESERVED))))
 946   {
 947     ret = TRUE; /* ok */
 948   }
 949   return ret;
 950 }
 951
 952 static void test_VariantCopyInd(void)
 953 {
 954   VARIANTARG vSrc, vDst, vRef, vRef2;
 955   VARTYPE vt;
 956   size_t i;
 957   BYTE buffer[64];
 958   HRESULT hres, hExpected;
 959
 960   memset(buffer, 0, sizeof(buffer));
 961
 962   /* vSrc == vDst */
 963   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
 964   {
 965     if (ExtraFlags[i] & VT_ARRAY)
 966       continue; /* Native crashes on NULL safearray */
 967
 968     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
 969     {
 970       SKIPTESTS(vt);
 971
 972       memset(&vSrc, 0, sizeof(vSrc));
 973       V_VT(&vSrc) = vt | ExtraFlags[i];
 974
 975       hExpected = DISP_E_BADVARTYPE;
 976       if (!(ExtraFlags[i] & VT_BYREF))
 977       {
 978         /* if src is not by-reference, acts as VariantCopy() */
 979         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
 980           hExpected = S_OK;
 981       }
 982       else
 983       {
 984         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
 985             vt == VT_DISPATCH || vt == VT_RECORD)
 986           continue; /* Need valid ptrs for deep copies */
 987
 988         V_BYREF(&vSrc) = &buffer;
 989         hExpected = E_INVALIDARG;
 990
 991         if ((vt == VT_I8 || vt == VT_UI8) &&
 992             ExtraFlags[i] == VT_BYREF)
 993         {
 994           if (has_i8)
 995             hExpected = S_OK; /* Only valid if I8 is a known type */
 996         }
 997         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
 998           hExpected = S_OK;
 999       }
1000
1001       hres = VariantCopyInd(&vSrc, &vSrc);
1002
1003       ok(hres == hExpected,
1004          "CopyInd(src==dst): expected 0x%lX, got 0x%lX for src==dst vt %d|0x%X\n",
1005          hExpected, hres, vt, ExtraFlags[i]);
1006     }
1007   }
1008
1009   /* Bad dest */
1010   memset(&vSrc, 0, sizeof(vSrc));
1011   V_VT(&vSrc) = VT_UI1|VT_BYREF;
1012   V_BYREF(&vSrc) = &buffer;
1013
1014   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
1015   {
1016     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1017     {
1018       SKIPTESTS(vt);
1019
1020       memset(&vDst, 0, sizeof(vDst));
1021       V_VT(&vDst) = vt | ExtraFlags[i];
1022
1023       hExpected = DISP_E_BADVARTYPE;
1024
1025       if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1026         hExpected = S_OK;
1027
1028       hres = VariantCopyInd(&vDst, &vSrc);
1029
1030       ok(hres == hExpected,
1031          "CopyInd(bad dst): expected 0x%lX, got 0x%lX for dst vt %d|0x%X\n",
1032          hExpected, hres, vt, ExtraFlags[i]);
1033       if (hres == S_OK)
1034         ok(V_VT(&vDst) == VT_UI1,
1035            "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
1036     }
1037   }
1038
1039   /* bad src */
1040   for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
1041   {
1042     if (ExtraFlags[i] & VT_ARRAY)
1043       continue; /* Native crashes on NULL safearray */
1044
1045     for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1046     {
1047       SKIPTESTS(vt);
1048
1049       memset(&vDst, 0, sizeof(vDst));
1050       V_VT(&vDst) = VT_EMPTY;
1051
1052       memset(&vSrc, 0, sizeof(vSrc));
1053       V_VT(&vSrc) = vt | ExtraFlags[i];
1054
1055       hExpected = DISP_E_BADVARTYPE;
1056       if (!(ExtraFlags[i] & VT_BYREF))
1057       {
1058         /* if src is not by-reference, acts as VariantCopy() */
1059         if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
1060           hExpected = S_OK;
1061       }
1062       else
1063       {
1064         if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
1065             vt == VT_DISPATCH || vt == VT_RECORD)
1066           continue; /* Need valid ptrs for deep copies, see vartype.c */
1067
1068         V_BYREF(&vSrc) = &buffer;
1069
1070         hExpected = E_INVALIDARG;
1071
1072         if ((vt == VT_I8 || vt == VT_UI8) &&
1073             ExtraFlags[i] == VT_BYREF)
1074         {
1075           if (has_i8)
1076             hExpected = S_OK; /* Only valid if I8 is a known type */
1077         }
1078         else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
1079           hExpected = S_OK;
1080       }
1081
1082       hres = VariantCopyInd(&vDst, &vSrc);
1083
1084       ok(hres == hExpected,
1085          "CopyInd(bad src): expected 0x%lX, got 0x%lX for src vt %d|0x%X\n",
1086          hExpected, hres, vt, ExtraFlags[i]);
1087       if (hres == S_OK)
1088       {
1089         if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
1090         {
1091           /* Type of vDst should be the type of the referenced variant.
1092            * Since we set the buffer to all zeros, its type should be
1093            * VT_EMPTY.
1094            */
1095           ok(V_VT(&vDst) == VT_EMPTY,
1096              "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
1097              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
1098         }
1099         else
1100         {
1101           ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
1102              "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
1103              vt, ExtraFlags[i] & ~VT_BYREF,
1104              V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
1105         }
1106         VariantClear(&vDst);
1107       }
1108     }
1109   }
1110
1111   /* By-reference variants are dereferenced */
1112   V_VT(&vRef) = VT_UI1;
1113   V_UI1(&vRef) = 0x77;
1114   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
1115   V_VARIANTREF(&vSrc) = &vRef;
1116   VariantInit(&vDst);
1117
1118   hres = VariantCopyInd(&vDst, &vSrc);
1119   ok(hres == S_OK, "VariantCopyInd failed: 0x%08lx\n", hres);
1120   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
1121      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
1122       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
1123
1124   /* By-reference variant to a by-reference type succeeds */
1125   V_VT(&vRef) = VT_UI1|VT_BYREF;
1126   V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
1127   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
1128   V_VARIANTREF(&vSrc) = &vRef;
1129   VariantInit(&vDst);
1130
1131   hres = VariantCopyInd(&vDst, &vSrc);
1132   ok(hres == S_OK, "VariantCopyInd failed: 0x%08lx\n", hres);
1133   ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
1134      "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
1135       V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
1136
1137   /* But a by-reference variant to a by-reference variant fails */
1138   V_VT(&vRef2) = VT_UI1;
1139   V_UI1(&vRef2) = 0x77;
1140   V_VT(&vRef) = VT_VARIANT|VT_BYREF;
1141   V_VARIANTREF(&vRef) = &vRef2;
1142   V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
1143   V_VARIANTREF(&vSrc) = &vRef;
1144   VariantInit(&vDst);
1145
1146   hres = VariantCopyInd(&vDst, &vSrc);
1147   ok(hres == E_INVALIDARG,
1148      "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08lx\n", hres);
1149 }
1150
1151 /* Macros for converting and testing the result of VarParseNumFromStr */
1152 #define FAILDIG 255
1153
1154 static HRESULT wconvert_str( const OLECHAR *str, INT dig, ULONG npflags,
1155                              NUMPARSE *np, BYTE rgb[128], LCID lcid, ULONG flags)
1156 {
1157     memset( rgb, FAILDIG, 128 );
1158     memset( np, 255, sizeof(*np) );
1159     np->cDig = dig;
1160     np->dwInFlags = npflags;
1161     return VarParseNumFromStr( str, lcid, flags, np, rgb);
1162 }
1163
1164 static HRESULT convert_str( const char *str, INT dig, ULONG flags,
1165                             NUMPARSE *np, BYTE rgb[128], LCID lcid )
1166 {
1167     OLECHAR buff[128];
1168     MultiByteToWideChar( CP_ACP,0, str, -1, buff, ARRAY_SIZE( buff ));
1169     return wconvert_str(buff, dig, flags, np, rgb, lcid, LOCALE_NOUSEROVERRIDE);
1170 }
1171
1172 static void expect_NumFromStr( int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c,
1173                                INT d, INT e, INT f )
1174 {
1175     ok_(__FILE__,line)(hres == S_OK, "returned %08lx\n", hres);
1176     if (hres == S_OK)
1177     {
1178         ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
1179         ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%lx, got 0x%lx\n", b, np->dwInFlags);
1180         ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%lx, got 0x%lx\n", c, np->dwOutFlags);
1181         ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
1182         ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
1183         ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
1184     }
1185 }
1186
1187 #define WCONVERTN(str,dig,flags) hres = wconvert_str( str, dig, flags, &np, rgb, lcid, LOCALE_NOUSEROVERRIDE )
1188 #define WCONVERT(str,flags) WCONVERTN(str,sizeof(rgb),flags)
1189 #define CONVERTN(str,dig,flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )
1190 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
1191 #define EXPECT(a,b,c,d,e,f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )
1192 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
1193 #define EXPECTFAIL ok(hres == DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08lx\n", hres)
1194 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
1195
1196 static void test_VarParseNumFromStrEn(void)
1197 {
1198   HRESULT hres;
1199   /* Ensure all tests are using the same locale characters for '$', ',' etc */
1200   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1201   NUMPARSE np;
1202   BYTE rgb[128];
1203   OLECHAR wstr[128];
1204   OLECHAR spaces[] = L" \xa0\f\n\r\t\v"; /* man isspace() */
1205   int i;
1206
1207   /** No flags **/
1208
1209   /* Consume an empty string */
1210   CONVERT("", 0);
1211   EXPECTFAIL;
1212
1213   /* Consume a single digit */
1214   CONVERT("7", 0);
1215   EXPECT(1,0,0,1,0,0);
1216   EXPECT2(7,FAILDIG);
1217
1218   /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
1219   CONVERT("10", 0);
1220   EXPECT(1,0,0,2,0,1);
1221   /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
1222    * but then excludes them from the returned cDig count.
1223    * In our implementation we don't bother writing them at all.
1224    */
1225   EXPECTRGB(0, 1);
1226
1227   /* if cDig is too small and numbers follow, sets INEXACT */
1228   CONVERTN("11",1, 0);
1229   EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
1230   EXPECT2(1,FAILDIG);
1231
1232   /* Strips leading zeros */
1233   CONVERT("01", 0);
1234   EXPECT(1,0,0,2,0,0);
1235   EXPECT2(1,FAILDIG);
1236
1237   /* Strips leading zeros */
1238   CONVERTN("01",1, 0);
1239   EXPECT(1,0,0,2,0,0);
1240   EXPECT2(1,FAILDIG);
1241
1242
1243   /* Fails on non digits */
1244   CONVERT("a", 0);
1245   EXPECTFAIL;
1246   EXPECTRGB(0,FAILDIG);
1247
1248   /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
1249
1250   /* Without flag, fails on whitespace */
1251   CONVERT(" 0", 0);
1252   EXPECTFAIL;
1253   EXPECTRGB(0,FAILDIG);
1254
1255
1256   /* With flag, consumes any type of space */
1257   for (i = 0; i < ARRAY_SIZE(spaces)-1; i++)
1258   {
1259       winetest_push_context("%d", i);
1260
1261       wsprintfW(wstr, L"%c0", spaces[i]);
1262       WCONVERT(wstr, NUMPRS_LEADING_WHITE);
1263       EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1264       EXPECT2(0,FAILDIG);
1265
1266       winetest_pop_context();
1267   }
1268
1269   /* Doesn't pick up trailing whitespace without flag */
1270   CONVERT("0 ", 0);
1271   EXPECT(1,0,0,1,0,0);
1272   EXPECT2(0,FAILDIG);
1273
1274   /* With flag, consumes trailing whitespace */
1275   CONVERT("0 ", NUMPRS_TRAILING_WHITE);
1276   EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1277   EXPECT2(0,FAILDIG);
1278
1279   /* Leading flag only consumes leading */
1280   CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
1281   EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1282   EXPECT2(0,FAILDIG);
1283
1284   /* Both flags consumes both */
1285   CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
1286   EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
1287   EXPECT2(0,FAILDIG);
1288
1289   /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
1290
1291   /* Without flag, fails on + */
1292   CONVERT("+0", 0);
1293   EXPECTFAIL;
1294   EXPECTRGB(0,FAILDIG);
1295
1296   /* With flag, consumes + */
1297   CONVERT("+0", NUMPRS_LEADING_PLUS);
1298   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1299   EXPECT2(0,FAILDIG);
1300
1301   /* Without flag, doesn't consume trailing + */
1302   CONVERT("0+", 0);
1303   EXPECT(1,0,0,1,0,0);
1304   EXPECT2(0,FAILDIG);
1305
1306   /* With flag, consumes trailing + */
1307   CONVERT("0+", NUMPRS_TRAILING_PLUS);
1308   EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
1309   EXPECT2(0,FAILDIG);
1310
1311   /* With leading flag, doesn't consume trailing + */
1312   CONVERT("+0+", NUMPRS_LEADING_PLUS);
1313   EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1314   EXPECT2(0,FAILDIG);
1315
1316   /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
1317   CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
1318   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1319   EXPECT2(0,FAILDIG);
1320
1321   /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
1322
1323   /* Without flag, fails on - */
1324   CONVERT("-0", 0);
1325   EXPECTFAIL;
1326   EXPECTRGB(0,FAILDIG);
1327
1328   /* With flag, consumes - */
1329   CONVERT("-0", NUMPRS_LEADING_MINUS);
1330   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1331   EXPECT2(0,FAILDIG);
1332
1333   /* Without flag, doesn't consume trailing - */
1334   CONVERT("0-", 0);
1335   EXPECT(1,0,0,1,0,0);
1336   EXPECT2(0,FAILDIG);
1337
1338   /* With flag, consumes trailing - */
1339   CONVERT("0-", NUMPRS_TRAILING_MINUS);
1340   EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
1341   EXPECT2(0,FAILDIG);
1342
1343   /* With leading flag, doesn't consume trailing - */
1344   CONVERT("-0-", NUMPRS_LEADING_MINUS);
1345   EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1346   EXPECT2(0,FAILDIG);
1347
1348   /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
1349   CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
1350   EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1351   EXPECT2(0,FAILDIG);
1352
1353   /** NUMPRS_HEX_OCT **/
1354
1355   /* Could be hex, octal or decimal - With flag reads as decimal */
1356   CONVERT("0", NUMPRS_HEX_OCT);
1357   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1358   EXPECT2(0,FAILDIG);
1359
1360   /* Doesn't recognise hex in .asm syntax */
1361   CONVERT("0h", NUMPRS_HEX_OCT);
1362   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1363   EXPECT2(0,FAILDIG);
1364
1365   /* Doesn't fail with valid leading string but no digits */
1366   CONVERT("0x", NUMPRS_HEX_OCT);
1367   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1368   EXPECT2(0,FAILDIG);
1369
1370   /* Doesn't recognise hex format numbers at all! */
1371   CONVERT("0x0", NUMPRS_HEX_OCT);
1372   EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1373   EXPECT2(0,FAILDIG);
1374
1375   /* Doesn't recognise plain hex digits either */
1376   CONVERT("FE", NUMPRS_HEX_OCT);
1377   EXPECTFAIL;
1378   EXPECTRGB(0,FAILDIG);
1379
1380   /* A leading 0 does not an octal number make */
1381   CONVERT("0100", NUMPRS_HEX_OCT);
1382   EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
1383   EXPECTRGB(0,1);
1384   EXPECTRGB(1,0);
1385   EXPECTRGB(2,0);
1386   EXPECTRGB(3,FAILDIG);
1387
1388   /* VB hex */
1389   CONVERT("&HF800", NUMPRS_HEX_OCT);
1390   EXPECT(4,NUMPRS_HEX_OCT,NUMPRS_HEX_OCT,6,4,0);
1391   EXPECTRGB(0,15);
1392   EXPECTRGB(1,8);
1393   EXPECTRGB(2,0);
1394   EXPECTRGB(3,0);
1395   EXPECTRGB(4,FAILDIG);
1396
1397   /* VB hex lower case and leading zero */
1398   CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
1399   EXPECT(6,NUMPRS_HEX_OCT,NUMPRS_HEX_OCT,9,4,0);
1400   EXPECTRGB(0,10);
1401   EXPECTRGB(1,11);
1402   EXPECTRGB(2,12);
1403   EXPECTRGB(3,13);
1404   EXPECTRGB(4,14);
1405   EXPECTRGB(5,15);
1406   EXPECTRGB(6,FAILDIG);
1407
1408   /* VB oct */
1409   CONVERT("&O300", NUMPRS_HEX_OCT);
1410   EXPECT(3,NUMPRS_HEX_OCT,NUMPRS_HEX_OCT,5,3,0);
1411   EXPECTRGB(0,3);
1412   EXPECTRGB(1,0);
1413   EXPECTRGB(2,0);
1414   EXPECTRGB(3,FAILDIG);
1415
1416   /* VB oct lower case and leading zero */
1417   CONVERT("&o0777", NUMPRS_HEX_OCT);
1418   EXPECT(3,NUMPRS_HEX_OCT,NUMPRS_HEX_OCT,6,3,0);
1419   EXPECTRGB(0,7);
1420   EXPECTRGB(1,7);
1421   EXPECTRGB(2,7);
1422   EXPECTRGB(3,FAILDIG);
1423
1424   /* VB oct char bigger than 7 */
1425   CONVERT("&o128", NUMPRS_HEX_OCT);
1426   EXPECT(2,NUMPRS_HEX_OCT,NUMPRS_HEX_OCT,4,3,0);
1427   EXPECTRGB(0,1);
1428   EXPECTRGB(1,2);
1429   EXPECTRGB(3,FAILDIG);
1430
1431   /* Only integers are allowed when using an alternative radix */
1432   CONVERT("&ha.2", NUMPRS_HEX_OCT|NUMPRS_DECIMAL);
1433   EXPECT(1,NUMPRS_HEX_OCT|NUMPRS_DECIMAL,NUMPRS_HEX_OCT,3,4,0);
1434   EXPECT2(10,FAILDIG);
1435
1436   /* Except if it looks like a plain decimal number */
1437   CONVERT("01.2", NUMPRS_HEX_OCT|NUMPRS_DECIMAL);
1438   EXPECT(2,NUMPRS_HEX_OCT|NUMPRS_DECIMAL,NUMPRS_DECIMAL,4,0,-1);
1439   EXPECT2(1,2);
1440   EXPECTRGB(3,FAILDIG);
1441
1442   /** NUMPRS_PARENS **/
1443
1444   /* Empty parens = error */
1445   CONVERT("()", NUMPRS_PARENS);
1446   EXPECTFAIL;
1447   EXPECTRGB(0,FAILDIG);
1448
1449   /* With flag, trailing parens not consumed */
1450   CONVERT("0()", NUMPRS_PARENS);
1451   EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1452   EXPECT2(0,FAILDIG);
1453
1454   /* With flag, Number in parens made negative and parens consumed */
1455   CONVERT("(0)", NUMPRS_PARENS);
1456   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1457   EXPECT2(0,FAILDIG);
1458
1459   /** NUMPRS_THOUSANDS **/
1460
1461   /* With flag, thousands sep. not needed */
1462   CONVERT("0", NUMPRS_THOUSANDS);
1463   EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1464   EXPECT2(0,FAILDIG);
1465
1466   /* Without flag stop at thousands separator */
1467   CONVERT("1,000", 0);
1468   EXPECT(1,0,0,1,0,0);
1469   EXPECT2(1,FAILDIG);
1470
1471   /* With flag, thousands sep. and following digits consumed */
1472   CONVERT("1,000", NUMPRS_THOUSANDS);
1473   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1474   EXPECTRGB(0,1);
1475   /* VarParseNumFromStr() may have added more digits to rgb but they are not
1476    * part of the returned value. So consider that an implementation detail.
1477    */
1478   EXPECTRGB(4,FAILDIG);
1479
1480   /* With flag, thousands sep. and following digits consumed */
1481   CONVERT("&h1,000", NUMPRS_HEX_OCT|NUMPRS_THOUSANDS);
1482   EXPECT(1,NUMPRS_HEX_OCT|NUMPRS_THOUSANDS,NUMPRS_HEX_OCT,3,4,0);
1483   EXPECTRGB(1,FAILDIG);
1484
1485   /* With flag and decimal point, thousands sep. but not decimals consumed */
1486   CONVERT("1,001.0", NUMPRS_THOUSANDS);
1487   EXPECT(4,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,0);
1488   EXPECT2(1,0);
1489   EXPECTRGB(2,0);
1490   EXPECTRGB(3,1);
1491   EXPECTRGB(4,FAILDIG);
1492
1493   /* With flag, consecutive thousands separators are allowed */
1494   CONVERT("1,,000", NUMPRS_THOUSANDS);
1495   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,6,0,3);
1496   EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
1497   EXPECTRGB(4,FAILDIG);
1498
1499   /* With flag, thousands separators can be sprinkled at random */
1500   CONVERT("1,00,0,,", NUMPRS_THOUSANDS);
1501   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,8,0,3);
1502   EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
1503   EXPECTRGB(4,FAILDIG);
1504
1505   /* With flag, but leading thousands separators are not allowed */
1506   CONVERT(",1,000", NUMPRS_THOUSANDS);
1507   EXPECTFAIL;
1508
1509   /* With flag, thousands separator not needed but still reported */
1510   CONVERT("1,", NUMPRS_THOUSANDS);
1511   EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,2,0,0);
1512   EXPECT2(1,FAILDIG);
1513
1514   /** NUMPRS_CURRENCY **/
1515
1516   /* Without flag, chokes on currency sign */
1517   CONVERT("$11", 0);
1518   EXPECTFAIL;
1519   EXPECTRGB(0,FAILDIG);
1520
1521   /* With flag, allows having no currency sign */
1522   CONVERT("11", NUMPRS_CURRENCY);
1523   EXPECT(2,NUMPRS_CURRENCY,0,2,0,0);
1524   EXPECT2(1,1);
1525   EXPECTRGB(2,FAILDIG);
1526
1527   /* With flag, does not allow a lone currency sign */
1528   CONVERT("$", NUMPRS_CURRENCY);
1529   EXPECTFAIL;
1530
1531   /* With flag, consumes currency sign */
1532   CONVERT("$11", NUMPRS_CURRENCY);
1533   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1534   EXPECT2(1,1);
1535   EXPECTRGB(2,FAILDIG);
1536
1537   /* With flag, currency amounts cannot be in hexadecimal */
1538   CONVERT("$&ha", NUMPRS_HEX_OCT|NUMPRS_CURRENCY);
1539   EXPECTFAIL;
1540
1541   CONVERT("&ha$", NUMPRS_HEX_OCT|NUMPRS_CURRENCY);
1542   EXPECT(1,NUMPRS_HEX_OCT|NUMPRS_CURRENCY,NUMPRS_HEX_OCT,3,4,0);
1543   EXPECTRGB(0,10);
1544   EXPECTRGB(1,FAILDIG);
1545
1546   /* With flag, the sign cannot be repeated before the amount */
1547   CONVERT("$$11", NUMPRS_CURRENCY);
1548   EXPECTFAIL;
1549
1550   /* With flag, but is allowed after the amount and can even be repeated! */
1551   CONVERT("$11$$", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
1552   EXPECT(2,NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_CURRENCY,5,0,0);
1553   EXPECT2(1,1);
1554   EXPECTRGB(2,FAILDIG);
1555
1556   /* With flag, the British Pound is not allowed "1L" */
1557   WCONVERT(L"\x31\xa3", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
1558   EXPECTFAIL;
1559
1560   /* With flag, minus can go after the currency sign */
1561   CONVERT("$-11", NUMPRS_CURRENCY|NUMPRS_LEADING_MINUS);
1562   EXPECT(2,NUMPRS_CURRENCY|NUMPRS_LEADING_MINUS,NUMPRS_CURRENCY|NUMPRS_LEADING_MINUS|NUMPRS_NEG,4,0,0);
1563   EXPECT2(1,1);
1564   EXPECTRGB(2,FAILDIG);
1565
1566   /* With flag, or before */
1567   CONVERT("-$11", NUMPRS_CURRENCY|NUMPRS_LEADING_MINUS);
1568   EXPECT(2,NUMPRS_CURRENCY|NUMPRS_LEADING_MINUS,NUMPRS_CURRENCY|NUMPRS_LEADING_MINUS|NUMPRS_NEG,4,0,0);
1569   EXPECT2(1,1);
1570   EXPECTRGB(2,FAILDIG);
1571
1572   for (i = 0; i < ARRAY_SIZE(spaces)-1; i++)
1573   {
1574       winetest_push_context("%d", i);
1575
1576       /* With flag, no space is allowed after the currency sign */
1577       wsprintfW(wstr, L"$%c11", spaces[i]);
1578       WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_USE_ALL);
1579       EXPECTFAIL;
1580
1581       /* With flag, unless explicitly allowed before the digits */
1582       WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_LEADING_WHITE);
1583       EXPECT(2,NUMPRS_CURRENCY|NUMPRS_LEADING_WHITE,NUMPRS_CURRENCY|NUMPRS_LEADING_WHITE,4,0,0);
1584       EXPECT2(1,1);
1585       EXPECTRGB(2,FAILDIG);
1586
1587       /* With flag, no space is allowed before the trailing currency sign */
1588       wsprintfW(wstr, L"11%c$", spaces[i]);
1589       WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_USE_ALL);
1590       EXPECTFAIL;
1591
1592       /* With flag, even with thousands flag (see the French situation) */
1593       WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
1594       EXPECTFAIL;
1595
1596       /* With flag, unless explicitly allowed */
1597       WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL);
1598       EXPECT(2,NUMPRS_CURRENCY|NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL,NUMPRS_CURRENCY|NUMPRS_TRAILING_WHITE,4,0,0);
1599       EXPECT2(1,1);
1600       EXPECTRGB(2,FAILDIG);
1601
1602       winetest_pop_context();
1603   }
1604
1605   /* With flag only, doesn't consume decimal point */
1606   CONVERT("$11.1", NUMPRS_CURRENCY);
1607   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1608   EXPECT2(1,1);
1609   EXPECTRGB(2,FAILDIG);
1610
1611   /* With flag and decimal flag, consumes decimal point and following digits */
1612   CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1613   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1614   EXPECT2(1,1);
1615   EXPECTRGB(2,1);
1616   EXPECTRGB(3,FAILDIG);
1617
1618   /* With flag, the currency cannot replace the decimal sign (see comment about
1619    * the Cape Verdean escudo).
1620    */
1621   CONVERT("1$99", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1622   EXPECT(1,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY,2,0,0);
1623   EXPECT2(1,FAILDIG);
1624
1625   /* Thousands flag can also be used with currency */
1626   CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1627   EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1628   EXPECT2(1,2);
1629   EXPECTRGB(2,3);
1630   EXPECTRGB(3,4);
1631   EXPECTRGB(4,FAILDIG);
1632
1633   /* Thousands flag can also be used with currency and decimal numbers */
1634   CONVERT("$1,234.5", NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_DECIMAL);
1635   EXPECT(5,NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_DECIMAL,8,0,-1);
1636   EXPECT2(1,2);
1637   EXPECTRGB(2,3);
1638   EXPECTRGB(3,4);
1639   EXPECTRGB(4,5);
1640   EXPECTRGB(5,FAILDIG);
1641
1642   /** NUMPRS_DECIMAL **/
1643
1644   /* With flag, consumes decimal point */
1645   CONVERT("1.1", NUMPRS_DECIMAL);
1646   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1647   EXPECT2(1,1);
1648   EXPECTRGB(2,FAILDIG);
1649
1650   /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1651   CONVERT("1.", NUMPRS_DECIMAL);
1652   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1653   EXPECT2(1,FAILDIG);
1654
1655   /* Skipping the integer part is not an error */
1656   CONVERT(".2", NUMPRS_DECIMAL);
1657   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,-1);
1658   EXPECT2(2,FAILDIG);
1659
1660   /* Even zero gets an exponent (it sort of indicates 'precision') */
1661   CONVERT(".0", NUMPRS_DECIMAL);
1662   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,-1);
1663   EXPECT2(0,FAILDIG);
1664
1665   CONVERT(".000", NUMPRS_DECIMAL);
1666   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,4,0,-3);
1667   EXPECTRGB(0,0);
1668   EXPECTRGB(3,FAILDIG);
1669
1670   CONVERT("$.02", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1671   EXPECT(1,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,4,0,-2);
1672   EXPECT2(2,FAILDIG);
1673
1674   CONVERT(".001", NUMPRS_DECIMAL);
1675   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,4,0,-3);
1676   EXPECT2(1,FAILDIG);
1677
1678   CONVERT(".101", NUMPRS_DECIMAL);
1679   EXPECT(3,NUMPRS_DECIMAL,NUMPRS_DECIMAL,4,0,-3);
1680   EXPECT2(1,0);
1681   EXPECTRGB(2,1);
1682   EXPECTRGB(3,FAILDIG);
1683
1684   CONVERT(".30", NUMPRS_DECIMAL);
1685   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1686   /* See the NUMPRS_THOUSANDS comment about trailing zeroes */
1687   EXPECTRGB(0,3);
1688   EXPECTRGB(2,FAILDIG);
1689
1690   /* But skipping both the integer and decimal part is not allowed */
1691   CONVERT(".", NUMPRS_DECIMAL);
1692   EXPECTFAIL;
1693
1694   /* Consumes only one decimal point */
1695   CONVERT("1.1.", NUMPRS_DECIMAL);
1696   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1697   EXPECT2(1,1);
1698   EXPECTRGB(2,FAILDIG);
1699
1700   /* With flag, including if they are consecutive */
1701   CONVERT("1..1", NUMPRS_DECIMAL);
1702   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1703   EXPECT2(1,FAILDIG);
1704
1705   /** NUMPRS_EXPONENT **/
1706
1707   /* Without flag, doesn't consume exponent */
1708   CONVERT("1e1", 0);
1709   EXPECT(1,0,0,1,0,0);
1710   EXPECT2(1,FAILDIG);
1711
1712   /* With flag, consumes exponent */
1713   CONVERT("1e1", NUMPRS_EXPONENT);
1714   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1715   EXPECT2(1,FAILDIG);
1716
1717   /* Spaces are not allowed before the exponent */
1718   CONVERT("1 e1", NUMPRS_EXPONENT|NUMPRS_TRAILING_WHITE);
1719   EXPECT(1,NUMPRS_EXPONENT|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1720   EXPECT2(1,FAILDIG);
1721
1722   /* With flag, incompatible with NUMPRS_HEX_OCT */
1723   CONVERT("&o1e1", NUMPRS_HEX_OCT|NUMPRS_EXPONENT);
1724   EXPECT(1,NUMPRS_HEX_OCT|NUMPRS_EXPONENT,NUMPRS_HEX_OCT,3,3,0);
1725   EXPECT2(1,FAILDIG);
1726
1727   /* With flag, even if it sort of looks like an exponent */
1728   CONVERT("&h1e2", NUMPRS_HEX_OCT|NUMPRS_EXPONENT);
1729   EXPECT(3,NUMPRS_HEX_OCT|NUMPRS_EXPONENT,NUMPRS_HEX_OCT,5,4,0);
1730   EXPECT2(1,0xe);
1731   EXPECTRGB(2,2);
1732   EXPECTRGB(3,FAILDIG);
1733
1734   /* Negative exponents are accepted without flags */
1735   CONVERT("1e-1", NUMPRS_EXPONENT);
1736   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1737   EXPECT2(1,FAILDIG);
1738
1739   /* As are positive exponents and leading exponent 0s */
1740   CONVERT("1e+01", NUMPRS_EXPONENT);
1741   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1742   EXPECT2(1,FAILDIG);
1743
1744   /* The same for zero exponents */
1745   CONVERT("1e0", NUMPRS_EXPONENT);
1746   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1747   EXPECT2(1,FAILDIG);
1748
1749   /* Sign on a zero exponent doesn't matter */
1750   CONVERT("1e+0", NUMPRS_EXPONENT);
1751   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1752   EXPECT2(1,FAILDIG);
1753
1754   CONVERT("1e-0", NUMPRS_EXPONENT);
1755   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1756   EXPECT2(1,FAILDIG);
1757
1758   /* Doesn't consume a real number exponent */
1759   CONVERT("1e1.", NUMPRS_EXPONENT);
1760   EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1761   EXPECT2(1,FAILDIG);
1762
1763   /* Powers of 10 are calculated from the position of any decimal point */
1764   CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1765   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1766   EXPECT2(1,5);
1767
1768   CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1769   EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1770   EXPECT2(1,5);
1771
1772   /** NUMPRS_USE_ALL **/
1773
1774   /* Flag expects all digits */
1775   CONVERT("0", NUMPRS_USE_ALL);
1776   EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1777   EXPECT2(0,FAILDIG);
1778
1779   /* Rejects anything trailing */
1780   CONVERT("0 ", NUMPRS_USE_ALL);
1781   EXPECTFAIL;
1782   EXPECT2(0,FAILDIG);
1783
1784   /* Unless consumed by trailing flag */
1785   CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1786   EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1787   EXPECT2(0,FAILDIG);
1788
1789   /** Combinations **/
1790
1791   /* Leading whitespace and plus, doesn't consume trailing whitespace */
1792   CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1793   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1794   EXPECT2(0,FAILDIG);
1795
1796   /* Order of whitespace and plus is unimportant */
1797   CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1798   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1799   EXPECT2(0,FAILDIG);
1800
1801   /* Leading whitespace can be repeated */
1802   CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1803   EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1804   EXPECT2(0,FAILDIG);
1805
1806   /* But plus/minus etc. cannot */
1807   CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1808   EXPECTFAIL;
1809   EXPECTRGB(0,FAILDIG);
1810
1811   /* Inexact is not set if trailing zeros are removed */
1812   CONVERTN("10", 1, 0);
1813   EXPECT(1,0,0,2,0,1);
1814   EXPECT2(1,FAILDIG);
1815
1816   /* Make sure a leading 0 is stripped but decimals after it get read */
1817   CONVERT("-0.51", NUMPRS_STD);
1818   EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1819   EXPECT2(5,1);
1820
1821   /* Keep trailing zeros on whole number part of a decimal */
1822   CONVERT("10.1", NUMPRS_STD);
1823   EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1824   EXPECT2(1,0);
1825   EXPECTRGB(2,1);
1826
1827   /* Zeros after decimal sign */
1828   CONVERT("0.01", NUMPRS_STD);
1829   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1830   EXPECT2(1,FAILDIG);
1831
1832   /* Trailing zeros after decimal part */
1833   CONVERT("0.10", NUMPRS_STD);
1834   EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1835   EXPECT2(1,0);
1836
1837   /* Arabic numerals are not allowed "0" */
1838   WCONVERT(L"\x660", NUMPRS_STD);
1839   EXPECTFAIL;
1840 }
1841
1842 static void test_VarParseNumFromStrFr(void)
1843 {
1844   HRESULT hres;
1845   /* Test some aspects that are different in a non-English locale */
1846   LCID lcid = MAKELCID(MAKELANGID(LANG_FRENCH,SUBLANG_FRENCH),SORT_DEFAULT);
1847   NUMPARSE np;
1848   BYTE rgb[128];
1849   OLECHAR wstr[128];
1850   OLECHAR spaces[] = L" \xa0\f\n\r\t\v"; /* man isspace() */
1851   int i;
1852
1853   /** White spaces **/
1854
1855   for (i = 0; i < ARRAY_SIZE(spaces)-1; i++)
1856   {
1857     winetest_push_context("%d", i);
1858
1859     /* Leading spaces must be explicitly allowed */
1860     wsprintfW(wstr, L"%c2", spaces[i]);
1861     WCONVERT(wstr, NUMPRS_USE_ALL);
1862     EXPECTFAIL;
1863
1864     WCONVERT(wstr, NUMPRS_LEADING_WHITE|NUMPRS_USE_ALL);
1865     EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_USE_ALL,NUMPRS_LEADING_WHITE,2,0,0);
1866     EXPECT2(2,FAILDIG);
1867
1868     /* But trailing spaces... */
1869     wsprintfW(wstr, L"3%c", spaces[i]);
1870     WCONVERT(wstr, NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL);
1871     if (spaces[i] == ' ' || spaces[i] == 0xa0 /* non-breaking space */)
1872     {
1873       /* Spaces aliased to the thousands separator are never allowed! */
1874       EXPECTFAIL;
1875     }
1876     else
1877     {
1878       /* The others behave normally */
1879       EXPECT(1,NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL,NUMPRS_TRAILING_WHITE,2,0,0);
1880       EXPECT2(3,FAILDIG);
1881     }
1882
1883     WCONVERT(wstr, NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
1884     if (spaces[i] == ' ' || spaces[i] == 0xa0 /* non-breaking space */)
1885     {
1886       /* Trailing thousands separators are allowed as usual */
1887       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,2,0,0);
1888       EXPECT2(3,FAILDIG);
1889     }
1890     else
1891     {
1892       /* But not other spaces */
1893       EXPECTFAIL;
1894     }
1895
1896     /* No space of any type is allowed before the exponent... */
1897     wsprintfW(wstr, L"1%ce1", spaces[i]);
1898     WCONVERT(wstr, NUMPRS_EXPONENT|NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL);
1899     EXPECTFAIL;
1900
1901     winetest_pop_context();
1902   }
1903
1904
1905   /** NUMPRS_PARENS **/
1906
1907   /* With flag, Number in parens made negative and parens consumed */
1908   CONVERT("(0)", NUMPRS_PARENS);
1909   EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1910   EXPECT2(0,FAILDIG);
1911
1912   /** NUMPRS_THOUSANDS **/
1913
1914   for (i = 0; i < ARRAY_SIZE(spaces)-1; i++)
1915   {
1916     winetest_push_context("%d", i);
1917
1918     /* With flag, thousands separator and following digits consumed */
1919     wsprintfW(wstr, L"1%c000", spaces[i]);
1920     WCONVERT(wstr, NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
1921     if (spaces[i] == ' ' || spaces[i] == 0xa0 /* non-breaking space */)
1922     {
1923       /* Non-breaking space and regular spaces work */
1924       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,5,0,3);
1925       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
1926       EXPECTRGB(4,FAILDIG);
1927     }
1928     else
1929     {
1930       /* But not other spaces */
1931       EXPECTFAIL;
1932     }
1933
1934     winetest_pop_context();
1935   }
1936
1937   /* With flag and decimal point, thousands sep. but not decimals consumed */
1938   CONVERT("1 001,0", NUMPRS_THOUSANDS);
1939   EXPECT(4,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,0);
1940   EXPECT2(1,0);
1941   EXPECTRGB(2,0);
1942   EXPECTRGB(3,1);
1943   EXPECTRGB(4,FAILDIG);
1944
1945   /* With flag, consecutive thousands separators are allowed */
1946   CONVERT("1  000", NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
1947   EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,6,0,3);
1948   EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
1949   EXPECTRGB(4,FAILDIG);
1950
1951   /* With flag, thousands separators can be sprinkled at random */
1952   CONVERT("1 00 0  ", NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
1953   EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,8,0,3);
1954   EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
1955   EXPECTRGB(4,FAILDIG);
1956
1957   /* With flag, but leading thousands separators are not allowed */
1958   CONVERT(" 1 000", NUMPRS_THOUSANDS);
1959   EXPECTFAIL;
1960
1961   /* With flag, thousands separator not needed but still reported */
1962   CONVERT("1 ", NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
1963   EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,2,0,0);
1964   EXPECT2(1,FAILDIG);
1965
1966
1967   /** NUMPRS_CURRENCY **/
1968
1969   /* With flag, consumes currency sign "E12" */
1970   WCONVERT(L"\x20ac\x31\x32", NUMPRS_CURRENCY);
1971   EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1972   EXPECT2(1,2);
1973   EXPECTRGB(2,FAILDIG);
1974
1975   /* With flag, consumes all currency signs! "E12EE" */
1976   WCONVERT(L"\x20ac\x31\x32\x20ac\x20ac", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
1977   EXPECT(2,NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_CURRENCY,5,0,0);
1978   EXPECT2(1,2);
1979   EXPECTRGB(2,FAILDIG);
1980
1981   /* The presence of a trailing currency sign changes nothing for spaces */
1982   for (i = 0; i < ARRAY_SIZE(spaces)-1; i++)
1983   {
1984     winetest_push_context("%d", i);
1985
1986     /* With flag, no space is allowed before the currency sign "12 E" */
1987     wsprintfW(wstr, L"12%c\x20ac", spaces[i]);
1988     WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_USE_ALL);
1989     EXPECTFAIL;
1990
1991     /* With flag, even if explicitly allowed "12 E" */
1992     WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL);
1993     if (spaces[i] == ' ' || spaces[i] == 0xa0 /* non-breaking space */)
1994     {
1995       /* Spaces aliased to thousands separator are never allowed! */
1996       EXPECTFAIL;
1997     }
1998     else
1999     {
2000       /* The others behave normally */
2001       EXPECT(2,NUMPRS_CURRENCY|NUMPRS_TRAILING_WHITE|NUMPRS_USE_ALL,NUMPRS_CURRENCY|NUMPRS_TRAILING_WHITE,4,0,0);
2002       EXPECT2(1,2);
2003       EXPECTRGB(2,FAILDIG);
2004     }
2005
2006     WCONVERT(wstr, NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_USE_ALL);
2007     if (spaces[i] == ' ' || spaces[i] == 0xa0 /* non-breaking space */)
2008     {
2009       /* Spaces aliased to thousands separator are never allowed! */
2010       EXPECT(2,NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,4,0,0);
2011       EXPECT2(1,2);
2012       EXPECTRGB(2,FAILDIG);
2013     }
2014     else
2015     {
2016       /* The others behave normally */
2017       EXPECTFAIL;
2018     }
2019
2020     winetest_pop_context();
2021   }
2022
2023   /* With flag only, doesn't consume decimal point */
2024   WCONVERT(L"12,1\x20ac", NUMPRS_CURRENCY);
2025   EXPECT(2,NUMPRS_CURRENCY,0,2,0,0);
2026   EXPECT2(1,2);
2027   EXPECTRGB(2,FAILDIG);
2028
2029   /* The three-letter Euro abbreviation is not allowed */
2030   WCONVERT(L"12EUR", NUMPRS_CURRENCY);
2031   EXPECT(2,NUMPRS_CURRENCY,0,2,0,0);
2032   EXPECT2(1,2);
2033   EXPECTRGB(2,FAILDIG);
2034
2035   /* With flag and decimal flag, consumes decimal point and following digits */
2036   WCONVERT(L"12,1\x20ac", NUMPRS_CURRENCY|NUMPRS_DECIMAL|NUMPRS_USE_ALL);
2037   EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL|NUMPRS_USE_ALL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
2038   EXPECT2(1,2);
2039   EXPECTRGB(2,1);
2040   EXPECTRGB(3,FAILDIG);
2041
2042   /* Thousands flag can also be used with currency */
2043   WCONVERT(L"1 234,5 \x20ac", NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_USE_ALL);
2044   EXPECT(5,NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_USE_ALL,NUMPRS_CURRENCY|NUMPRS_THOUSANDS|NUMPRS_DECIMAL,9,0,-1);
2045   EXPECT2(1,2);
2046   EXPECTRGB(2,3);
2047   EXPECTRGB(3,4);
2048   EXPECTRGB(4,5);
2049   EXPECTRGB(5,FAILDIG);
2050
2051
2052   /** NUMPRS_DECIMAL **/
2053
2054   /* With flag, consumes decimal point */
2055   CONVERT("1,2", NUMPRS_DECIMAL);
2056   EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
2057   EXPECT2(1,2);
2058   EXPECTRGB(2,FAILDIG);
2059
2060   /* With flag, but not regular point */
2061   CONVERT("1.2", NUMPRS_DECIMAL);
2062   EXPECT(1,NUMPRS_DECIMAL,0,1,0,0);
2063   EXPECT2(1,FAILDIG);
2064
2065   /* The integer part can still be omitted */
2066   CONVERT(",2", NUMPRS_DECIMAL);
2067   EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,-1);
2068   EXPECT2(2,FAILDIG);
2069
2070   CONVERT(".2", NUMPRS_DECIMAL);
2071   EXPECTFAIL;
2072 }
2073
2074 static void test_VarParseNumFromStrMisc(void)
2075 {
2076   HRESULT hres;
2077   LCID lcid;
2078   NUMPARSE np;
2079   BYTE rgb[128];
2080   OLECHAR currency[8], t1000[8], mont1000[8], dec[8], mondec[8];
2081
2082   /* Customize the regional settings to perform extra tests */
2083
2084   if (GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, currency, ARRAY_SIZE(currency)) &&
2085       GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, t1000, ARRAY_SIZE(t1000)) &&
2086       GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, mont1000, ARRAY_SIZE(mont1000)) &&
2087       GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, dec, ARRAY_SIZE(dec)) &&
2088       GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, mondec, ARRAY_SIZE(mondec)))
2089   {
2090       /* Start from a known configuration */
2091       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, L"$");
2092       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L",");
2093       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L",");
2094       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, L".");
2095       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L".");
2096
2097       /* SCURRENCY defaults to '$' */
2098       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, L"");
2099       hres = wconvert_str(L"$1", ARRAY_SIZE(rgb), NUMPRS_CURRENCY, &np, rgb, LOCALE_USER_DEFAULT, 0);
2100       EXPECT(1,NUMPRS_CURRENCY,NUMPRS_CURRENCY,2,0,0);
2101       EXPECT2(1,FAILDIG);
2102       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, L"$");
2103
2104       /* STHOUSAND has no default */
2105       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L"~");
2106       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L"");
2107       hres = wconvert_str(L"1,000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2108       EXPECTFAIL;
2109       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L"~");
2110
2111       /* But SMONTHOUSANDSEP defaults to ','! */
2112       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L"");
2113       hres = wconvert_str(L"$1,000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY, &np, rgb, LOCALE_USER_DEFAULT, 0);
2114       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,6,0,3);
2115       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2116       EXPECTRGB(4,FAILDIG);
2117       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L",");
2118       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L",");
2119
2120       /* SDECIMAL defaults to '.' */
2121       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L"~");
2122       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, L"");
2123       hres = wconvert_str(L"4.2", ARRAY_SIZE(rgb), NUMPRS_DECIMAL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2124       EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
2125       EXPECT2(4,2);
2126       EXPECTRGB(2,FAILDIG);
2127       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, L"~");
2128
2129       /* But SMONDECIMALSEP has no default! */
2130       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L"");
2131       hres = wconvert_str(L"3.9", ARRAY_SIZE(rgb), NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2132       EXPECTFAIL;
2133       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, L".");
2134       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L".");
2135
2136       /* Non-breaking spaces are not allowed if sThousand is a regular space */
2137       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L" ");
2138
2139       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS, &np, rgb, LOCALE_USER_DEFAULT, 0);
2140       EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
2141       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2142       EXPECTRGB(4,FAILDIG);
2143
2144       hres = wconvert_str(L"1\xa0\x30\x30\x30", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2145       EXPECTFAIL;
2146
2147
2148       /* Show that NUMPRS_THOUSANDS activates sThousand and that
2149        * NUMPRS_THOUSANDS+NUMPRS_CURRENCY activates sMonThousandSep
2150        * whether a currency sign is present or not. Also the presence of
2151        * sMonThousandSep flags the value as being a currency.
2152        */
2153       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L"|");
2154       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L" ");
2155
2156       hres = wconvert_str(L"1|000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS, &np, rgb, LOCALE_USER_DEFAULT, 0);
2157       EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
2158       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2159       EXPECTRGB(4,FAILDIG);
2160
2161       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2162       EXPECTFAIL;
2163
2164       hres = wconvert_str(L"1|000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY, &np, rgb, LOCALE_USER_DEFAULT, 0);
2165       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,NUMPRS_THOUSANDS,5,0,3);
2166       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2167       EXPECTRGB(4,FAILDIG);
2168
2169       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2170       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,5,0,3);
2171       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2172       EXPECTRGB(4,FAILDIG);
2173
2174
2175       /* Leading sMonThousandSep are not allowed (same as sThousand) */
2176       hres = wconvert_str(L" 1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2177       EXPECTFAIL;
2178
2179       /* But trailing ones are allowed (same as sThousand) */
2180       hres = wconvert_str(L"1 000 ", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2181       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,6,0,3);
2182       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2183       EXPECTRGB(4,FAILDIG);
2184
2185       /* And they break NUMPRS_TRAILING_WHITE (same as sThousand) */
2186       hres = wconvert_str(L"1000 ", ARRAY_SIZE(rgb), NUMPRS_TRAILING_WHITE|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2187       EXPECTFAIL;
2188
2189
2190       /* NUMPRS_CURRENCY is not enough for sMonThousandSep */
2191       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2192       EXPECTFAIL;
2193
2194
2195       /* Even with a currency sign, the regular thousands separator works */
2196       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, L"$");
2197       /* Make sure SMONDECIMALSEP is not the currency sign (see the
2198        * Cape Verdean escudo comment).
2199        */
2200       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L"/");
2201       hres = wconvert_str(L"$1|000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2202       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,6,0,3);
2203       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2204       EXPECTRGB(4,FAILDIG);
2205
2206       /* Mixing both thousands separators is allowed */
2207       hres = wconvert_str(L"1 000|000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2208       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,9,0,6);
2209       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2210       EXPECTRGB(7,FAILDIG);
2211
2212
2213       /* SMONTHOUSANDSEP does not consider regular spaces to be equivalent to
2214        * non-breaking spaces!
2215        */
2216       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L"\xa0");
2217       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2218       EXPECTFAIL;
2219
2220       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L"\xa0");
2221       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2222       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,5,0,3);
2223       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2224       EXPECTRGB(4,FAILDIG);
2225
2226
2227       /* Regular thousands separators also have precedence over the currency ones */
2228       hres = wconvert_str(L"1\xa0\x30\x30\x30", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2229       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,5,0,3);
2230       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2231       EXPECTRGB(4,FAILDIG);
2232
2233
2234       /* Show that the decimal separator masks the thousands one in all
2235        * positions, sometimes even without NUMPRS_DECIMAL.
2236        */
2237       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L",");
2238       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L"~");
2239       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, L",");
2240       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L"~");
2241
2242       hres = wconvert_str(L",1", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_DECIMAL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2243       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,-1);
2244       EXPECT2(1,FAILDIG);
2245
2246       hres = wconvert_str(L"1,000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2247       EXPECTFAIL;
2248
2249       hres = wconvert_str(L"1,", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2250       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_USE_ALL,NUMPRS_DECIMAL,2,0,0);
2251       EXPECT2(1,FAILDIG);
2252
2253       /* But not for their monetary equivalents */
2254       hres = wconvert_str(L"~1", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_CURRENCY, &np, rgb, LOCALE_USER_DEFAULT, 0);
2255       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_CURRENCY,NUMPRS_DECIMAL|NUMPRS_CURRENCY,2,0,-1);
2256       EXPECT2(1,FAILDIG);
2257
2258       hres = wconvert_str(L"1~", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2259       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_THOUSANDS|NUMPRS_CURRENCY,2,0,0);
2260       EXPECT2(1,FAILDIG);
2261
2262
2263       /* Only the first sThousand character is used (sigh of relief) */
2264       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, L" \xa0");
2265       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, L" \xa0");
2266
2267       hres = wconvert_str(L"1 000", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2268       EXPECT(1,NUMPRS_THOUSANDS|NUMPRS_USE_ALL,NUMPRS_THOUSANDS,5,0,3);
2269       EXPECTRGB(0,1); /* Don't test extra digits, see "1,000" test */
2270       EXPECTRGB(4,FAILDIG);
2271
2272       hres = wconvert_str(L"1\xa0\x30\x30\x30", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2273       EXPECTFAIL;
2274
2275       hres = wconvert_str(L"1 \xa0\x30\x30\x30", ARRAY_SIZE(rgb), NUMPRS_THOUSANDS|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2276       EXPECTFAIL;
2277
2278
2279       /* Show that the currency decimal separator is active even without
2280        * NUMPRS_CURRENCY.
2281        */
2282       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, L".");
2283       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L",");
2284
2285       hres = wconvert_str(L"1.2", ARRAY_SIZE(rgb), NUMPRS_DECIMAL|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2286       EXPECT(2,NUMPRS_DECIMAL|NUMPRS_USE_ALL,NUMPRS_DECIMAL,3,0,-1);
2287       EXPECT2(1,2);
2288       EXPECTRGB(2,FAILDIG);
2289
2290       hres = wconvert_str(L"1,2", ARRAY_SIZE(rgb), NUMPRS_DECIMAL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2291       EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL|NUMPRS_CURRENCY,3,0,-1);
2292       EXPECT2(1,2);
2293       EXPECTRGB(2,FAILDIG);
2294
2295       hres = wconvert_str(L"1.2", ARRAY_SIZE(rgb), NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2296       EXPECT(2,NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_DECIMAL,3,0,-1);
2297       EXPECT2(1,2);
2298       EXPECTRGB(2,FAILDIG);
2299
2300       hres = wconvert_str(L"1,2", ARRAY_SIZE(rgb), NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2301       EXPECT(2,NUMPRS_DECIMAL|NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_DECIMAL|NUMPRS_CURRENCY,3,0,-1);
2302       EXPECT2(1,2);
2303       EXPECTRGB(2,FAILDIG);
2304
2305       hres = wconvert_str(L"1.2,3", ARRAY_SIZE(rgb), NUMPRS_DECIMAL|NUMPRS_CURRENCY, &np, rgb, LOCALE_USER_DEFAULT, 0);
2306       EXPECT(2,NUMPRS_DECIMAL|NUMPRS_CURRENCY,NUMPRS_DECIMAL,3,0,-1);
2307       EXPECT2(1,2);
2308       EXPECTRGB(2,FAILDIG);
2309
2310       hres = wconvert_str(L"1,2.3", ARRAY_SIZE(rgb), NUMPRS_DECIMAL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2311       EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL|NUMPRS_CURRENCY,3,0,-1);
2312       EXPECT2(1,2);
2313       EXPECTRGB(2,FAILDIG);
2314
2315
2316       /* In some locales the decimal separator is the currency sign.
2317        * For instance the Cape Verdean escudo.
2318        */
2319       SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, L"$");
2320       hres = wconvert_str(L"1$99", ARRAY_SIZE(rgb), NUMPRS_DECIMAL|NUMPRS_USE_ALL, &np, rgb, LOCALE_USER_DEFAULT, 0);
2321       EXPECT(3,NUMPRS_DECIMAL|NUMPRS_USE_ALL,NUMPRS_DECIMAL|NUMPRS_CURRENCY,4,0,-2);
2322       EXPECT2(1,9);
2323       EXPECTRGB(2,9);
2324       EXPECTRGB(3,FAILDIG);
2325
2326
2327       /* Restore all the settings */
2328       ok(SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SCURRENCY, currency), "Restoring SCURRENCY failed\n");
2329       ok(SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, t1000), "Restoring STHOUSAND failed\n");
2330       ok(SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHOUSANDSEP, mont1000), "Restoring SMONTHOUSANDSEP failed\n");
2331       ok(SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, dec), "Restoring SDECIMAL failed\n");
2332       ok(SetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONDECIMALSEP, mondec), "Restoring SMONDECIMALSEP failed\n");
2333   }
2334
2335
2336   /* Test currencies of various lengths */
2337
2338   /* 2 Polish zloty */
2339   lcid = MAKELCID(MAKELANGID(LANG_POLISH,SUBLANG_POLISH_POLAND),SORT_DEFAULT);
2340   WCONVERT(L"z\x142\x32", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
2341   EXPECT(1,NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_CURRENCY,3,0,0);
2342   EXPECT2(2,FAILDIG);
2343
2344   /* Multi-character currencies can be repeated too "zl2zlzl" */
2345   WCONVERT(L"z\x142\x32z\x142z\x142", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
2346   EXPECT(1,NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_CURRENCY,7,0,0);
2347   EXPECT2(2,FAILDIG);
2348
2349   lcid = MAKELCID(MAKELANGID(LANG_FRENCH,SUBLANG_FRENCH_SWISS),SORT_DEFAULT);
2350   WCONVERT(L"3CHF", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
2351   /* Windows <= 8.1 uses an old currency symbol: "fr. 5" */
2352   ok(hres == S_OK || broken(hres == DISP_E_TYPEMISMATCH), "returned %08lx\n", hres);
2353   if (hres == S_OK)
2354   {
2355     EXPECT(1,NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_CURRENCY,4,0,0);
2356     EXPECT2(3,FAILDIG);
2357   }
2358
2359   /* 5 Moroccan dirham */
2360   lcid = MAKELCID(MAKELANGID(LANG_ARABIC,SUBLANG_ARABIC_MOROCCO),SORT_DEFAULT);
2361   WCONVERT(L"5\x62f.\x645.\x200f", NUMPRS_CURRENCY|NUMPRS_USE_ALL);
2362   /* Windows 8.1 incorrectly doubles the right-to-left mark:
2363    * "\x62f.\x645.\x200f\x200f 5"
2364    */
2365   ok(hres == S_OK || broken(hres == DISP_E_TYPEMISMATCH), "returned %08lx\n", hres);
2366   if (hres == S_OK)
2367   {
2368     EXPECT(1,NUMPRS_CURRENCY|NUMPRS_USE_ALL,NUMPRS_CURRENCY,6,0,0);
2369     EXPECT2(5,FAILDIG);
2370   }
2371
2372
2373   /* Test Arabic numerals in an Arabic locale */
2374
2375   lcid = MAKELCID(MAKELANGID(LANG_ARABIC,SUBLANG_ARABIC_MOROCCO),SORT_DEFAULT);
2376   WCONVERT(L"\x660", NUMPRS_STD);
2377   EXPECTFAIL;
2378 }
2379
2380 /* Macros for converting and testing the result of VarNumFromParseNum */
2381 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
2382 #undef CONVERT
2383 #define CONVERT(a,b,c,d,e,f,bits) \
2384     np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
2385     np.nBaseShift = (e); np.nPwr10 = (f); hres = VarNumFromParseNum(&np, rgb, bits, &vOut)
2386 static const char *szFailOverflow = "Expected overflow, hres = %08x\n";
2387 #define EXPECT_OVERFLOW ok(hres == DISP_E_OVERFLOW, szFailOverflow, hres)
2388 static const char *szFailOk = "Call failed, hres = %08x\n";
2389 #define EXPECT_OK ok(hres == S_OK, szFailOk, hres); \
2390   if (hres == S_OK)
2391 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
2392 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
2393   ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
2394 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
2395   ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
2396 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
2397   ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
2398 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
2399   ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
2400 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
2401   ok(V_I4(&vOut) == val, "Expected i4 = %ld, got %ld\n", (LONG)val, V_I4(&vOut)); }
2402 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
2403   ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
2404 #define EXPECT_I8(val) EXPECT_OK { EXPECT_TYPE(VT_I8); \
2405   ok(V_I8(&vOut) == val, "Expected i8 = %#I64x, got %#I64x\n", (LONG64)val, V_I8(&vOut)); }
2406 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
2407   ok(V_UI8(&vOut) == val, "Expected ui8 = %#I64x, got %#I64x\n", (ULONG64)val, V_UI8(&vOut); }
2408 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
2409   ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
2410 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
2411   ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
2412 #define CY_MULTIPLIER 10000
2413 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
2414   ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = %#I64x, got %#I64x\n", \
2415      (LONG64)val, V_CY(&vOut).int64); }
2416 #define EXPECT_DECIMAL(valHi, valMid, valLo) EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
2417       ok(V_DECIMAL(&vOut).Hi32 == valHi && V_DECIMAL(&vOut).Mid32 == valMid && \
2418       V_DECIMAL(&vOut).Lo32 == valLo, \
2419   "Expected decimal = %x/0x%x%08x, got %lx/0x%lx%08lx\n", valHi, valMid, valLo, \
2420       V_DECIMAL(&vOut).Hi32, V_DECIMAL(&vOut).Mid32, V_DECIMAL(&vOut).Lo32); }
2421
2422 static void test_VarNumFromParseNum(void)
2423 {
2424   HRESULT hres;
2425   NUMPARSE np;
2426   BYTE rgb[128];
2427   VARIANT vOut;
2428
2429   /* Convert the number 1 to different types */
2430   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
2431   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
2432   /* Prefers a signed type to unsigned of the same size */
2433   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
2434   /* But takes the smaller size if possible */
2435   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
2436
2437   /* Try different integer sizes */
2438 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
2439
2440   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
2441   /* 127 */
2442   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
2443   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
2444   /* 128 */
2445   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
2446   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
2447   /* 255 */
2448   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
2449   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
2450   /* 256 */
2451   SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
2452   CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
2453   /* 32767 */
2454   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
2455   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
2456   /* 32768 */
2457   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
2458   CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
2459
2460   /* Assume the above pattern holds for remaining positive integers; test negative */
2461
2462   /* -128 */
2463   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
2464   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
2465   /* -129 */
2466   SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
2467   CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
2468   /* -32768 */
2469   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
2470   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
2471   /* -32768 */
2472   SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
2473   CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
2474
2475   /* Assume the above pattern holds for remaining negative integers */
2476
2477   /* Test hexadecimal conversions */
2478   SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
2479   /* 0x7f */
2480   SETRGB(0, 7); SETRGB(1, 0xf);
2481   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
2482   SETRGB(0, 7); SETRGB(1, 0xf);
2483   CONVERT(2,0,0,2,4,0, VTBIT_DECIMAL); EXPECT_DECIMAL(0,0,0x7f);
2484   /* 0x7fff */
2485   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
2486   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
2487   /* 0x7fffffff */
2488   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
2489   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
2490   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
2491   /* 0x7fffffffffffffff (64 bits) */
2492   SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
2493   SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
2494   SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
2495   SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
2496   if (has_i8)
2497   {
2498     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
2499        truncate the number to the smallest integer size requested:
2500        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
2501     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffffffffffffull);
2502   }
2503
2504   /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
2505   /* 0x82 */
2506   SETRGB(0, 8); SETRGB(1, 2);
2507   CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
2508   EXPECT_I1((signed char)0x82);
2509   /* 0x8002 */
2510   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
2511   CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
2512   EXPECT_I2((signed short)0x8002);
2513   /* 0x80000002 */
2514   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
2515   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
2516   CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
2517   /* 0x8000000000000002 (64 bits) */
2518   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
2519   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
2520   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
2521   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
2522   if (has_i8)
2523   {
2524     /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
2525        truncate the number to the smallest integer size requested:
2526        CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
2527        EXPECT_I2((signed short)0x0002); */
2528     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x8000000000000002ull);
2529   }
2530
2531   /* Test (preservation of) hi-bit with STRICT type requesting */
2532   /* 0x82 */
2533   SETRGB(0, 8); SETRGB(1, 2);
2534   CONVERT(2,0,0,2,4,0, VTBIT_I1);
2535   EXPECT_I1((signed char)0x82);
2536   /* 0x8002 */
2537   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
2538   CONVERT(4,0,0,4,4,0, VTBIT_I2);
2539   EXPECT_I2((signed short)0x8002);
2540   /* 0x80000002 */
2541   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
2542   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
2543   CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
2544   /* 0x8000000000000002 (64 bits) */
2545   SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
2546   SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
2547   SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
2548   SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
2549   if (has_i8)
2550   {
2551     CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x8000000000000002ull);
2552   }
2553   /* Assume the above pattern holds for numbers with hi-bit set */
2554
2555   /* Negative numbers overflow if we have only unsigned outputs */
2556   /* -1 */
2557   SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
2558   /* -0.6 */
2559   SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
2560
2561   /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
2562   /* -0.5 */
2563   SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
2564
2565   /* Floating point zero is OK */
2566   /* 0.00000000E0 */
2567   SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
2568   EXPECT_R8(0.0);
2569
2570   /* Float is acceptable for an integer input value */
2571   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
2572   /* As is double */
2573   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
2574   /* As is currency */
2575   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
2576
2577   /* Float is preferred over double */
2578   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
2579
2580   /* Double is preferred over currency */
2581   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
2582
2583   /* Currency is preferred over decimal */
2584   SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
2585
2586   /* Underflow test */
2587   SETRGB(0, 1); CONVERT(1,0,NUMPRS_EXPONENT,1,0,-94938484, VTBIT_R4); EXPECT_R4(0.0);
2588   SETRGB(0, 1); CONVERT(1,0,NUMPRS_EXPONENT,1,0,-94938484, VTBIT_R8); EXPECT_R8(0.0);
2589   SETRGB(0, 1); CONVERT(1,0,NUMPRS_EXPONENT,1,0,-94938484, VTBIT_CY); EXPECT_CY(0);
2590 }
2591
2592
2593 static void test_UdateFromDate( int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y,
2594                                 WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)
2595 {
2596     UDATE ud;
2597     HRESULT res;
2598
2599     memset(&ud, 0, sizeof(ud));
2600     res = VarUdateFromDate(dt, flags, &ud);
2601     ok_(__FILE__,line)(r == res && (res != S_OK || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
2602                        ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
2603                        ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)),
2604                        "%.16g expected res(%lx) %d,%d,%d,%d,%d,%d,%d  %d %d, got res(%lx) %d,%d,%d,%d,%d,%d,%d  %d %d\n",
2605                        dt, r, d, m, y, h, mn, s, ms, dw, dy,
2606                        res, ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
2607                        ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
2608 }
2609 #define DT2UD(dt,flags,r,d,m,y,h,mn,s,ms,dw,dy) test_UdateFromDate(__LINE__,dt,flags,r,d,m,y,h,mn,s,ms,dw,dy)
2610
2611 static void test_VarUdateFromDate(void)
2612 {
2613   DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1);        /* 1 Jan 1980 */
2614   DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2);        /* 2 Jan 1980 */
2615   DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365);    /* 31 Dec 1990 */
2616   DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364);        /* 30 Dec 1899 - VT_DATE 0.0 */
2617   DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1);       /* 1 Jan 100 - Min */
2618   DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
2619   DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365);  /* 31 Dec 9999 - Max */
2620   DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err  */
2621
2622   /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
2623   DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
2624   DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
2625
2626   /* Times */
2627   DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1);           /* 6 AM */
2628   DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1);     /* 8 AM */
2629   DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1);           /* 12 AM */
2630   DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
2631   DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
2632
2633   /* Test handling of times on dates prior to the epoch */
2634   DT2UD(-5.25,0,S_OK,25,12,1899,6,0,0,0,1,359);
2635   DT2UD(-5.9999884259259,0,S_OK,25,12,1899,23,59,59,0,1,359);
2636   /* This just demonstrates the non-linear nature of values prior to the epoch */
2637   DT2UD(-4.0,0,S_OK,26,12,1899,0,0,0,0,2,360);
2638   /* Numerical oddity: for 0.0 < x < 1.0, x and -x represent the same datetime */
2639   DT2UD(-0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
2640   DT2UD(0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
2641 }
2642
2643
2644 static void test_DateFromUDate( int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms,
2645                                 WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt )
2646 {
2647     UDATE ud;
2648     double out;
2649     HRESULT res;
2650
2651     ud.st.wYear = y;
2652     ud.st.wMonth = m;
2653     ud.st.wDay = d;
2654     ud.st.wHour = h;
2655     ud.st.wMinute = mn;
2656     ud.st.wSecond = s;
2657     ud.st.wMilliseconds = ms;
2658     ud.st.wDayOfWeek = dw;
2659     ud.wDayOfYear = dy;
2660     res = VarDateFromUdate(&ud, flags, &out);
2661     ok_(__FILE__,line)(r == res && (r != S_OK || EQ_DOUBLE(out, dt)),
2662                        "expected %lx, %.16g, got %lx, %.16g\n", r, dt, res, out);
2663 }
2664 #define UD2T(d,m,y,h,mn,s,ms,dw,dy,flags,r,dt) test_DateFromUDate(__LINE__,d,m,y,h,mn,s,ms,dw,dy,flags,r,dt)
2665
2666 static void test_VarDateFromUdate(void)
2667 {
2668   UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0);      /* 1 Jan 1980 */
2669   UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0);      /* 2 Jan 1980 */
2670   UD2T(2,1,1980,0,0,0,0,4,5,0,S_OK,29222.0);      /* 2 Jan 1980 */
2671   UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0);    /* 31 Dec 1990 */
2672   UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0);      /* year < 100 is 1900+year! */
2673   UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0);      /* 30 Dec 1899 - VT_DATE 0.0 */
2674   UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0);     /* 1 Jan 100 - Min */
2675   UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0);  /* 31 Dec 9999 - Max */
2676   UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err  */
2677   UD2T(1,1,-10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0);/* < -9999 => err  */
2678
2679   UD2T(30,12,1899,0,0,0,0,0,0,0,S_OK,0.0); /* 30 Dec 1899 0:00:00  */
2680   UD2T(30,12,1899,0,0,0,999,0,0,0,S_OK,0.0); /* Ignore milliseconds  */
2681
2682   UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963);             /* 6:18:02 PM */
2683   UD2T(1,300,1980,18,1,16,0,2,1,0,S_OK,38322.75087962963);           /* Test fwdrolled month */
2684   UD2T(300,1,1980,18,1,16,0,2,1,0,S_OK,29520.75087962963);           /* Test fwdrolled days */
2685   UD2T(0,1,1980,42,1,16,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled hours */
2686   UD2T(1,1,1980,17,61,16,0,2,1,0,S_OK,29221.75087962963);            /* Test fwdrolled minutes */
2687   UD2T(1,1,1980,18,0,76,0,2,1,0,S_OK,29221.75087962963);             /* Test fwdrolled seconds */
2688   UD2T(1,-300,1980,18,1,16,0,2,1,0,S_OK,20059.75087962963);          /* Test backrolled month */
2689   UD2T(-300,1,1980,18,1,16,0,2,1,0,S_OK,28920.75087962963);          /* Test backrolled days */
2690   UD2T(3,1,1980,-30,1,16,0,2,1,0,S_OK,29221.75087962963);            /* Test backrolled hours */
2691   UD2T(1,1,1980,20,-119,16,0,2,1,0,S_OK,29221.75087962963);          /* Test backrolled minutes */
2692   UD2T(1,1,1980,18,3,-104,0,2,1,0,S_OK,29221.75087962963);           /* Test backrolled seconds */
2693   UD2T(1,12001,-1020,18,1,16,0,0,0,0,S_OK,29221.75087962963);        /* Test rolled year and month */
2694   UD2T(1,-23,1982,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled month */
2695   UD2T(-59,3,1980,18,1,16,0,0,0,0,S_OK,29221.75087962963);           /* Test backrolled days */
2696   UD2T(1,1,0,0,0,0,0,0,0,0,S_OK,36526);                              /* Test zero year */
2697   UD2T(0,0,1980,0,0,0,0,0,0,0,S_OK,29189);                           /* Test zero day and month */
2698   UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0);                         /* Test zero day = LastDayOfMonth */
2699   UD2T(-1,1,1980,18,1,16,0,0,0,0,S_OK,29219.75087962963);            /* Test day -1 = LastDayOfMonth - 1 */
2700   UD2T(1,1,-1,18,1,16,0,0,0,0,S_OK,36161.75087962963);               /* Test year -1 = 1999 */
2701   UD2T(1,-1,1980,18,1,16,0,0,0,0,S_OK,29160.7508796296);             /* Test month -1 = 11 */
2702   UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0);                        /* Rolls fwd to 1/1/1981 */
2703
2704   /* Test handling of times on dates prior to the epoch */
2705   UD2T(25,12,1899,6,0,0,0,1,359,0,S_OK,-5.25);
2706   UD2T(25,12,1899,23,59,59,0,1,359,0,S_OK,-5.9999884259259);
2707   /* This just demonstrates the non-linear nature of values prior to the epoch */
2708   UD2T(26,12,1899,0,0,0,0,2,360,0,S_OK,-4.0);
2709   /* for DATE values 0.0 < x < 1.0, x and -x represent the same datetime */
2710   /* but when converting to DATE, prefer the positive versions */
2711   UD2T(30,12,1899,6,0,0,0,6,364,0,S_OK,0.25);
2712
2713   UD2T(1,1,1980,18,1,16,0,2,1,VAR_TIMEVALUEONLY,S_OK,0.7508796296296296);
2714   UD2T(1,1,1980,18,1,16,0,2,1,VAR_DATEVALUEONLY,S_OK,29221.0);
2715   UD2T(25,12,1899,6,0,0,0,1,359,VAR_TIMEVALUEONLY,S_OK,0.25);
2716   UD2T(25,12,1899,6,0,0,0,1,359,VAR_DATEVALUEONLY,S_OK,-5.0);
2717   UD2T(1,-1,1980,18,1,16,0,0,0,VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY,S_OK,0.7508796296296296);
2718 }
2719
2720 static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
2721                        WORD s, WORD ms, INT r, double dt, double dt2)
2722 {
2723     SYSTEMTIME st;
2724     double out;
2725     INT res;
2726
2727     st.wYear = y;
2728     st.wMonth = m;
2729     st.wDay = d;
2730     st.wHour = h;
2731     st.wMinute = mn;
2732     st.wSecond = s;
2733     st.wMilliseconds = ms;
2734     st.wDayOfWeek = 0;
2735     res = SystemTimeToVariantTime(&st, &out);
2736     ok_(__FILE__,line)(r == res, "expected %d, got %d\n", r, res);
2737     if (r && res)
2738         ok_(__FILE__,line)(EQ_DOUBLE(out, dt) || (dt2 && broken(EQ_DOUBLE(out, dt2))),
2739                            "expected %.16g or %.16g, got %.16g\n", dt, dt2, out);
2740 }
2741 #define ST2DT(d,m,y,h,mn,s,ms,r,dt,dt2) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt,dt2)
2742
2743 static void test_SystemTimeToVariantTime(void)
2744 {
2745   ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0,0.0);
2746   ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0,0.0);
2747   ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0,0.0);   /* Rolls back to 31 Dec 1899 */
2748   ST2DT(1,13,1980,0,0,0,0,FALSE,0.0,0.0);     /* Fails on invalid month */
2749   ST2DT(32,1,1980,0,0,0,0,FALSE,0.0,0.0);     /* Fails on invalid day */
2750   ST2DT(1,1,-1,0,0,0,0,FALSE,0.0,0.0);        /* Fails on invalid year */
2751   ST2DT(1,1,10000,0,0,0,0,FALSE,0.0,0.0);     /* Fails on invalid year */
2752   ST2DT(1,1,9999,0,0,0,0,TRUE,2958101.0,0.0); /* 9999 is last valid year */
2753
2754   /* Old Windows versions use 29 as the Y2K cutoff:
2755    * years 00-29 map to 2000-2029 while years 30-99 map to 1930-1999
2756    */
2757   ST2DT(1,1,0,0,0,0,0,TRUE,36526.0,0.0);
2758   ST2DT(1,1,29,0,0,0,0,TRUE,47119.0,0.0);
2759   ST2DT(1,1,30,0,0,0,0,TRUE,47484.0,10959.0);
2760   /* But Windows 1903+ uses 49 as the Y2K cutoff */
2761   ST2DT(1,1,49,0,0,0,0,TRUE,54424.0,17899.0);
2762   ST2DT(1,1,50,0,0,0,0,TRUE,18264.0,0.0);
2763   ST2DT(31,12,99,0,0,0,0,TRUE,36525.0,0.0);
2764 }
2765
2766 static void test_dt2st(int line, double dt, INT r, WORD d, WORD m, WORD y,
2767                        WORD h, WORD mn, WORD s, WORD ms)
2768 {
2769   SYSTEMTIME st;
2770   INT res;
2771
2772   memset(&st, 0, sizeof(st));
2773   res = VariantTimeToSystemTime(dt, &st);
2774   ok_(__FILE__,line)(r == res &&
2775                      (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
2776                              st.wHour == h && st.wMinute == mn &&
2777                              st.wSecond == s && st.wMilliseconds == ms)),
2778                      "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
2779                      dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
2780                      st.wYear, st.wHour, st.wMinute, st.wSecond,
2781                      st.wMilliseconds);
2782 }
2783 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)
2784
2785 static void test_VariantTimeToSystemTime(void)
2786 {
2787     DT2ST(29221.0,1,1,1,1980,0,0,0,0);
2788     DT2ST(29222.0,1,2,1,1980,0,0,0,0);
2789 }
2790
2791 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
2792 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
2793
2794 static void test_dos2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
2795                         WORD s, INT r, double dt)
2796 {
2797     unsigned short dosDate, dosTime;
2798     double out;
2799     INT res;
2800
2801     out = 0.0;
2802     dosDate = MKDOSDATE(d, m, y);
2803     dosTime = MKDOSTIME(h, mn, s);
2804     res = DosDateTimeToVariantTime(dosDate, dosTime, &out);
2805     ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
2806                        "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
2807 }
2808 #define DOS2DT(d,m,y,h,mn,s,r,dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)
2809
2810 static void test_DosDateTimeToVariantTime(void)
2811 {
2812   /* Date */
2813   DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
2814   DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
2815   /* Dates are limited to the dos date max of 31/12/2099 */
2816   DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
2817   /* Days and months of 0 cause date to roll back 1 day or month */
2818   DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
2819   DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth =>  1/12/1979 */
2820   DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
2821   /* Days > days in the month cause date to roll forward 1 month */
2822   DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
2823   DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
2824   /* Takes leap years into account when rolling forward */
2825   DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
2826   /* Months > 12 cause an error */
2827   DOS2DT(2,13,1980,0,0,0,0,0.0);
2828
2829   /* Time */
2830   DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
2831   DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
2832   DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
2833   DOS2DT(1,1,1980,0,60,0,0,0.0);               /* Invalid minutes */
2834   DOS2DT(1,1,1980,0,0,60,0,0.0);               /* Invalid seconds */
2835   DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
2836   DOS2DT(1,1,1980,24,0,0,0,0.0);               /* Invalid hours */
2837
2838   DOS2DT(1,1,1980,0,0,1,1,29221.0);
2839   DOS2DT(2,1,1980,0,0,0,1,29222.0);
2840   DOS2DT(2,1,1980,0,0,0,1,29222.0);
2841   DOS2DT(31,12,1990,0,0,0,1,33238.0);
2842   DOS2DT(31,12,90,0,0,0,1,40543.0);
2843   DOS2DT(30,12,1899,0,0,0,1,46751.0);
2844   DOS2DT(1,1,100,0,0,0,1,43831.0);
2845   DOS2DT(31,12,9999,0,0,0,1,59901.0);
2846   DOS2DT(1,1,10000,0,0,0,1,59902.0);
2847   DOS2DT(1,1,-10000,0,0,0,1,48214.0);
2848
2849   DOS2DT(30,12,1899,0,0,0,1,46751.0);
2850   DOS2DT(30,12,1899,0,0,1,1,46751.0);
2851
2852   DOS2DT(1,1,1980,18,1,16,1,29221.75087962963);
2853   DOS2DT(1,300,1980,18,1,16,1,29556.75087962963);
2854   DOS2DT(300,1,1980,18,1,16,1,29232.75087962963);
2855   DOS2DT(0,1,1980,42,1,16,1,29220.4175462963);
2856   DOS2DT(1,1,1980,17,61,16,0,0.0);
2857   DOS2DT(1,1,1980,18,0,76,1,29221.75013888889);
2858   DOS2DT(1,-300,1980,18,1,16,1,29312.75087962963);
2859   DOS2DT(-300,1,1980,18,1,16,1,29240.75087962963);
2860   DOS2DT(3,1,1980,-30,1,16,1,29223.08421296296);
2861   DOS2DT(1,1,1980,20,-119,16,1,29221.83976851852);
2862   DOS2DT(1,1,1980,18,3,-104,1,29221.75236111111);
2863   DOS2DT(1,12001,-1020,18,1,16,1,55519.75087962963);
2864   DOS2DT(1,-23,1982,18,1,16,1,30195.75087962963);
2865   DOS2DT(-59,3,1980,18,1,16,1,29285.75087962963);
2866   DOS2DT(1,1,0,0,0,0,1,54058.0);
2867   DOS2DT(0,0,1980,0,0,0,1,29189.0);
2868   DOS2DT(0,1,1980,0,0,0,1,29220.0);
2869   DOS2DT(-1,1,1980,18,1,16,1,29251.75087962963);
2870   DOS2DT(1,1,-1,18,1,16,1,53693.75087962963);
2871   DOS2DT(1,-1,1980,18,1,16,0,0);
2872 }
2873
2874 static void test_dt2dos(int line, double dt, INT r, WORD d, WORD m, WORD y,
2875                         WORD h, WORD mn, WORD s)
2876 {
2877     unsigned short dosDate, dosTime, expDosDate, expDosTime;
2878     INT res;
2879
2880     dosTime = dosDate = 0;
2881     expDosDate = MKDOSDATE(d,m,y);
2882     expDosTime = MKDOSTIME(h,mn,s);
2883     res = VariantTimeToDosDateTime(dt, &dosDate, &dosTime);
2884     ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
2885                        "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
2886                        dt, r, expDosDate, expDosDate & 0x1f,
2887                        (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
2888                        expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
2889                        (expDosTime & 0x1f),
2890                        res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
2891                        1980 + (dosDate >> 9), dosTime, dosTime >> 11,
2892                        (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
2893 }
2894 #define DT2DOS(dt,r,d,m,y,h,mn,s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)
2895
2896 static void test_VariantTimeToDosDateTime(void)
2897 {
2898   /* Date */
2899   DT2DOS(29221.0,1,1,1,1980,0,0,0);   /* 1/1/1980 */
2900   DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
2901   DT2DOS(29220.0,0,0,0,0,0,0,0);      /* 31/12/1979 - out of range */
2902   DT2DOS(73415.0,0,0,0,0,0,0,0);      /* 31/12/2100 - out of range */
2903
2904   /* Time */
2905   DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
2906   DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
2907   DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
2908   DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
2909 }
2910
2911 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
2912
2913 #define VARABS(vt,val,rvt,rval)                  \
2914     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
2915     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2916     test_var_call1( __LINE__, pVarAbs, &v, &exp )
2917
2918 static void test_VarAbs(void)
2919 {
2920     static WCHAR szNum[] = {'-','1','.','1','\0' };
2921     char buff[8];
2922     HRESULT hres;
2923     VARIANT v, vDst, exp;
2924     size_t i;
2925
2926     CHECKPTR(VarAbs);
2927
2928     /* Test all possible V_VT values.
2929      */
2930     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
2931     {
2932         VARTYPE vt;
2933
2934         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2935         {
2936             HRESULT hExpected = DISP_E_BADVARTYPE;
2937
2938             SKIPTESTS(vt);
2939
2940             memset(&v, 0, sizeof(v));
2941             V_VT(&v) = vt | ExtraFlags[i];
2942             V_VT(&vDst) = VT_EMPTY;
2943
2944             hres = pVarAbs(&v,&vDst);
2945             if (ExtraFlags[i] & VT_ARRAY ||
2946                 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
2947                  vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
2948             {
2949                 hExpected = DISP_E_TYPEMISMATCH;
2950             }
2951             else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
2952             {
2953                 hExpected = DISP_E_BADVARTYPE;
2954             }
2955             else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
2956                 hExpected = S_OK;
2957
2958             /* Native always fails on some vartypes that should be valid. don't
2959              * check that Wine does the same; these are bugs in native.
2960              */
2961             if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
2962                 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
2963                 continue;
2964             ok(hres == hExpected, "VarAbs: expected 0x%lX, got 0x%lX for vt %d | 0x%X\n",
2965                hExpected, hres, vt, ExtraFlags[i]);
2966         }
2967     }
2968
2969     /* BOOL->I2, BSTR->R8, all others remain the same */
2970     VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
2971     VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
2972     VARABS(EMPTY,0,I2,0);
2973     VARABS(EMPTY,1,I2,0);
2974     VARABS(NULL,0,NULL,0);
2975     VARABS(NULL,1,NULL,0);
2976     VARABS(I2,1,I2,1);
2977     VARABS(I2,-1,I2,1);
2978     VARABS(I4,1,I4,1);
2979     VARABS(I4,-1,I4,1);
2980     VARABS(UI1,1,UI1,1);
2981     VARABS(R4,1,R4,1);
2982     VARABS(R4,-1,R4,1);
2983     VARABS(R8,1,R8,1);
2984     VARABS(R8,-1,R8,1);
2985     VARABS(R4,1.40129846432481707e-45,R4,1.40129846432481707e-45);
2986     VARABS(R8,4.94065645841246544e-324,R8,4.94065645841246544e-324);
2987     VARABS(DATE,1,DATE,1);
2988     VARABS(DATE,-1,DATE,1);
2989     V_VT(&v) = VT_CY;
2990     V_CY(&v).int64 = -10000;
2991     memset(&vDst,0,sizeof(vDst));
2992     hres = pVarAbs(&v,&vDst);
2993     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
2994        "VarAbs(CY): expected 0x0 got 0x%lX\n", hres);
2995     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, ARRAY_SIZE(buff));
2996     if (buff[1])
2997     {
2998         trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
2999         return;
3000     } else {
3001         szNum[2] = buff[0];
3002     }
3003     V_VT(&v) = VT_BSTR;
3004     V_BSTR(&v) = (BSTR)szNum;
3005     memset(&vDst,0,sizeof(vDst));
3006     hres = pVarAbs(&v,&vDst);
3007     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
3008        "VarAbs: expected 0x0,%d,%g, got 0x%lX,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
3009
3010     V_VT(&v) = VT_BSTR;
3011     V_BSTR(&v) = SysAllocString(L"30000");
3012     memset(&vDst,0,sizeof(vDst));
3013     hres = pVarAbs(&v,&vDst);
3014     ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 30000.0,
3015        "VarAbs: expected 0x0,%d,%g, got 0x%lX,%d,%g\n", VT_R8, 30000.0, hres, V_VT(&vDst), V_R8(&vDst));
3016     SysFreeString(V_BSTR(&v));
3017 }
3018
3019 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
3020
3021 #define VARNOT(vt,val,rvt,rval)                  \
3022     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3023     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3024     test_var_call1( __LINE__, pVarNot, &v, &exp )
3025
3026 static void test_VarNot(void)
3027 {
3028     static const WCHAR szNum0[] = {'0','\0' };
3029     static const WCHAR szNum1[] = {'1','\0' };
3030     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3031     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3032     HRESULT hres;
3033     VARIANT v, exp, vDst;
3034     DECIMAL *pdec = &V_DECIMAL(&v);
3035     CY *pcy = &V_CY(&v);
3036     size_t i;
3037
3038     CHECKPTR(VarNot);
3039
3040     /* Test all possible V_VT values */
3041     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
3042     {
3043         VARTYPE vt;
3044
3045         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3046         {
3047             HRESULT hExpected = DISP_E_BADVARTYPE;
3048
3049             SKIPTESTS(vt);
3050
3051             memset(&v, 0, sizeof(v));
3052             V_VT(&v) = vt | ExtraFlags[i];
3053             V_VT(&vDst) = VT_EMPTY;
3054
3055             switch (V_VT(&v))
3056             {
3057             case VT_I1:  case VT_UI1: case VT_I2:  case VT_UI2:
3058             case VT_INT: case VT_UINT: case VT_I4:  case VT_UI4:
3059             case VT_R4:  case VT_R8:
3060             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3061             case VT_DATE: case VT_CY:
3062                 hExpected = S_OK;
3063                 break;
3064             case VT_I8: case VT_UI8:
3065                 if (has_i8)
3066                     hExpected = S_OK;
3067                 break;
3068             case VT_RECORD:
3069                 hExpected = DISP_E_TYPEMISMATCH;
3070                 break;
3071             case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
3072                 hExpected = DISP_E_TYPEMISMATCH;
3073                 break;
3074             default:
3075                 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
3076                    hExpected = DISP_E_TYPEMISMATCH;
3077                 break;
3078             }
3079
3080             hres = pVarNot(&v,&vDst);
3081             ok(hres == hExpected, "VarNot: expected 0x%lX, got 0x%lX vt %d|0x%X\n",
3082                hExpected, hres, vt, ExtraFlags[i]);
3083         }
3084     }
3085     /* Test the values returned by all cases that can succeed */
3086     VARNOT(EMPTY,0,I2,-1);
3087     VARNOT(EMPTY,1,I2,-1);
3088     VARNOT(NULL,0,NULL,0);
3089     VARNOT(NULL,1,NULL,0);
3090     VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3091     VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3092     VARNOT(I1,-1,I4,0);
3093     VARNOT(I1,0,I4,-1);
3094     VARNOT(I2,-1,I2,0);
3095     VARNOT(I2,0,I2,-1);
3096     VARNOT(I2,1,I2,-2);
3097     VARNOT(I4,1,I4,-2);
3098     VARNOT(I4,0,I4,-1);
3099     VARNOT(UI1,1,UI1,254);
3100     VARNOT(UI1,0,UI1,255);
3101     VARNOT(UI2,0,I4,-1);
3102     VARNOT(UI2,1,I4,-2);
3103     VARNOT(UI4,0,I4,-1);
3104     VARNOT(UI4,1,I4,-2);
3105     VARNOT(INT,0,I4,-1);
3106     VARNOT(INT,1,I4,-2);
3107     VARNOT(UINT,0,I4,-1);
3108     VARNOT(UINT,1,I4,-2);
3109     if (has_i8)
3110     {
3111         VARNOT(I8,1,I8,-2);
3112         VARNOT(I8,0,I8,-1);
3113         VARNOT(UI8,0,I4,-1);
3114         VARNOT(UI8,1,I4,-2);
3115     }
3116     VARNOT(R4,1,I4,-2);
3117     VARNOT(R4,0,I4,-1);
3118     VARNOT(R8,1,I4,-2);
3119     VARNOT(R8,0,I4,-1);
3120     VARNOT(DATE,1,I4,-2);
3121     VARNOT(DATE,0,I4,-1);
3122     VARNOT(BSTR,(BSTR)szNum0,I4,-1);
3123     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
3124     VARNOT(BSTR,(BSTR)szNum1,I4,-2);
3125     ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
3126     VARNOT(BSTR, (BSTR)szTrue, BOOL, VARIANT_FALSE);
3127     VARNOT(BSTR, (BSTR)szFalse, BOOL, VARIANT_TRUE);
3128
3129     pdec->sign = DECIMAL_NEG;
3130     pdec->scale = 0;
3131     pdec->Hi32 = 0;
3132     pdec->Mid32 = 0;
3133     pdec->Lo32 = 1;
3134     VARNOT(DECIMAL,*pdec,I4,0);
3135
3136     pcy->int64 = 10000;
3137     VARNOT(CY,*pcy,I4,-2);
3138
3139     pcy->int64 = 0;
3140     VARNOT(CY,*pcy,I4,-1);
3141
3142     pcy->int64 = -1;
3143     VARNOT(CY,*pcy,I4,-1);
3144 }
3145
3146 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
3147
3148 #define VARSUB(vt1,val1,vt2,val2,rvt,rval)               \
3149         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3150         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3151         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3152         test_var_call2( __LINE__, pVarSub, &left, &right, &exp )
3153
3154 static void test_VarSub(void)
3155 {
3156     VARIANT left, right, exp, result, cy, dec;
3157     VARTYPE i;
3158     BSTR lbstr, rbstr;
3159     HRESULT hres, expectedhres;
3160     double r;
3161
3162     CHECKPTR(VarSub);
3163
3164     lbstr = SysAllocString(L"12");
3165     rbstr = SysAllocString(L"12");
3166
3167     VariantInit(&left);
3168     VariantInit(&right);
3169     VariantInit(&result);
3170
3171     /* Test all possible flag/vt combinations & the resulting vt type */
3172     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
3173     {
3174
3175         VARTYPE leftvt, rightvt, resvt;
3176
3177         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3178         {
3179
3180             SKIPTESTS(leftvt);
3181
3182             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3183             {
3184
3185                 SKIPTESTS(rightvt);
3186                 expectedhres = S_OK;
3187
3188                 memset(&left, 0, sizeof(left));
3189                 memset(&right, 0, sizeof(right));
3190                 V_VT(&left) = leftvt | ExtraFlags[i];
3191                 if (leftvt == VT_BSTR)
3192                     V_BSTR(&left) = lbstr;
3193                 V_VT(&right) = rightvt | ExtraFlags[i];
3194                 if (rightvt == VT_BSTR)
3195                     V_BSTR(&right) = rbstr;
3196                 V_VT(&result) = VT_EMPTY;
3197
3198                 /* All extra flags produce errors */
3199                 if (ExtraFlags[i] == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
3200                     ExtraFlags[i] == (VT_VECTOR|VT_RESERVED) ||
3201                     ExtraFlags[i] == (VT_VECTOR|VT_BYREF) ||
3202                     ExtraFlags[i] == (VT_BYREF|VT_RESERVED) ||
3203                     ExtraFlags[i] == VT_VECTOR ||
3204                     ExtraFlags[i] == VT_BYREF ||
3205                     ExtraFlags[i] == VT_RESERVED)
3206                 {
3207                     expectedhres = DISP_E_BADVARTYPE;
3208                     resvt = VT_EMPTY;
3209                 }
3210                 else if (ExtraFlags[i] >= VT_ARRAY)
3211                 {
3212                     expectedhres = DISP_E_TYPEMISMATCH;
3213                     resvt = VT_EMPTY;
3214                 }
3215                 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
3216                    VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
3217                 else if (!IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3218                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3219                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
3220                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3221                     leftvt == VT_I1 || rightvt == VT_I1 ||
3222                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
3223                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
3224                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
3225                     leftvt == VT_INT || rightvt == VT_INT ||
3226                     leftvt == VT_UINT || rightvt == VT_UINT ||
3227                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
3228                     leftvt == VT_RECORD || rightvt == VT_RECORD)
3229                 {
3230                     if (leftvt == VT_RECORD && rightvt == VT_I8)
3231                     {
3232                         if (has_i8)
3233                             expectedhres = DISP_E_TYPEMISMATCH;
3234                         else
3235                             expectedhres = DISP_E_BADVARTYPE;
3236                     }
3237                     else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
3238                         expectedhres = DISP_E_TYPEMISMATCH;
3239                     else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
3240                         expectedhres = DISP_E_TYPEMISMATCH;
3241                     else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
3242                         expectedhres = DISP_E_TYPEMISMATCH;
3243                     else if (leftvt == VT_RECORD && rightvt > VT_UI1)
3244                         expectedhres = DISP_E_BADVARTYPE;
3245                     else
3246                         expectedhres = DISP_E_BADVARTYPE;
3247                     resvt = VT_EMPTY;
3248                 }
3249                 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
3250                     (leftvt == VT_DISPATCH && rightvt == VT_NULL))
3251                     resvt = VT_NULL;
3252                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3253                     leftvt == VT_ERROR || rightvt == VT_ERROR)
3254                 {
3255                     resvt = VT_EMPTY;
3256                     expectedhres = DISP_E_TYPEMISMATCH;
3257                 }
3258                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3259                     resvt = VT_NULL;
3260                 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
3261                     (leftvt == VT_DATE && rightvt == VT_DATE) ||
3262                     (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
3263                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
3264                     resvt = VT_R8;
3265                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
3266                     resvt = VT_DECIMAL;
3267                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
3268                     resvt = VT_DATE;
3269                 else if (leftvt == VT_CY || rightvt == VT_CY)
3270                     resvt = VT_CY;
3271                 else if (leftvt == VT_R8 || rightvt == VT_R8)
3272                     resvt = VT_R8;
3273                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
3274                     resvt = VT_R8;
3275                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
3276                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
3277                         leftvt == VT_I8 || rightvt == VT_I8)
3278                         resvt = VT_R8;
3279                     else
3280                         resvt = VT_R4;
3281                 }
3282                 else if (leftvt == VT_I8 || rightvt == VT_I8)
3283                     resvt = VT_I8;
3284                 else if (leftvt == VT_I4 || rightvt == VT_I4)
3285                     resvt = VT_I4;
3286                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
3287                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
3288                     (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
3289                     resvt = VT_I2;
3290                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3291                     resvt = VT_UI1;
3292                 else
3293                 {
3294                     resvt = VT_EMPTY;
3295                     expectedhres = DISP_E_TYPEMISMATCH;
3296                 }
3297
3298                 hres = pVarSub(&left, &right, &result);
3299
3300                 ok(hres == expectedhres && V_VT(&result) == resvt,
3301                     "VarSub: %d|0x%X, %d|0x%X: Expected failure 0x%lX, "
3302                     "got 0x%lX, expected vt %d got vt %d\n",
3303                     leftvt, ExtraFlags[i], rightvt, ExtraFlags[i],
3304                     expectedhres, hres, resvt, V_VT(&result));
3305             }
3306         }
3307     }
3308
3309     /* Test returned values */
3310     VARSUB(I4,4,I4,2,I4,2);
3311     VARSUB(I2,4,I2,2,I2,2);
3312     VARSUB(I2,-13,I4,5,I4,-18);
3313     VARSUB(I4,-13,I4,5,I4,-18);
3314     VARSUB(I2,7,R4,0.5f,R4,6.5f);
3315     VARSUB(R4,0.5f,I4,5,R8,-4.5);
3316     VARSUB(R8,7.1,BOOL,0,R8,7.1);
3317     VARSUB(BSTR,lbstr,I2,4,R8,8);
3318     VARSUB(BSTR,lbstr,BOOL,1,R8,11);
3319     VARSUB(BSTR,lbstr,R4,0.1f,R8,11.9);
3320     VARSUB(R4,0.2f,BSTR,rbstr,R8,-11.8);
3321     VARSUB(DATE,2.25,I4,7,DATE,-4.75);
3322     VARSUB(DATE,1.25,R4,-1.7f,DATE,2.95);
3323
3324     VARSUB(UI1, UI1_MAX, UI1, UI1_MAX, UI1, 0);
3325     VARSUB(I2, I2_MAX, I2, I2_MAX, I2, 0);
3326     VARSUB(I2, I2_MIN, I2, I2_MIN, I2, 0);
3327     VARSUB(I4, I4_MAX, I4, I4_MAX, I4, 0);
3328     VARSUB(I4, I4_MIN, I4, I4_MIN, I4, 0);
3329     VARSUB(R4, R4_MAX, R4, R4_MAX, R4, 0.0f);
3330     VARSUB(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX - R4_MIN);
3331     VARSUB(R4, R4_MIN, R4, R4_MIN, R4, 0.0f);
3332     VARSUB(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX - R8_MIN);
3333     VARSUB(R8, R8_MIN, R8, R8_MIN, R8, 0.0);
3334
3335     /* Manually test BSTR + BSTR */
3336     V_VT(&left) = VT_BSTR;
3337     V_BSTR(&left) = lbstr;
3338     V_VT(&right) = VT_BSTR;
3339     V_BSTR(&right) = rbstr;
3340     hres = pVarSub(&left, &right, &result);
3341     ok(hres == S_OK && V_VT(&result) == VT_R8,
3342         "VarSub: expected coerced type VT_R8, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
3343     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.0),
3344         "VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
3345
3346     /* Manually test some VT_CY and VT_DECIMAL variants */
3347     V_VT(&cy) = VT_CY;
3348     hres = VarCyFromI4(4711, &V_CY(&cy));
3349     ok(hres == S_OK, "VarCyFromI4 failed!\n");
3350     V_VT(&dec) = VT_DECIMAL;
3351     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
3352     ok(hres == S_OK, "VarDecFromR4 failed!\n");
3353     memset(&left, 0, sizeof(left));
3354     memset(&right, 0, sizeof(right));
3355     V_VT(&left) = VT_I4;
3356     V_I4(&left) = -11;
3357     V_VT(&right) = VT_UI1;
3358     V_UI1(&right) = 9;
3359
3360     hres = pVarSub(&cy, &right, &result);
3361     ok(hres == S_OK && V_VT(&result) == VT_CY,
3362         "VarSub: expected coerced type VT_CY, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
3363     hres = VarR8FromCy(V_CY(&result), &r);
3364     ok(hres == S_OK && EQ_DOUBLE(r, 4702.0), "VarSub: CY value %f, expected %f\n", r, 4720.0);
3365
3366     hres = pVarSub(&left, &dec, &result);
3367     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
3368         "VarSub: expected coerced type VT_DECIMAL, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
3369     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
3370     ok(hres == S_OK && EQ_DOUBLE(r, -6.8), "VarSub: DECIMAL value %f, expected %f\n", r, -6.8);
3371
3372     SysFreeString(lbstr);
3373     SysFreeString(rbstr);
3374 }
3375
3376 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
3377
3378 static void test_Mod( int line, VARIANT *left, VARIANT *right, VARIANT *expected, HRESULT expres )
3379 {
3380     VARIANT result;
3381     HRESULT hres;
3382
3383     V_VT(&result) = 15;
3384     V_I4(&result) = 0x12345;
3385     hres = pVarMod( left, right, &result );
3386     ok_(__FILE__,line)( hres == expres, "wrong result %lx/%lx\n", hres, expres );
3387     if (hres == S_OK)
3388     {
3389         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
3390                             "got %s expected %s\n", wine_dbgstr_variant(&result), wine_dbgstr_variant(expected) );
3391     }
3392     else
3393     {
3394         ok_(__FILE__,line)( V_VT(&result) == VT_EMPTY, "Unexpected type %d.\n", V_VT(&result) );
3395         ok_(__FILE__,line)( V_I4(&result) == 0x12345, "Unexpected value %ld.\n", V_I4(&result) );
3396     }
3397 }
3398
3399 #define VARMOD(vt1,vt2,val1,val2,rvt,rval)               \
3400         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
3401         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3402         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
3403         test_var_call2( __LINE__, pVarMod, &left, &right, &exp )
3404
3405 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected)         \
3406         V_VT(&left) = VT_##vt1; V_I4(&left) = val1;           \
3407         V_VT(&right) = VT_##vt2; V_I4(&right) = val2;         \
3408         V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval;             \
3409         test_Mod( __LINE__, &left, &right, &exp, hexpected )
3410
3411 static void test_VarMod(void)
3412 {
3413   VARIANT v1, v2, vDst, left, right, exp;
3414   HRESULT hres;
3415   HRESULT hexpected = 0;
3416   int l, r;
3417   BOOL lFound, rFound;
3418   BOOL lValid;
3419   BSTR strNum0, strNum1;
3420
3421   CHECKPTR(VarMod);
3422
3423   VARMOD(I1,BOOL,100,10,I4,0);
3424   VARMOD(I1,I1,100,10,I4,0);
3425   VARMOD(I1,UI1,100,10,I4,0);
3426   VARMOD(I1,I2,100,10,I4,0);
3427   VARMOD(I1,UI2,100,10,I4,0);
3428   VARMOD(I1,I4,100,10,I4,0);
3429   VARMOD(I1,UI4,100,10,I4,0);
3430   VARMOD(I1,R4,100,10,I4,0);
3431   VARMOD(I1,R8,100,10,I4,0);
3432
3433   VARMOD(UI1,BOOL,100,10,I2,0);
3434   VARMOD(UI1,I1,100,10,I4,0);
3435   VARMOD(UI1,UI1,100,10,UI1,0);
3436   VARMOD(UI1,I2,100,10,I2,0);
3437   VARMOD(UI1,UI2,100,10,I4,0);
3438   VARMOD(UI1,I4,100,10,I4,0);
3439   VARMOD(UI1,UI4,100,10,I4,0);
3440   VARMOD(UI1,R4,100,10,I4,0);
3441   VARMOD(UI1,R8,100,10,I4,0);
3442
3443   VARMOD(I2,BOOL,100,10,I2,0);
3444   VARMOD(I2,I1,100,10,I4,0);
3445   VARMOD(I2,UI1,100,10,I2,0);
3446   VARMOD(I2,I2,100,10,I2,0);
3447   VARMOD(I2,UI2,100,10,I4,0);
3448   VARMOD(I2,I4,100,10,I4,0);
3449   VARMOD(I2,UI4,100,10,I4,0);
3450   VARMOD(I2,R4,100,10,I4,0);
3451   VARMOD(I2,R8,100,10,I4,0);
3452
3453   VARMOD(I4,BOOL,100,10,I4,0);
3454   VARMOD(I4,I1,100,10,I4,0);
3455   VARMOD(I4,UI1,100,10,I4,0);
3456   VARMOD(I4,I2,100,10,I4,0);
3457   VARMOD(I4,UI2,100,10,I4,0);
3458   VARMOD(I4,I4,100,10,I4,0);
3459   VARMOD(I4,UI4,100,10,I4,0);
3460   VARMOD(I4,R4,100,10,I4,0);
3461   VARMOD(I4,R8,100,10,I4,0);
3462   VARMOD(UI4,BOOL,100,10,I4,0);
3463   VARMOD(UI4,I1,100,10,I4,0);
3464   VARMOD(UI4,UI1,100,10,I4,0);
3465   VARMOD(UI4,I2,100,10,I4,0);
3466   VARMOD(UI4,UI2,100,10,I4,0);
3467   VARMOD(UI4,I4,100,10,I4,0);
3468   VARMOD(UI4,UI4,100,10,I4,0);
3469   VARMOD(UI4,R4,100,10,I4,0);
3470   VARMOD(UI4,R8,100,10,I4,0);
3471   VARMOD(R4,BOOL,100,10,I4,0);
3472   VARMOD(R4,I1,100,10,I4,0);
3473   VARMOD(R4,UI1,100,10,I4,0);
3474   VARMOD(R4,I2,100,10,I4,0);
3475   VARMOD(R4,UI2,100,10,I4,0);
3476   VARMOD(R4,I4,100,10,I4,0);
3477   VARMOD(R4,UI4,100,10,I4,0);
3478   VARMOD(R4,R4,100,10,I4,0);
3479   VARMOD(R4,R8,100,10,I4,0);
3480   VARMOD(R8,BOOL,100,10,I4,0);
3481   VARMOD(R8,I1,100,10,I4,0);
3482   VARMOD(R8,UI1,100,10,I4,0);
3483   VARMOD(R8,I2,100,10,I4,0);
3484   VARMOD(R8,UI2,100,10,I4,0);
3485   VARMOD(R8,I4,100,10,I4,0);
3486   VARMOD(R8,UI4,100,10,I4,0);
3487   VARMOD(R8,R4,100,10,I4,0);
3488   VARMOD(R8,R8,100,10,I4,0);
3489
3490   VARMOD(INT,INT,100,10,I4,0);
3491   VARMOD(INT,UINT,100,10,I4,0);
3492
3493   VARMOD(BOOL,BOOL,100,10,I2,0);
3494   VARMOD(BOOL,I1,100,10,I4,0);
3495   VARMOD(BOOL,UI1,100,10,I2,0);
3496   VARMOD(BOOL,I2,100,10,I2,0);
3497   VARMOD(BOOL,UI2,100,10,I4,0);
3498   VARMOD(BOOL,I4,100,10,I4,0);
3499   VARMOD(BOOL,UI4,100,10,I4,0);
3500   VARMOD(BOOL,R4,100,10,I4,0);
3501   VARMOD(BOOL,R8,100,10,I4,0);
3502   VARMOD(BOOL,DATE,100,10,I4,0);
3503
3504   VARMOD(DATE,BOOL,100,10,I4,0);
3505   VARMOD(DATE,I1,100,10,I4,0);
3506   VARMOD(DATE,UI1,100,10,I4,0);
3507   VARMOD(DATE,I2,100,10,I4,0);
3508   VARMOD(DATE,UI2,100,10,I4,0);
3509   VARMOD(DATE,I4,100,10,I4,0);
3510   VARMOD(DATE,UI4,100,10,I4,0);
3511   VARMOD(DATE,R4,100,10,I4,0);
3512   VARMOD(DATE,R8,100,10,I4,0);
3513   VARMOD(DATE,DATE,100,10,I4,0);
3514
3515   strNum0 = SysAllocString(L"125");
3516   strNum1 = SysAllocString(L"10");
3517   VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5);
3518   VARMOD(BSTR,I1,strNum0,10,I4,5);
3519   VARMOD(BSTR,I2,strNum0,10,I4,5);
3520   VARMOD(BSTR,I4,strNum0,10,I4,5);
3521   VARMOD(BSTR,R4,strNum0,10,I4,5);
3522   VARMOD(BSTR,R8,strNum0,10,I4,5);
3523   VARMOD(I4,BSTR,125,strNum1,I4,5);
3524
3525   if (has_i8)
3526   {
3527     VARMOD(BOOL,I8,100,10,I8,0);
3528     VARMOD(I1,I8,100,10,I8,0);
3529     VARMOD(UI1,I8,100,10,I8,0);
3530     VARMOD(I2,I8,100,10,I8,0);
3531     VARMOD(I4,I8,100,10,I8,0);
3532     VARMOD(UI4,I8,100,10,I8,0);
3533     VARMOD(R4,I8,100,10,I8,0);
3534     VARMOD(R8,I8,100,10,I8,0);
3535     VARMOD(DATE,I8,100,10,I8,0);
3536
3537     VARMOD(I8,BOOL,100,10,I8,0);
3538     VARMOD(I8,I1,100,10,I8,0);
3539     VARMOD(I8,UI1,100,10,I8,0);
3540     VARMOD(I8,I2,100,10,I8,0);
3541     VARMOD(I8,UI2,100,10,I8,0);
3542     VARMOD(I8,I4,100,10,I8,0);
3543     VARMOD(I8,UI4,100,10,I8,0);
3544     VARMOD(I8,R4,100,10,I8,0);
3545     VARMOD(I8,R8,100,10,I8,0);
3546     VARMOD(I8,I8,100,10,I8,0);
3547
3548     VARMOD(BSTR,I8,strNum0,10,I8,5);
3549   }
3550
3551   /* test all combinations of types */
3552   for(l = 0; l < VT_BSTR_BLOB; l++)
3553   {
3554     SKIPTESTS(l);
3555
3556     for(r = 0; r < VT_BSTR_BLOB; r++)
3557     {
3558       SKIPTESTS(r);
3559
3560       if(l == VT_BSTR) continue;
3561       if(l == VT_DISPATCH) continue;
3562       if(r == VT_BSTR) continue;
3563       if(r == VT_DISPATCH) continue;
3564
3565       lFound = TRUE;
3566       lValid = TRUE;
3567       switch(l)
3568         {
3569         case VT_EMPTY:
3570         case VT_NULL:
3571         case VT_I1:
3572         case VT_UI1:
3573         case VT_I2:
3574         case VT_UI2:
3575         case VT_I4:
3576         case VT_I8:
3577         case VT_UI4:
3578         case VT_UI8:
3579         case VT_INT:
3580         case VT_UINT:
3581         case VT_R4:
3582         case VT_R8:
3583         case VT_BOOL:
3584         case VT_DATE:
3585         case VT_CY:
3586         case VT_DECIMAL:
3587           hexpected = S_OK;
3588           break;
3589         case VT_ERROR:
3590         case VT_VARIANT:
3591         case VT_UNKNOWN:
3592         case VT_RECORD:
3593           lValid = FALSE;
3594           break;
3595         default:
3596           lFound = FALSE;
3597           hexpected = DISP_E_BADVARTYPE;
3598           break;
3599         }
3600
3601       rFound = TRUE;
3602       switch(r)
3603         {
3604         case VT_EMPTY:
3605         case VT_NULL:
3606         case VT_I1:
3607         case VT_UI1:
3608         case VT_I2:
3609         case VT_UI2:
3610         case VT_I4:
3611         case VT_I8:
3612         case VT_UI4:
3613         case VT_UI8:
3614         case VT_INT:
3615         case VT_UINT:
3616         case VT_R4:
3617         case VT_R8:
3618         case VT_BOOL:
3619         case VT_DATE:
3620         case VT_DECIMAL:
3621         case VT_CY:
3622           hexpected = S_OK;
3623           break;
3624         case VT_ERROR:
3625         case VT_VARIANT:
3626         case VT_UNKNOWN:
3627         case VT_RECORD:
3628           break;
3629         default:
3630           rFound = FALSE;
3631           break;
3632         }
3633
3634       if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
3635       {
3636         hexpected = DISP_E_TYPEMISMATCH;
3637       } else if((l == VT_EMPTY) && (r == VT_NULL))
3638       {
3639         hexpected = S_OK;
3640       } else if((l == VT_NULL) && (r == VT_EMPTY))
3641       {
3642         hexpected = S_OK;
3643       } else if((l == VT_EMPTY) && (r == VT_CY))
3644       {
3645         hexpected = S_OK;
3646       } else if((l == VT_EMPTY) && (r == VT_RECORD))
3647       {
3648         hexpected = DISP_E_TYPEMISMATCH;
3649       } else if((r == VT_EMPTY) && lFound && lValid)
3650       {
3651         hexpected = DISP_E_DIVBYZERO;
3652       } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
3653       {
3654         hexpected = DISP_E_TYPEMISMATCH;
3655       } else if((l == VT_NULL) && (r == VT_NULL))
3656       {
3657         hexpected = S_OK;
3658       } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
3659       {
3660         hexpected = DISP_E_TYPEMISMATCH;
3661       } else if((l == VT_NULL) && (r == VT_RECORD))
3662       {
3663         hexpected = DISP_E_TYPEMISMATCH;
3664       } else if((l == VT_I8) && (r == VT_DECIMAL))
3665       {
3666         hexpected = S_OK;
3667       } else if((l == VT_DECIMAL) && (r == VT_I8))
3668       {
3669         hexpected = S_OK;
3670       } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
3671       {
3672         hexpected = DISP_E_TYPEMISMATCH;
3673       } else if((l == VT_NULL) && rFound)
3674       {
3675         hexpected = S_OK;
3676       } else if(l == VT_RECORD)
3677       {
3678         hexpected = DISP_E_TYPEMISMATCH;
3679       } else if((r == VT_RECORD) && lValid && lFound)
3680       {
3681         hexpected = DISP_E_TYPEMISMATCH;
3682       } else if((l == VT_EMPTY) && (r == VT_EMPTY))
3683       {
3684         hexpected = DISP_E_DIVBYZERO;
3685       } else if((l == VT_CY) && !rFound)
3686       {
3687         hexpected = DISP_E_BADVARTYPE;
3688       } else if(lFound && !rFound)
3689       {
3690         hexpected = DISP_E_BADVARTYPE;
3691       } else if(!lFound && rFound)
3692       {
3693         hexpected = DISP_E_BADVARTYPE;
3694       } else if((r == VT_NULL) && lFound && lValid)
3695       {
3696         hexpected = S_OK;
3697       } else if((l == VT_NULL) || (r == VT_NULL))
3698       {
3699         hexpected = DISP_E_BADVARTYPE;
3700       } else if((l == VT_VARIANT) || (r == VT_VARIANT))
3701       {
3702         hexpected = DISP_E_BADVARTYPE;
3703       } else if(!lFound && !rFound)
3704       {
3705         hexpected = DISP_E_BADVARTYPE;
3706       }
3707
3708       V_VT(&v1) = l;
3709       V_VT(&v2) = r;
3710
3711       if(l == VT_CY)
3712         V_CY(&v1).int64 = 1000000;
3713       else if(l == VT_R4)
3714         V_R4(&v1) = 100;
3715       else if(l == VT_R8)
3716         V_R8(&v1) = 100;
3717       else if(l == VT_UI8)
3718         V_UI8(&v1) = 100;
3719       else if(l == VT_I8)
3720         V_I8(&v1) = 100;
3721       else if(l == VT_DATE)
3722         V_DATE(&v1) = 1000;
3723       else if (l == VT_DECIMAL)
3724       {
3725         V_DECIMAL(&v1).Hi32 = 0;
3726         V_DECIMAL(&v1).Lo64 = 100;
3727         V_DECIMAL(&v1).sign = 0;
3728         V_DECIMAL(&v1).scale = 0;
3729       }
3730       else
3731         V_I4(&v1) = 10000;
3732
3733       if(r == VT_CY)
3734         V_CY(&v2).int64 = 10000;
3735       else if(r == VT_R4)
3736         V_R4(&v2) = 100;
3737       else if(r == VT_R8)
3738         V_R8(&v2) = 100;
3739       else if(r == VT_UI8)
3740         V_UI8(&v2) = 100;
3741       else if(r == VT_I8)
3742         V_I8(&v2) = 100;
3743       else if(r == VT_DATE)
3744         V_DATE(&v2) = 1000;
3745       else if (r == VT_DECIMAL)
3746       {
3747         V_DECIMAL(&v2).Hi32 = 0;
3748         V_DECIMAL(&v2).Lo64 = 100;
3749         V_DECIMAL(&v2).sign = 0;
3750         V_DECIMAL(&v2).scale = 0;
3751       }
3752       else
3753         V_I4(&v2) = 10000;
3754
3755       if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || has_i8)
3756       {
3757         hres = pVarMod(&v1,&v2,&vDst);
3758         ok(hres == hexpected,
3759            "VarMod: expected 0x%lx, got 0x%lX for l type of %d, r type of %d,\n", hexpected, hres, l, r);
3760       }
3761     }
3762   }
3763
3764
3765   /****************************/
3766   /* test some bad parameters */
3767   VARMOD(I4,I4,-1,-1,I4,0);
3768
3769   /* test modulus with zero */
3770   VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
3771
3772   VARMOD(I4,I4,0,10,I4,0); /* test 0 mod 10 */
3773
3774   /* right parameter is type empty */
3775   VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
3776
3777   /* left parameter is type empty */
3778   VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
3779
3780   /* mod with a null left value */
3781   VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
3782
3783   /* mod with a null right value */
3784   VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
3785
3786   /* void left value */
3787   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3788
3789   /* void right value */
3790   VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3791
3792   /* null left value, void right value */
3793   VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
3794
3795   /* void left value, null right value */
3796   VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3797
3798   /* some currencies */
3799   V_VT(&v1) = VT_CY;
3800   V_VT(&v2) = VT_CY;
3801   V_CY(&v1).int64 = 100000;
3802   V_CY(&v2).int64 = 100000;
3803   hres = pVarMod(&v1,&v2,&vDst);
3804   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
3805      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
3806
3807   V_VT(&v1) = VT_I4;
3808   V_VT(&v2) = VT_CY;
3809   V_I4(&v1) = 100;
3810   V_CY(&v2).int64 = 100000;
3811   hres = pVarMod(&v1,&v2,&vDst);
3812   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
3813      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
3814
3815   /* some decimals */
3816   V_VT(&v1) = VT_DECIMAL;
3817   V_VT(&v2) = VT_DECIMAL;
3818   VarDecFromI4(100, &V_DECIMAL(&v1));
3819   VarDecFromI4(10, &V_DECIMAL(&v2));
3820   hres = pVarMod(&v1,&v2,&vDst);
3821   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
3822      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
3823
3824   V_VT(&v1) = VT_I4;
3825   V_VT(&v2) = VT_DECIMAL;
3826   V_I4(&v1) = 100;
3827   VarDecFromI4(10, &V_DECIMAL(&v2));
3828   hres = pVarMod(&v1,&v2,&vDst);
3829   ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
3830      "VarMod: expected 0x%lx,%d,%d, got 0x%lX,%d,%ld\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
3831
3832   VARMOD2(UINT,I4,100,10,I4,0,S_OK);
3833
3834   /* test that an error results in the type of the result changing but not its value */
3835   V_VT(&v1) = VT_UNKNOWN;
3836   V_VT(&v2) = VT_EMPTY;
3837   V_I4(&v1) = 100;
3838   V_CY(&v2).int64 = 100000;
3839   V_VT(&vDst) = VT_I4;
3840   V_I4(&vDst) = 1231;
3841   hres = pVarMod(&v1,&v2,&vDst);
3842   ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
3843      "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));
3844
3845
3846   /* test some invalid types */
3847   /*TODO: not testing VT_DISPATCH */
3848   if (has_i8)
3849   {
3850     VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
3851   }
3852   VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
3853   VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
3854   VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
3855   VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3856   VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3857   VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3858   VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3859   VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3860   VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3861   VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3862   VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3863   VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
3864   VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3865   VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3866   VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3867   VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3868   VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3869   VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3870   VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3871   VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3872   VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3873   VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3874   VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3875   VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
3876
3877   /* test some more invalid types */
3878   V_VT(&v1) = 456;
3879   V_VT(&v2) = 234;
3880   V_I4(&v1) = 100;
3881   V_I4(&v2)=  10;
3882   hres = pVarMod(&v1,&v2,&vDst);
3883   ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY,
3884      "VarMod: expected 0x%lx,%d, got 0x%lX,%d\n", DISP_E_BADVARTYPE, VT_EMPTY, hres, V_VT(&vDst));
3885
3886   SysFreeString(strNum0);
3887   SysFreeString(strNum1);
3888 }
3889
3890 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
3891
3892 #define VARFIX(vt,val,rvt,rval)                  \
3893     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
3894     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3895     test_var_call1( __LINE__, pVarFix, &v, &exp )
3896
3897 static void test_VarFix(void)
3898 {
3899     HRESULT hres;
3900     VARIANT v, exp, vDst;
3901     DECIMAL *pdec = &V_DECIMAL(&v);
3902     CY *pcy = &V_CY(&v);
3903     size_t i;
3904
3905     CHECKPTR(VarFix);
3906
3907     /* Test all possible V_VT values */
3908     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
3909     {
3910         VARTYPE vt;
3911
3912         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3913         {
3914             BOOL bFail = TRUE;
3915
3916             SKIPTESTS(vt);
3917
3918             memset(&v, 0, sizeof(v));
3919             V_VT(&v) = vt | ExtraFlags[i];
3920             V_VT(&vDst) = VT_EMPTY;
3921
3922             switch (V_VT(&v))
3923             {
3924               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
3925               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3926               case VT_DATE: case VT_CY:
3927                 bFail = FALSE;
3928                 break;
3929               case VT_I8:
3930                 if (has_i8)
3931                   bFail = FALSE;
3932                 break;
3933             }
3934
3935             hres = pVarFix(&v,&vDst);
3936             if (bFail)
3937               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3938                  "VarFix: expected failure, got 0x%lX vt %d|0x%X\n",
3939                  hres, vt, ExtraFlags[i]);
3940             else
3941                  ok(hres == S_OK, "VarFix: expected S_OK, got 0x%lX vt %d|0x%X\n",
3942                     hres, vt, ExtraFlags[i]);
3943         }
3944     }
3945
3946     VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
3947     VARFIX(BOOL,VARIANT_FALSE,I2,0);
3948     VARFIX(BOOL,1,I2,1);
3949     VARFIX(UI1,1,UI1,1);
3950     VARFIX(I2,-1,I2,-1);
3951     VARFIX(I4,-1,I4,-1);
3952     if (has_i8)
3953     {
3954         VARFIX(I8,-1,I8,-1);
3955     }
3956     VARFIX(R4,1.4f,R4,1);
3957     VARFIX(R4,1.5f,R4,1);
3958     VARFIX(R4,1.6f,R4,1);
3959     VARFIX(R4,-1.4f,R4,-1);
3960     VARFIX(R4,-1.5f,R4,-1);
3961     VARFIX(R4,-1.6f,R4,-1);
3962     /* DATE & R8 round as for R4 */
3963     VARFIX(DATE,-1,DATE,-1);
3964     VARFIX(R8,-1,R8,-1);
3965     VARFIX(BSTR,(BSTR)L"-1",R8,-1);
3966
3967     V_VT(&v) = VT_EMPTY;
3968     hres = pVarFix(&v,&vDst);
3969     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3970        "VarFix: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
3971        hres, V_VT(&vDst), V_I2(&vDst));
3972
3973     V_VT(&v) = VT_NULL;
3974     hres = pVarFix(&v,&vDst);
3975     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3976        "VarFix: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
3977
3978     V_VT(&v) = VT_DECIMAL;
3979     pdec->sign = DECIMAL_NEG;
3980     pdec->scale = 0;
3981     pdec->Hi32 = 0;
3982     pdec->Mid32 = 0;
3983     pdec->Lo32 = 1;
3984     hres = pVarFix(&v,&vDst);
3985     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
3986        "VarFix: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
3987        hres, V_VT(&vDst));
3988
3989     /* FIXME: Test some fractional decimals when VarDecFix is implemented */
3990
3991     V_VT(&v) = VT_CY;
3992     pcy->int64 = -10000;
3993     hres = pVarFix(&v,&vDst);
3994     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
3995        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
3996
3997     V_VT(&v) = VT_CY;
3998     pcy->int64 = -16000;
3999     hres = pVarFix(&v,&vDst);
4000     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
4001        "VarFix: VT_CY wrong, hres=0x%lX\n", hres);
4002 }
4003
4004 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
4005
4006 #define VARINT(vt,val,rvt,rval)                  \
4007     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
4008     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4009     test_var_call1( __LINE__, pVarInt, &v, &exp )
4010
4011 static void test_VarInt(void)
4012 {
4013     HRESULT hres;
4014     VARIANT v, exp, vDst;
4015     DECIMAL *pdec = &V_DECIMAL(&v);
4016     CY *pcy = &V_CY(&v);
4017     size_t i;
4018
4019     CHECKPTR(VarInt);
4020
4021     /* Test all possible V_VT values */
4022     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
4023     {
4024         VARTYPE vt;
4025
4026         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
4027         {
4028             BOOL bFail = TRUE;
4029
4030             SKIPTESTS(vt);
4031
4032             memset(&v, 0, sizeof(v));
4033             V_VT(&v) = vt | ExtraFlags[i];
4034             V_VT(&vDst) = VT_EMPTY;
4035
4036             switch (V_VT(&v))
4037             {
4038               case VT_UI1: case VT_I2: case VT_I4: case VT_R4:  case VT_R8:
4039               case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
4040               case VT_DATE: case VT_CY:
4041                 bFail = FALSE;
4042                 break;
4043               case VT_I8:
4044                 if (has_i8)
4045                   bFail = FALSE;
4046                 break;
4047             }
4048
4049             hres = pVarInt(&v,&vDst);
4050             if (bFail)
4051               ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4052                  "VarInt: expected failure, got 0x%lX vt %d|0x%X\n",
4053                  hres, vt, ExtraFlags[i]);
4054             else
4055                  ok(hres == S_OK, "VarInt: expected S_OK, got 0x%lX vt %d|0x%X\n",
4056                     hres, vt, ExtraFlags[i]);
4057         }
4058     }
4059
4060     VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
4061     VARINT(BOOL,VARIANT_FALSE,I2,0);
4062     VARINT(BOOL,1,I2,1);
4063     VARINT(UI1,1,UI1,1);
4064     VARINT(I2,-1,I2,-1);
4065     VARINT(I4,-1,I4,-1);
4066     if (has_i8)
4067     {
4068         VARINT(I8,-1,I8,-1);
4069     }
4070     VARINT(R4,1.4f,R4,1);
4071     VARINT(R4,1.5f,R4,1);
4072     VARINT(R4,1.6f,R4,1);
4073     VARINT(R4,-1.4f,R4,-2); /* Note these 3 are different from VarFix */
4074     VARINT(R4,-1.5f,R4,-2);
4075     VARINT(R4,-1.6f,R4,-2);
4076     /* DATE & R8 round as for R4 */
4077     VARINT(DATE,-1,DATE,-1);
4078     VARINT(R8,-1,R8,-1);
4079     VARINT(BSTR,(BSTR)L"-1",R8,-1);
4080
4081     V_VT(&v) = VT_EMPTY;
4082     hres = pVarInt(&v,&vDst);
4083     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
4084        "VarInt: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
4085        hres, V_VT(&vDst), V_I2(&vDst));
4086
4087     V_VT(&v) = VT_NULL;
4088     hres = pVarInt(&v,&vDst);
4089     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
4090        "VarInt: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
4091
4092     V_VT(&v) = VT_DECIMAL;
4093     pdec->sign = DECIMAL_NEG;
4094     pdec->scale = 0;
4095     pdec->Hi32 = 0;
4096     pdec->Mid32 = 0;
4097     pdec->Lo32 = 1;
4098     hres = pVarInt(&v,&vDst);
4099     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
4100        "VarInt: expected 0x0,%d,identical, got 0x%lX,%d\n", VT_DECIMAL,
4101        hres, V_VT(&vDst));
4102
4103     /* FIXME: Test some fractional decimals when VarDecInt is implemented */
4104
4105     V_VT(&v) = VT_CY;
4106     pcy->int64 = -10000;
4107     hres = pVarInt(&v,&vDst);
4108     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
4109        "VarInt: VT_CY wrong, hres=0x%lX\n", hres);
4110
4111     V_VT(&v) = VT_CY;
4112     pcy->int64 = -11000;
4113     hres = pVarInt(&v,&vDst);
4114     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
4115        "VarInt: VT_CY wrong, hres=%#lX %#I64x\n",
4116        hres, V_CY(&vDst).int64);
4117 }
4118
4119 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
4120
4121 #define VARNEG(vt,val,rvt,rval)                  \
4122     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
4123     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4124     test_var_call1( __LINE__, pVarNeg, &v, &exp )
4125
4126 static void test_VarNeg(void)
4127 {
4128     HRESULT hres;
4129     VARIANT v, exp, vDst;
4130     DECIMAL *pdec = &V_DECIMAL(&v);
4131     CY *pcy = &V_CY(&v);
4132     size_t i;
4133
4134     CHECKPTR(VarNeg);
4135
4136     /* Test all possible V_VT values. But don't test the exact return values
4137      * except for success/failure, since M$ made a hash of them in the
4138      * native version. This at least ensures (as with all tests here) that
4139      * we will notice if/when new vtypes/flags are added in native.
4140      */
4141     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
4142     {
4143         VARTYPE vt;
4144
4145         for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
4146         {
4147             BOOL bFail = TRUE;
4148
4149             SKIPTESTS(vt);
4150
4151             memset(&v, 0, sizeof(v));
4152             V_VT(&v) = vt | ExtraFlags[i];
4153             V_VT(&vDst) = VT_EMPTY;
4154
4155             switch (V_VT(&v))
4156             {
4157             case VT_UI1: case VT_I2: case VT_I4:
4158             case VT_R4:  case VT_R8:
4159             case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
4160             case VT_DATE: case VT_CY:
4161                 bFail = FALSE;
4162                 break;
4163             case VT_I8:
4164                 if (has_i8)
4165                     bFail = FALSE;
4166             }
4167
4168             hres = pVarNeg(&v,&vDst);
4169             if (bFail)
4170                 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4171                    "VarNeg: expected failure, got 0x%lX vt %d|0x%X\n",
4172                    hres, vt, ExtraFlags[i]);
4173             else
4174                 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%lX vt %d|0x%X\n",
4175                     hres, vt, ExtraFlags[i]);
4176         }
4177     }
4178
4179     VARNEG(BOOL,VARIANT_TRUE,I2,1);
4180     VARNEG(BOOL,VARIANT_FALSE,I2,0);
4181     VARNEG(BOOL,1,I2,-1);
4182     VARNEG(UI1,1,I2,-1);
4183     VARNEG(UI1,254,I2,-254);
4184     VARNEG(I2,-32768,I4,32768);
4185     VARNEG(I2,-1,I2,1);
4186     VARNEG(I2,1,I2,-1);
4187     VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
4188     VARNEG(I4,-1,I4,1);
4189     VARNEG(I4,1,I4,-1);
4190     if (has_i8)
4191     {
4192         VARNEG(I8,1,I8,-1);
4193         VARNEG(I8,-1,I8,1);
4194     }
4195     VARNEG(R4,1,R4,-1);
4196     VARNEG(R4,-1,R4,1);
4197     VARNEG(DATE,1,DATE,-1);
4198     VARNEG(DATE,-1,DATE,1);
4199     VARNEG(R8,1,R8,-1);
4200     VARNEG(R8,-1,R8,1);
4201     VARNEG(BSTR,(BSTR)L"-1",R8,1);
4202     VARNEG(BSTR,(BSTR)L"1",R8,-1);
4203
4204     V_VT(&v) = VT_EMPTY;
4205     hres = pVarNeg(&v,&vDst);
4206     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
4207        "VarNeg: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
4208        hres, V_VT(&vDst), V_I2(&vDst));
4209
4210     V_VT(&v) = VT_NULL;
4211     hres = pVarNeg(&v,&vDst);
4212     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
4213        "VarNeg: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
4214
4215     V_VT(&v) = VT_DECIMAL;
4216     pdec->sign = DECIMAL_NEG;
4217     pdec->scale = 0;
4218     pdec->Hi32 = 0;
4219     pdec->Mid32 = 0;
4220     pdec->Lo32 = 1;
4221     hres = pVarNeg(&v,&vDst);
4222     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
4223        V_DECIMAL(&vDst).sign == 0,
4224        "VarNeg: expected 0x0,%d,0x00, got 0x%lX,%d,%02x\n", VT_DECIMAL,
4225        hres, V_VT(&vDst), V_DECIMAL(&vDst).sign);
4226
4227     pdec->sign = 0;
4228     hres = pVarNeg(&v,&vDst);
4229     ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
4230        V_DECIMAL(&vDst).sign == DECIMAL_NEG,
4231        "VarNeg: expected 0x0,%d,0x7f, got 0x%lX,%d,%02x\n", VT_DECIMAL,
4232        hres, V_VT(&vDst), V_DECIMAL(&vDst).sign);
4233
4234     V_VT(&v) = VT_CY;
4235     pcy->int64 = -10000;
4236     hres = pVarNeg(&v,&vDst);
4237     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
4238        "VarNeg: VT_CY wrong, hres=0x%lX\n", hres);
4239 }
4240
4241 static void test_Round( int line, VARIANT *arg, int deci, VARIANT *expected )
4242 {
4243     VARIANT result;
4244     HRESULT hres;
4245
4246     memset( &result, 0, sizeof(result) );
4247     hres = VarRound( arg, deci, &result );
4248     ok_(__FILE__,line)( hres == S_OK, "wrong result %lx\n", hres );
4249     if (hres == S_OK)
4250         ok_(__FILE__,line)( is_expected_variant( &result, expected ),
4251                             "got %s expected %s\n", wine_dbgstr_variant(&result), wine_dbgstr_variant(expected) );
4252 }
4253 #define VARROUND(vt,val,deci,rvt,rval)           \
4254     V_VT(&v) = VT_##vt; V_##vt(&v) = val;        \
4255     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4256     test_Round( __LINE__, &v, deci, &exp )
4257
4258 struct decimal_t {
4259     BYTE scale;
4260     BYTE sign;
4261     ULONG Hi32;
4262     ULONG Mid32;
4263     ULONG Lo32;
4264 };
4265
4266 struct decimal_round_t {
4267     struct decimal_t source;
4268     struct decimal_t ret;
4269     int dec;
4270 };
4271
4272 static const struct decimal_round_t decimal_round_data[] = {
4273     {{ 0, DECIMAL_NEG, 0, 0, 1 }, { 0, DECIMAL_NEG, 0, 0, 1 }, 0},
4274     {{ 0, 0, 0, 0, 1 }, { 0, 0, 0, 0, 1 }, 0},
4275     {{ 2, 0, 0, 0, 155 }, { 0, 0, 0, 0, 16 }, 1},
4276     {{ 2, 0, 0, 0, 155 }, { 1, 0, 0, 0, 2 }, 0},
4277     {{ 2, 0, 0, 0, 199 }, { 1, 0, 0, 0, 20 }, 1},
4278     {{ 2, 0, 0, 0, 199 }, { 2, 0, 0, 0, 199 }, 2},
4279     {{ 2, DECIMAL_NEG, 0, 0, 199 }, { 2, DECIMAL_NEG, 0, 0, 199 }, 2},
4280     {{ 2, DECIMAL_NEG, 0, 0, 55 },  { 2, DECIMAL_NEG, 0, 0, 6 }, 1},
4281     {{ 2, 0, 0, 0, 55 },  { 2, 0, 0, 0, 6 }, 1},
4282     {{ 2, 0, 0, 0, 1999 }, { 1, 0, 0, 0, 200 }, 1},
4283 };
4284
4285 static void test_VarRound(void)
4286 {
4287     static WCHAR szNumMin[] = {'-','1','.','4','4','9','\0' };
4288     static WCHAR szNum[] = {'1','.','4','5','1','\0' };
4289     HRESULT hres;
4290     VARIANT v, exp, vDst;
4291     CY *pcy = &V_CY(&v);
4292     char buff[8];
4293     int i;
4294
4295     /* first check valid integer types */
4296     VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
4297     VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
4298     VARROUND(BOOL,1,0,I2,1);
4299     VARROUND(UI1,1,0,UI1,1);
4300     VARROUND(UI1,254,0,UI1,254);
4301     VARROUND(I2,-32768,0,I2,-32768);
4302     VARROUND(I2,-1,0,I2,-1);
4303     VARROUND(I2,1,0,I2,1);
4304     VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
4305     VARROUND(I4,-1,0,I4,-1);
4306     VARROUND(I4,1,0,I4,1);
4307
4308
4309     /* MSDN states that rounding of R4/R8 is dependent on the underlying
4310      * bit pattern of the number and so is architecture dependent. In this
4311      * case Wine returns .2 (which is more correct) and Native returns .3
4312      */
4313
4314     VARROUND(R4,1.0f,0,R4,1.0f);
4315     VARROUND(R4,-1.0f,0,R4,-1.0f);
4316     VARROUND(R8,1.0,0,R8,1.0);
4317     VARROUND(R8,-1.0,0,R8,-1.0);
4318
4319     /* floating point numbers aren't exactly equal and we can't just
4320      * compare the first few digits. */
4321     VARROUND(DATE,1.451,1,DATE,1.5);
4322     VARROUND(DATE,-1.449,1,DATE,-1.4);
4323
4324     /* replace the decimal separator */
4325     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, ARRAY_SIZE(buff));
4326     if (!buff[1]) {
4327         szNumMin[2] = buff[0];
4328         szNum[1] = buff[0];
4329         VARROUND(BSTR,(BSTR)szNumMin,1,R8,-1.40);
4330         VARROUND(BSTR,(BSTR)szNum,1,R8,1.50);
4331     } else {
4332         skip("Skipping VarRound(BSTR) as decimal separator is '%s'\n", buff);
4333     }
4334
4335     VARROUND(R4,1.23456f,0,R4,1.0f);
4336     VARROUND(R4,1.23456f,1,R4,1.2f);
4337     VARROUND(R4,1.23456f,2,R4,1.23f);
4338     VARROUND(R4,1.23456f,3,R4,1.235f);
4339     VARROUND(R4,1.23456f,4,R4,1.2346f);
4340     VARROUND(R4,-1.23456f,0,R4,-1.0f);
4341     VARROUND(R4,-1.23456f,1,R4,-1.2f);
4342     VARROUND(R4,-1.23456f,2,R4,-1.23f);
4343     VARROUND(R4,-1.23456f,3,R4,-1.235f);
4344     VARROUND(R4,-1.23456f,4,R4,-1.2346f);
4345
4346     VARROUND(R8,1.23456,0,R8,1.0);
4347     VARROUND(R8,1.23456,1,R8,1.2);
4348     VARROUND(R8,1.23456,2,R8,1.23);
4349     VARROUND(R8,1.23456,3,R8,1.235);
4350     VARROUND(R8,1.23456,4,R8,1.2346);
4351     VARROUND(R8,-1.23456,0,R8,-1.0);
4352     VARROUND(R8,-1.23456,1,R8,-1.2);
4353     VARROUND(R8,-1.23456,2,R8,-1.23);
4354     VARROUND(R8,-1.23456,3,R8,-1.235);
4355     VARROUND(R8,-1.23456,4,R8,-1.2346);
4356
4357     V_VT(&v) = VT_EMPTY;
4358     hres = VarRound(&v,0,&vDst);
4359     ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
4360         "VarRound: expected 0x0,%d,0 got 0x%lX,%d,%d\n", VT_EMPTY,
4361         hres, V_VT(&vDst), V_I2(&vDst));
4362
4363     V_VT(&v) = VT_NULL;
4364     hres = VarRound(&v,0,&vDst);
4365     ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
4366         "VarRound: expected 0x0,%d got 0x%lX,%d\n", VT_NULL, hres, V_VT(&vDst));
4367
4368     /* VT_DECIMAL */
4369     for (i = 0; i < ARRAY_SIZE(decimal_round_data); i++)
4370     {
4371         const struct decimal_round_t *ptr = &decimal_round_data[i];
4372         DECIMAL *pdec;
4373
4374         pdec = &V_DECIMAL(&v);
4375         V_VT(&v) = VT_DECIMAL;
4376         pdec->sign = ptr->source.sign;
4377         pdec->scale = ptr->source.scale;
4378         pdec->Hi32 = ptr->source.Hi32;
4379         pdec->Mid32 = ptr->source.Mid32;
4380         pdec->Lo32 = ptr->source.Lo32;
4381         VariantInit(&vDst);
4382         hres = VarRound(&v, ptr->dec, &vDst);
4383         ok(hres == S_OK, "%d: got 0x%08lx\n", i, hres);
4384         if (hres == S_OK)
4385         {
4386             ok(V_VT(&vDst) == VT_DECIMAL, "%d: got VT %d, expected VT_DECIMAL\n", i, V_VT(&vDst));
4387             ok(V_DECIMAL(&vDst).sign == ptr->ret.sign, "%d: got sign 0x%02x, expected 0x%02x\n",
4388                 i, V_DECIMAL(&vDst).sign, ptr->ret.sign);
4389             ok(V_DECIMAL(&vDst).Hi32 == ptr->ret.Hi32, "%d: got Hi32 %ld, expected %ld\n",
4390                 i, V_DECIMAL(&vDst).Hi32, ptr->ret.Hi32);
4391             ok(V_DECIMAL(&vDst).Mid32 == ptr->ret.Mid32, "%d: got Mid32 %ld, expected %ld\n",
4392                i, V_DECIMAL(&vDst).Mid32,  ptr->ret.Mid32);
4393             ok(V_DECIMAL(&vDst).Lo32 == ptr->ret.Lo32, "%d: got Lo32 %ld, expected %ld\n",
4394                 i, V_DECIMAL(&vDst).Lo32, ptr->ret.Lo32);
4395         }
4396     }
4397
4398     /* VT_CY */
4399     V_VT(&v) = VT_CY;
4400     pcy->int64 = 10000;
4401     hres = VarRound(&v,0,&vDst);
4402     ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
4403         "VarRound: VT_CY wrong, hres=0x%lX\n", hres);
4404 }
4405
4406 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
4407
4408 #define VARXOR(vt1,val1,vt2,val2,rvt,rval)               \
4409         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4410         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4411         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4412         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
4413
4414 #define VARXORCY(vt1,val1,val2,rvt,rval)                 \
4415         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
4416         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
4417         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
4418         test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
4419
4420 static void test_VarXor(void)
4421 {
4422     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
4423     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
4424     VARIANT left, right, exp, result;
4425     BSTR lbstr, rbstr;
4426     VARTYPE i;
4427     HRESULT hres;
4428
4429     CHECKPTR(VarXor);
4430
4431     /* Test all possible flag/vt combinations & the resulting vt type */
4432     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
4433     {
4434         VARTYPE leftvt, rightvt, resvt;
4435
4436         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4437         {
4438
4439             SKIPTESTS(leftvt);
4440
4441             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4442             {
4443                 BOOL bFail = FALSE;
4444
4445                 SKIPTESTS(rightvt);
4446
4447                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4448                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4449                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4450                     continue;
4451
4452                 memset(&left, 0, sizeof(left));
4453                 memset(&right, 0, sizeof(right));
4454                 V_VT(&left) = leftvt | ExtraFlags[i];
4455                 V_VT(&right) = rightvt | ExtraFlags[i];
4456                 V_VT(&result) = VT_EMPTY;
4457                 resvt = VT_I4;
4458
4459                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4460                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4461                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4462                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
4463                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
4464                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4465                     leftvt == VT_ERROR || rightvt == VT_ERROR)
4466                 {
4467                     bFail = TRUE;
4468                 }
4469                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4470                 {
4471                     if (leftvt == rightvt ||
4472                         leftvt == VT_I2 || rightvt == VT_I2 ||
4473                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
4474                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4475                         resvt = VT_I2;
4476                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
4477                         resvt = VT_NULL;
4478                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4479                         resvt = VT_I8;
4480                 }
4481                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4482                 {
4483                     resvt = VT_NULL;
4484                 }
4485                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4486                 {
4487                     if (leftvt == rightvt)
4488                         resvt = VT_UI1;
4489                     else if (leftvt == rightvt ||
4490                         leftvt == VT_I2 || rightvt == VT_I2 ||
4491                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4492                     {
4493                         resvt = VT_I2;
4494                     }
4495                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4496                         resvt = VT_I8;
4497                 }
4498                 else if (leftvt == VT_I2 || rightvt == VT_I2)
4499                 {
4500                     if (leftvt == rightvt ||
4501                         leftvt == VT_BOOL || rightvt == VT_BOOL)
4502                         resvt = VT_I2;
4503                     else if (leftvt == VT_I8 || rightvt == VT_I8)
4504                         resvt = VT_I8;
4505                 }
4506                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4507                 {
4508                     resvt = VT_BOOL;
4509                 }
4510                 else if (leftvt == VT_I8 || rightvt == VT_I8)
4511                 {
4512                     if (leftvt == VT_INT || rightvt == VT_INT)
4513                         bFail = TRUE;
4514                     else
4515                         resvt = VT_I8;
4516                 }
4517                 hres = pVarXor(&left, &right, &result);
4518                 if (bFail)
4519                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4520                        "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
4521                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4522                        V_VT(&result));
4523                 else
4524                     ok(hres == S_OK && V_VT(&result) == resvt,
4525                        "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
4526                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4527                        V_VT(&result));
4528             }
4529         }
4530     }
4531
4532     /* Test returned values
4533      * FIXME: Test VT_DECIMAL/VT_DISPATCH
4534      */
4535     VARXOR(EMPTY,0,EMPTY,0,I2,0);
4536     VARXOR(EMPTY,1,EMPTY,0,I2,0);
4537     VARXOR(EMPTY,0,NULL,0,NULL,0);
4538     VARXOR(EMPTY,0,I1,0,I4,0);
4539     VARXOR(EMPTY,0,I1,1,I4,1);
4540     VARXOR(EMPTY,0,UI1,0,I2,0);
4541     VARXOR(EMPTY,0,UI1,1,I2,1);
4542     VARXOR(EMPTY,0,I2,0,I2,0);
4543     VARXOR(EMPTY,0,I2,1,I2,1);
4544     VARXOR(EMPTY,0,UI2,0,I4,0);
4545     VARXOR(EMPTY,0,UI2,1,I4,1);
4546     VARXOR(EMPTY,0,I4,0,I4,0);
4547     VARXOR(EMPTY,0,I4,1,I4,1);
4548     VARXOR(EMPTY,0,UI4,0,I4,0);
4549     VARXOR(EMPTY,0,UI4,1,I4,1);
4550     if (has_i8)
4551     {
4552         VARXOR(EMPTY,0,I8,0,I8,0);
4553         VARXOR(EMPTY,0,I8,1,I8,1);
4554         VARXOR(EMPTY,0,UI8,0,I4,0);
4555         VARXOR(EMPTY,0,UI8,1,I4,1);
4556     }
4557     VARXOR(EMPTY,0,INT,0,I4,0);
4558     VARXOR(EMPTY,0,INT,1,I4,1);
4559     VARXOR(EMPTY,0,UINT,0,I4,0);
4560     VARXOR(EMPTY,0,UINT,1,I4,1);
4561     VARXOR(EMPTY,0,BOOL,0,I2,0);
4562     VARXOR(EMPTY,0,BOOL,1,I2,1);
4563     VARXOR(EMPTY,0,R4,0,I4,0);
4564     VARXOR(EMPTY,0,R4,1,I4,1);
4565     VARXOR(EMPTY,0,R8,0,I4,0);
4566     VARXOR(EMPTY,0,R8,1,I4,1);
4567     rbstr = SysAllocString(szFalse);
4568     VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
4569     SysFreeString(rbstr);
4570     rbstr = SysAllocString(szTrue);
4571     VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
4572     VARXORCY(EMPTY,0,10000,I4,1);
4573     SysFreeString(rbstr);
4574
4575     /* NULL OR 0 = NULL. NULL OR n = n */
4576     VARXOR(NULL,0,NULL,0,NULL,0);
4577     VARXOR(NULL,1,NULL,0,NULL,0);
4578     VARXOR(NULL,0,I1,0,NULL,0);
4579     VARXOR(NULL,0,I1,1,NULL,0);
4580     VARXOR(NULL,0,UI1,0,NULL,0);
4581     VARXOR(NULL,0,UI1,1,NULL,0);
4582     VARXOR(NULL,0,I2,0,NULL,0);
4583     VARXOR(NULL,0,I2,1,NULL,0);
4584     VARXOR(NULL,0,UI2,0,NULL,0);
4585     VARXOR(NULL,0,UI2,1,NULL,0);
4586     VARXOR(NULL,0,I4,0,NULL,0);
4587     VARXOR(NULL,0,I4,1,NULL,0);
4588     VARXOR(NULL,0,UI4,0,NULL,0);
4589     VARXOR(NULL,0,UI4,1,NULL,0);
4590     if (has_i8)
4591     {
4592         VARXOR(NULL,0,I8,0,NULL,0);
4593         VARXOR(NULL,0,I8,1,NULL,0);
4594         VARXOR(NULL,0,UI8,0,NULL,0);
4595         VARXOR(NULL,0,UI8,1,NULL,0);
4596     }
4597     VARXOR(NULL,0,INT,0,NULL,0);
4598     VARXOR(NULL,0,INT,1,NULL,0);
4599     VARXOR(NULL,0,UINT,0,NULL,0);
4600     VARXOR(NULL,0,UINT,1,NULL,0);
4601     VARXOR(NULL,0,BOOL,0,NULL,0);
4602     VARXOR(NULL,0,BOOL,1,NULL,0);
4603     VARXOR(NULL,0,R4,0,NULL,0);
4604     VARXOR(NULL,0,R4,1,NULL,0);
4605     VARXOR(NULL,0,R8,0,NULL,0);
4606     VARXOR(NULL,0,R8,1,NULL,0);
4607     rbstr = SysAllocString(szFalse);
4608     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
4609     SysFreeString(rbstr);
4610     rbstr = SysAllocString(szTrue);
4611     VARXOR(NULL,0,BSTR,rbstr,NULL,0);
4612     SysFreeString(rbstr);
4613     VARXORCY(NULL,0,10000,NULL,0);
4614     VARXORCY(NULL,0,0,NULL,0);
4615
4616     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4617     VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4618     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4619     VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4620     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4621     VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
4622     VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4623     VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4624     VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
4625     VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4626     VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4627     VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
4628     VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4629     VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4630     VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
4631     VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4632     VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4633     VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
4634     VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4635     VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4636     VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
4637     VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4638     VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4639     VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
4640     VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4641     VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4642     VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
4643     VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4644     VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4645     VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
4646     VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4647     VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4648     if (has_i8)
4649     {
4650         VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
4651         VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4652         VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4653         /* This returns DISP_E_OVERFLOW which indicates that a conversion
4654          * to I4 is performed.
4655          */
4656         /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4657         VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4658         VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4659     }
4660     VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
4661     VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4662     VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4663     VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
4664     VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4665     VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4666     rbstr = SysAllocString(szFalse);
4667     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4668     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4669     SysFreeString(rbstr);
4670     rbstr = SysAllocString(szTrue);
4671     VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4672     VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4673     SysFreeString(rbstr);
4674     VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
4675     VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4676     VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
4677
4678     VARXOR(I1,-1,I1,-1,I4,0);
4679     VARXOR(I1,-1,I1,0,I4,-1);
4680     VARXOR(I1,0,I1,0,I4,0);
4681     VARXOR(I1,-1,UI1,255,I4,-256);
4682     VARXOR(I1,-1,UI1,0,I4,-1);
4683     VARXOR(I1,0,UI1,0,I4,0);
4684     VARXOR(I1,-1,I2,-1,I4,0);
4685     VARXOR(I1,-1,I2,0,I4,-1);
4686     VARXOR(I1,0,I2,0,I4,0);
4687     VARXOR(I1,-1,UI2,65535,I4,-65536);
4688     VARXOR(I1,-1,UI2,0,I4,-1);
4689     VARXOR(I1,0,UI2,0,I4,0);
4690     VARXOR(I1,-1,I4,-1,I4,0);
4691     VARXOR(I1,-1,I4,0,I4,-1);
4692     VARXOR(I1,0,I4,0,I4,0);
4693     VARXOR(I1,-1,UI4,0xffffffff,I4,0);
4694     VARXOR(I1,-1,UI4,0,I4,-1);
4695     VARXOR(I1,0,UI4,0,I4,0);
4696     VARXOR(I1,-1,R4,-1,I4,0);
4697     VARXOR(I1,-1,R4,0,I4,-1);
4698     VARXOR(I1,0,R4,0,I4,0);
4699     VARXOR(I1,-1,R8,-1,I4,0);
4700     VARXOR(I1,-1,R8,0,I4,-1);
4701     VARXOR(I1,0,R8,0,I4,0);
4702     VARXOR(I1,-1,DATE,-1,I4,0);
4703     VARXOR(I1,-1,DATE,0,I4,-1);
4704     VARXOR(I1,0,DATE,0,I4,0);
4705     if (has_i8)
4706     {
4707         VARXOR(I1,-1,I8,-1,I8,0);
4708         VARXOR(I1,-1,I8,0,I8,-1);
4709         VARXOR(I1,0,I8,0,I8,0);
4710         VARXOR(I1,-1,UI8,0,I4,-1);
4711         VARXOR(I1,0,UI8,0,I4,0);
4712     }
4713     VARXOR(I1,-1,INT,-1,I4,0);
4714     VARXOR(I1,-1,INT,0,I4,-1);
4715     VARXOR(I1,0,INT,0,I4,0);
4716     VARXOR(I1,-1,UINT,0xffffffff,I4,0);
4717     VARXOR(I1,-1,UINT,0,I4,-1);
4718     VARXOR(I1,0,UINT,0,I4,0);
4719     rbstr = SysAllocString(szFalse);
4720     VARXOR(I1,0,BSTR,rbstr,I4,0);
4721     VARXOR(I1,-1,BSTR,rbstr,I4,-1);
4722     SysFreeString(rbstr);
4723     rbstr = SysAllocString(szTrue);
4724     VARXOR(I1,0,BSTR,rbstr,I4,-1);
4725     VARXOR(I1,-1,BSTR,rbstr,I4,0);
4726     SysFreeString(rbstr);
4727     VARXORCY(I1,-1,10000,I4,-2);
4728     VARXORCY(I1,-1,0,I4,-1);
4729     VARXORCY(I1,0,0,I4,0);
4730
4731     VARXOR(UI1,255,UI1,255,UI1,0);
4732     VARXOR(UI1,255,UI1,0,UI1,255);
4733     VARXOR(UI1,0,UI1,0,UI1,0);
4734     VARXOR(UI1,255,I2,-1,I2,-256);
4735     VARXOR(UI1,255,I2,0,I2,255);
4736     VARXOR(UI1,0,I2,0,I2,0);
4737     VARXOR(UI1,255,UI2,65535,I4,65280);
4738     VARXOR(UI1,255,UI2,0,I4,255);
4739     VARXOR(UI1,0,UI2,0,I4,0);
4740     VARXOR(UI1,255,I4,-1,I4,-256);
4741     VARXOR(UI1,255,I4,0,I4,255);
4742     VARXOR(UI1,0,I4,0,I4,0);
4743     VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
4744     VARXOR(UI1,255,UI4,0,I4,255);
4745     VARXOR(UI1,0,UI4,0,I4,0);
4746     VARXOR(UI1,255,R4,-1,I4,-256);
4747     VARXOR(UI1,255,R4,0,I4,255);
4748     VARXOR(UI1,0,R4,0,I4,0);
4749     VARXOR(UI1,255,R8,-1,I4,-256);
4750     VARXOR(UI1,255,R8,0,I4,255);
4751     VARXOR(UI1,0,R8,0,I4,0);
4752     VARXOR(UI1,255,DATE,-1,I4,-256);
4753     VARXOR(UI1,255,DATE,0,I4,255);
4754     VARXOR(UI1,0,DATE,0,I4,0);
4755     if (has_i8)
4756     {
4757         VARXOR(UI1,255,I8,-1,I8,-256);
4758         VARXOR(UI1,255,I8,0,I8,255);
4759         VARXOR(UI1,0,I8,0,I8,0);
4760         VARXOR(UI1,255,UI8,0,I4,255);
4761         VARXOR(UI1,0,UI8,0,I4,0);
4762     }
4763     VARXOR(UI1,255,INT,-1,I4,-256);
4764     VARXOR(UI1,255,INT,0,I4,255);
4765     VARXOR(UI1,0,INT,0,I4,0);
4766     VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
4767     VARXOR(UI1,255,UINT,0,I4,255);
4768     VARXOR(UI1,0,UINT,0,I4,0);
4769     rbstr = SysAllocString(szFalse);
4770     VARXOR(UI1,0,BSTR,rbstr,I2,0);
4771     VARXOR(UI1,255,BSTR,rbstr,I2,255);
4772     SysFreeString(rbstr);
4773     rbstr = SysAllocString(szTrue);
4774     VARXOR(UI1,0,BSTR,rbstr,I2,-1);
4775     VARXOR(UI1,255,BSTR,rbstr,I2,-256);
4776     SysFreeString(rbstr);
4777     VARXORCY(UI1,255,10000,I4,254);
4778     VARXORCY(UI1,255,0,I4,255);
4779     VARXORCY(UI1,0,0,I4,0);
4780
4781     VARXOR(I2,-1,I2,-1,I2,0);
4782     VARXOR(I2,-1,I2,0,I2,-1);
4783     VARXOR(I2,0,I2,0,I2,0);
4784     VARXOR(I2,-1,UI2,65535,I4,-65536);
4785     VARXOR(I2,-1,UI2,0,I4,-1);
4786     VARXOR(I2,0,UI2,0,I4,0);
4787     VARXOR(I2,-1,I4,-1,I4,0);
4788     VARXOR(I2,-1,I4,0,I4,-1);
4789     VARXOR(I2,0,I4,0,I4,0);
4790     VARXOR(I2,-1,UI4,0xffffffff,I4,0);
4791     VARXOR(I2,-1,UI4,0,I4,-1);
4792     VARXOR(I2,0,UI4,0,I4,0);
4793     VARXOR(I2,-1,R4,-1,I4,0);
4794     VARXOR(I2,-1,R4,0,I4,-1);
4795     VARXOR(I2,0,R4,0,I4,0);
4796     VARXOR(I2,-1,R8,-1,I4,0);
4797     VARXOR(I2,-1,R8,0,I4,-1);
4798     VARXOR(I2,0,R8,0,I4,0);
4799     VARXOR(I2,-1,DATE,-1,I4,0);
4800     VARXOR(I2,-1,DATE,0,I4,-1);
4801     VARXOR(I2,0,DATE,0,I4,0);
4802     if (has_i8)
4803     {
4804         VARXOR(I2,-1,I8,-1,I8,0);
4805         VARXOR(I2,-1,I8,0,I8,-1);
4806         VARXOR(I2,0,I8,0,I8,0);
4807         VARXOR(I2,-1,UI8,0,I4,-1);
4808         VARXOR(I2,0,UI8,0,I4,0);
4809     }
4810     VARXOR(I2,-1,INT,-1,I4,0);
4811     VARXOR(I2,-1,INT,0,I4,-1);
4812     VARXOR(I2,0,INT,0,I4,0);
4813     VARXOR(I2,-1,UINT,0xffffffff,I4,0);
4814     VARXOR(I2,-1,UINT,0,I4,-1);
4815     VARXOR(I2,0,UINT,0,I4,0);
4816     rbstr = SysAllocString(szFalse);
4817     VARXOR(I2,0,BSTR,rbstr,I2,0);
4818     VARXOR(I2,-1,BSTR,rbstr,I2,-1);
4819     SysFreeString(rbstr);
4820     rbstr = SysAllocString(szTrue);
4821     VARXOR(I2,0,BSTR,rbstr,I2,-1);
4822     VARXOR(I2,-1,BSTR,rbstr,I2,0);
4823     SysFreeString(rbstr);
4824     VARXORCY(I2,-1,10000,I4,-2);
4825     VARXORCY(I2,-1,0,I4,-1);
4826     VARXORCY(I2,0,0,I4,0);
4827
4828     VARXOR(UI2,65535,UI2,65535,I4,0);
4829     VARXOR(UI2,65535,UI2,0,I4,65535);
4830     VARXOR(UI2,0,UI2,0,I4,0);
4831     VARXOR(UI2,65535,I4,-1,I4,-65536);
4832     VARXOR(UI2,65535,I4,0,I4,65535);
4833     VARXOR(UI2,0,I4,0,I4,0);
4834     VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
4835     VARXOR(UI2,65535,UI4,0,I4,65535);
4836     VARXOR(UI2,0,UI4,0,I4,0);
4837     VARXOR(UI2,65535,R4,-1,I4,-65536);
4838     VARXOR(UI2,65535,R4,0,I4,65535);
4839     VARXOR(UI2,0,R4,0,I4,0);
4840     VARXOR(UI2,65535,R8,-1,I4,-65536);
4841     VARXOR(UI2,65535,R8,0,I4,65535);
4842     VARXOR(UI2,0,R8,0,I4,0);
4843     VARXOR(UI2,65535,DATE,-1,I4,-65536);
4844     VARXOR(UI2,65535,DATE,0,I4,65535);
4845     VARXOR(UI2,0,DATE,0,I4,0);
4846     if (has_i8)
4847     {
4848         VARXOR(UI2,65535,I8,-1,I8,-65536);
4849         VARXOR(UI2,65535,I8,0,I8,65535);
4850         VARXOR(UI2,0,I8,0,I8,0);
4851         VARXOR(UI2,65535,UI8,0,I4,65535);
4852         VARXOR(UI2,0,UI8,0,I4,0);
4853     }
4854     VARXOR(UI2,65535,INT,-1,I4,-65536);
4855     VARXOR(UI2,65535,INT,0,I4,65535);
4856     VARXOR(UI2,0,INT,0,I4,0);
4857     VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
4858     VARXOR(UI2,65535,UINT,0,I4,65535);
4859     VARXOR(UI2,0,UINT,0,I4,0);
4860     rbstr = SysAllocString(szFalse);
4861     VARXOR(UI2,0,BSTR,rbstr,I4,0);
4862     VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
4863     SysFreeString(rbstr);
4864     rbstr = SysAllocString(szTrue);
4865     VARXOR(UI2,0,BSTR,rbstr,I4,-1);
4866     VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
4867     SysFreeString(rbstr);
4868     VARXORCY(UI2,65535,10000,I4,65534);
4869     VARXORCY(UI2,65535,0,I4,65535);
4870     VARXORCY(UI2,0,0,I4,0);
4871
4872     VARXOR(I4,-1,I4,-1,I4,0);
4873     VARXOR(I4,-1,I4,0,I4,-1);
4874     VARXOR(I4,0,I4,0,I4,0);
4875     VARXOR(I4,-1,UI4,0xffffffff,I4,0);
4876     VARXOR(I4,-1,UI4,0,I4,-1);
4877     VARXOR(I4,0,UI4,0,I4,0);
4878     VARXOR(I4,-1,R4,-1,I4,0);
4879     VARXOR(I4,-1,R4,0,I4,-1);
4880     VARXOR(I4,0,R4,0,I4,0);
4881     VARXOR(I4,-1,R8,-1,I4,0);
4882     VARXOR(I4,-1,R8,0,I4,-1);
4883     VARXOR(I4,0,R8,0,I4,0);
4884     VARXOR(I4,-1,DATE,-1,I4,0);
4885     VARXOR(I4,-1,DATE,0,I4,-1);
4886     VARXOR(I4,0,DATE,0,I4,0);
4887     if (has_i8)
4888     {
4889         VARXOR(I4,-1,I8,-1,I8,0);
4890         VARXOR(I4,-1,I8,0,I8,-1);
4891         VARXOR(I4,0,I8,0,I8,0);
4892         VARXOR(I4,-1,UI8,0,I4,-1);
4893         VARXOR(I4,0,UI8,0,I4,0);
4894     }
4895     VARXOR(I4,-1,INT,-1,I4,0);
4896     VARXOR(I4,-1,INT,0,I4,-1);
4897     VARXOR(I4,0,INT,0,I4,0);
4898     VARXOR(I4,-1,UINT,0xffffffff,I4,0);
4899     VARXOR(I4,-1,UINT,0,I4,-1);
4900     VARXOR(I4,0,UINT,0,I4,0);
4901     rbstr = SysAllocString(szFalse);
4902     VARXOR(I4,0,BSTR,rbstr,I4,0);
4903     VARXOR(I4,-1,BSTR,rbstr,I4,-1);
4904     SysFreeString(rbstr);
4905     rbstr = SysAllocString(szTrue);
4906     VARXOR(I4,0,BSTR,rbstr,I4,-1);
4907     VARXOR(I4,-1,BSTR,rbstr,I4,0);
4908     SysFreeString(rbstr);
4909     VARXORCY(I4,-1,10000,I4,-2);
4910     VARXORCY(I4,-1,0,I4,-1);
4911     VARXORCY(I4,0,0,I4,0);
4912
4913     VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
4914     VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
4915     VARXOR(UI4,0,UI4,0,I4,0);
4916     VARXOR(UI4,0xffffffff,R4,-1,I4,0);
4917     VARXOR(UI4,0xffffffff,R4,0,I4,-1);
4918     VARXOR(UI4,0,R4,0,I4,0);
4919     VARXOR(UI4,0xffffffff,R8,-1,I4,0);
4920     VARXOR(UI4,0xffffffff,R8,0,I4,-1);
4921     VARXOR(UI4,0,R8,0,I4,0);
4922     VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
4923     VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
4924     VARXOR(UI4,0,DATE,0,I4,0);
4925     if (has_i8)
4926     {
4927         VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4928         VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
4929         VARXOR(UI4,0,I8,0,I8,0);
4930         VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
4931         VARXOR(UI4,0,UI8,0,I4,0);
4932     }
4933     VARXOR(UI4,0xffffffff,INT,-1,I4,0);
4934     VARXOR(UI4,0xffffffff,INT,0,I4,-1);
4935     VARXOR(UI4,0,INT,0,I4,0);
4936     VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
4937     VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
4938     VARXOR(UI4,0,UINT,0,I4,0);
4939     rbstr = SysAllocString(szFalse);
4940     VARXOR(UI4,0,BSTR,rbstr,I4,0);
4941     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4942     SysFreeString(rbstr);
4943     rbstr = SysAllocString(szTrue);
4944     VARXOR(UI4,0,BSTR,rbstr,I4,-1);
4945     VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
4946     SysFreeString(rbstr);
4947     VARXORCY(UI4,0xffffffff,10000,I4,-2);
4948     VARXORCY(UI4,0xffffffff,0,I4,-1);
4949     VARXORCY(UI4,0,0,I4,0);
4950
4951     VARXOR(R4,-1,R4,-1,I4,0);
4952     VARXOR(R4,-1,R4,0,I4,-1);
4953     VARXOR(R4,0,R4,0,I4,0);
4954     VARXOR(R4,-1,R8,-1,I4,0);
4955     VARXOR(R4,-1,R8,0,I4,-1);
4956     VARXOR(R4,0,R8,0,I4,0);
4957     VARXOR(R4,-1,DATE,-1,I4,0);
4958     VARXOR(R4,-1,DATE,0,I4,-1);
4959     VARXOR(R4,0,DATE,0,I4,0);
4960     if (has_i8)
4961     {
4962         VARXOR(R4,-1,I8,-1,I8,0);
4963         VARXOR(R4,-1,I8,0,I8,-1);
4964         VARXOR(R4,0,I8,0,I8,0);
4965         VARXOR(R4,-1,UI8,0,I4,-1);
4966         VARXOR(R4,0,UI8,0,I4,0);
4967     }
4968     VARXOR(R4,-1,INT,-1,I4,0);
4969     VARXOR(R4,-1,INT,0,I4,-1);
4970     VARXOR(R4,0,INT,0,I4,0);
4971     VARXOR(R4,-1,UINT,0xffffffff,I4,0);
4972     VARXOR(R4,-1,UINT,0,I4,-1);
4973     VARXOR(R4,0,UINT,0,I4,0);
4974     rbstr = SysAllocString(szFalse);
4975     VARXOR(R4,0,BSTR,rbstr,I4,0);
4976     VARXOR(R4,-1,BSTR,rbstr,I4,-1);
4977     SysFreeString(rbstr);
4978     rbstr = SysAllocString(szTrue);
4979     VARXOR(R4,0,BSTR,rbstr,I4,-1);
4980     VARXOR(R4,-1,BSTR,rbstr,I4,0);
4981     SysFreeString(rbstr);
4982     VARXORCY(R4,-1,10000,I4,-2);
4983     VARXORCY(R4,-1,0,I4,-1);
4984     VARXORCY(R4,0,0,I4,0);
4985
4986     VARXOR(R8,-1,R8,-1,I4,0);
4987     VARXOR(R8,-1,R8,0,I4,-1);
4988     VARXOR(R8,0,R8,0,I4,0);
4989     VARXOR(R8,-1,DATE,-1,I4,0);
4990     VARXOR(R8,-1,DATE,0,I4,-1);
4991     VARXOR(R8,0,DATE,0,I4,0);
4992     if (has_i8)
4993     {
4994         VARXOR(R8,-1,I8,-1,I8,0);
4995         VARXOR(R8,-1,I8,0,I8,-1);
4996         VARXOR(R8,0,I8,0,I8,0);
4997         VARXOR(R8,-1,UI8,0,I4,-1);
4998         VARXOR(R8,0,UI8,0,I4,0);
4999     }
5000     VARXOR(R8,-1,INT,-1,I4,0);
5001     VARXOR(R8,-1,INT,0,I4,-1);
5002     VARXOR(R8,0,INT,0,I4,0);
5003     VARXOR(R8,-1,UINT,0xffffffff,I4,0);
5004     VARXOR(R8,-1,UINT,0,I4,-1);
5005     VARXOR(R8,0,UINT,0,I4,0);
5006     rbstr = SysAllocString(szFalse);
5007     VARXOR(R8,0,BSTR,rbstr,I4,0);
5008     VARXOR(R8,-1,BSTR,rbstr,I4,-1);
5009     SysFreeString(rbstr);
5010     rbstr = SysAllocString(szTrue);
5011     VARXOR(R8,0,BSTR,rbstr,I4,-1);
5012     VARXOR(R8,-1,BSTR,rbstr,I4,0);
5013     SysFreeString(rbstr);
5014     VARXORCY(R8,-1,10000,I4,-2);
5015     VARXORCY(R8,-1,0,I4,-1);
5016     VARXORCY(R8,0,0,I4,0);
5017
5018     VARXOR(DATE,-1,DATE,-1,I4,0);
5019     VARXOR(DATE,-1,DATE,0,I4,-1);
5020     VARXOR(DATE,0,DATE,0,I4,0);
5021     if (has_i8)
5022     {
5023         VARXOR(DATE,-1,I8,-1,I8,0);
5024         VARXOR(DATE,-1,I8,0,I8,-1);
5025         VARXOR(DATE,0,I8,0,I8,0);
5026         VARXOR(DATE,-1,UI8,0,I4,-1);
5027         VARXOR(DATE,0,UI8,0,I4,0);
5028     }
5029     VARXOR(DATE,-1,INT,-1,I4,0);
5030     VARXOR(DATE,-1,INT,0,I4,-1);
5031     VARXOR(DATE,0,INT,0,I4,0);
5032     VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
5033     VARXOR(DATE,-1,UINT,0,I4,-1);
5034     VARXOR(DATE,0,UINT,0,I4,0);
5035     rbstr = SysAllocString(szFalse);
5036     VARXOR(DATE,0,BSTR,rbstr,I4,0);
5037     VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
5038     SysFreeString(rbstr);
5039     rbstr = SysAllocString(szTrue);
5040     VARXOR(DATE,0,BSTR,rbstr,I4,-1);
5041     VARXOR(DATE,-1,BSTR,rbstr,I4,0);
5042     SysFreeString(rbstr);
5043     VARXORCY(DATE,-1,10000,I4,-2);
5044     VARXORCY(DATE,-1,0,I4,-1);
5045     VARXORCY(DATE,0,0,I4,0);
5046
5047     if (has_i8)
5048     {
5049         VARXOR(I8,-1,I8,-1,I8,0);
5050         VARXOR(I8,-1,I8,0,I8,-1);
5051         VARXOR(I8,0,I8,0,I8,0);
5052         VARXOR(I8,-1,UI8,0,I8,-1);
5053         VARXOR(I8,0,UI8,0,I8,0);
5054         VARXOR(I8,-1,UINT,0,I8,-1);
5055         VARXOR(I8,0,UINT,0,I8,0);
5056         rbstr = SysAllocString(szFalse);
5057         VARXOR(I8,0,BSTR,rbstr,I8,0);
5058         VARXOR(I8,-1,BSTR,rbstr,I8,-1);
5059         SysFreeString(rbstr);
5060         rbstr = SysAllocString(szTrue);
5061         VARXOR(I8,0,BSTR,rbstr,I8,-1);
5062         VARXOR(I8,-1,BSTR,rbstr,I8,0);
5063         SysFreeString(rbstr);
5064         VARXORCY(I8,-1,10000,I8,-2);
5065         VARXORCY(I8,-1,0,I8,-1);
5066         VARXORCY(I8,0,0,I8,0);
5067
5068         VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
5069         VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
5070         VARXOR(UI8,0,UI8,0,I4,0);
5071         VARXOR(UI8,0xffff,INT,-1,I4,-65536);
5072         VARXOR(UI8,0xffff,INT,0,I4,0xffff);
5073         VARXOR(UI8,0,INT,0,I4,0);
5074         VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
5075         VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
5076         VARXOR(UI8,0,UINT,0,I4,0);
5077         rbstr = SysAllocString(szFalse);
5078         VARXOR(UI8,0,BSTR,rbstr,I4,0);
5079         VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
5080         SysFreeString(rbstr);
5081         rbstr = SysAllocString(szTrue);
5082         VARXOR(UI8,0,BSTR,rbstr,I4,-1);
5083         VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
5084         SysFreeString(rbstr);
5085         VARXORCY(UI8,0xffff,10000,I4,65534);
5086         VARXORCY(UI8,0xffff,0,I4,0xffff);
5087         VARXORCY(UI8,0,0,I4,0);
5088     }
5089
5090     VARXOR(INT,-1,INT,-1,I4,0);
5091     VARXOR(INT,-1,INT,0,I4,-1);
5092     VARXOR(INT,0,INT,0,I4,0);
5093     VARXOR(INT,-1,UINT,0xffff,I4,-65536);
5094     VARXOR(INT,-1,UINT,0,I4,-1);
5095     VARXOR(INT,0,UINT,0,I4,0);
5096     rbstr = SysAllocString(szFalse);
5097     VARXOR(INT,0,BSTR,rbstr,I4,0);
5098     VARXOR(INT,-1,BSTR,rbstr,I4,-1);
5099     SysFreeString(rbstr);
5100     rbstr = SysAllocString(szTrue);
5101     VARXOR(INT,0,BSTR,rbstr,I4,-1);
5102     VARXOR(INT,-1,BSTR,rbstr,I4,0);
5103     SysFreeString(rbstr);
5104     VARXORCY(INT,-1,10000,I4,-2);
5105     VARXORCY(INT,-1,0,I4,-1);
5106     VARXORCY(INT,0,0,I4,0);
5107
5108     VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
5109     VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
5110     VARXOR(UINT,0,UINT,0,I4,0);
5111     rbstr = SysAllocString(szFalse);
5112     VARXOR(UINT,0,BSTR,rbstr,I4,0);
5113     VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
5114     SysFreeString(rbstr);
5115     rbstr = SysAllocString(szTrue);
5116     VARXOR(UINT,0,BSTR,rbstr,I4,-1);
5117     VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
5118     SysFreeString(rbstr);
5119     VARXORCY(UINT,0xffff,10000,I4,65534);
5120     VARXORCY(UINT,0xffff,0,I4,0xffff);
5121     VARXORCY(UINT,0,0,I4,0);
5122
5123     lbstr = SysAllocString(szFalse);
5124     rbstr = SysAllocString(szFalse);
5125     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
5126     SysFreeString(rbstr);
5127     rbstr = SysAllocString(szTrue);
5128     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
5129     SysFreeString(lbstr);
5130     lbstr = SysAllocString(szTrue);
5131     VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
5132     VARXORCY(BSTR,lbstr,10000,I4,-2);
5133     SysFreeString(lbstr);
5134     lbstr = SysAllocString(szFalse);
5135     VARXORCY(BSTR,lbstr,10000,I4,1);
5136     SysFreeString(lbstr);
5137     SysFreeString(rbstr);
5138 }
5139
5140 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
5141
5142 #define VAROR(vt1,val1,vt2,val2,rvt,rval)                \
5143         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5144         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5145         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5146         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
5147
5148 #define VARORCY(vt1,val1,val2,rvt,rval)                  \
5149         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5150         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5151         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5152         test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
5153
5154 static void test_VarOr(void)
5155 {
5156     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5157     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5158     VARIANT left, right, exp, result;
5159     BSTR lbstr, rbstr;
5160     VARTYPE i;
5161     HRESULT hres;
5162
5163     CHECKPTR(VarOr);
5164
5165     /* Test all possible flag/vt combinations & the resulting vt type */
5166     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
5167     {
5168         VARTYPE leftvt, rightvt, resvt;
5169
5170         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5171         {
5172
5173             SKIPTESTS(leftvt);
5174
5175             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5176             {
5177                 BOOL bFail = FALSE;
5178
5179                 SKIPTESTS(rightvt);
5180
5181                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
5182                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5183                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5184                     continue;
5185
5186                 memset(&left, 0, sizeof(left));
5187                 memset(&right, 0, sizeof(right));
5188                 V_VT(&left) = leftvt | ExtraFlags[i];
5189                 V_VT(&right) = rightvt | ExtraFlags[i];
5190                 V_VT(&result) = VT_EMPTY;
5191                 resvt = VT_I4;
5192
5193                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5194                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5195                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5196                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5197                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5198                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5199                     leftvt == VT_ERROR || rightvt == VT_ERROR)
5200                 {
5201                     bFail = TRUE;
5202                 }
5203                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5204                 {
5205                     if (leftvt == rightvt ||
5206                         leftvt == VT_I2 || rightvt == VT_I2 ||
5207                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
5208                         leftvt == VT_BOOL || rightvt == VT_BOOL)
5209                         resvt = VT_I2;
5210                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
5211                         resvt = VT_NULL;
5212                     else if (leftvt == VT_I8 || rightvt == VT_I8)
5213                         resvt = VT_I8;
5214                 }
5215                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
5216                 {
5217                     resvt = VT_NULL;
5218                 }
5219                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5220                 {
5221                     if (leftvt == rightvt)
5222                         resvt = VT_UI1;
5223                     else if (leftvt == rightvt ||
5224                         leftvt == VT_I2 || rightvt == VT_I2 ||
5225                         leftvt == VT_BOOL || rightvt == VT_BOOL)
5226                     {
5227                         resvt = VT_I2;
5228                     }
5229                     else if (leftvt == VT_I8 || rightvt == VT_I8)
5230                         resvt = VT_I8;
5231                 }
5232                 else if (leftvt == VT_I2 || rightvt == VT_I2)
5233                 {
5234                     if (leftvt == rightvt ||
5235                         leftvt == VT_BOOL || rightvt == VT_BOOL)
5236                         resvt = VT_I2;
5237                     else if (leftvt == VT_I8 || rightvt == VT_I8)
5238                         resvt = VT_I8;
5239                 }
5240                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
5241                 {
5242                     resvt = VT_BOOL;
5243                 }
5244                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5245                 {
5246                     if (leftvt == VT_INT || rightvt == VT_INT)
5247                         bFail = TRUE;
5248                     else
5249                         resvt = VT_I8;
5250                 }
5251                 hres = pVarOr(&left, &right, &result);
5252                 if (bFail)
5253                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5254                        "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
5255                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5256                        V_VT(&result));
5257                 else
5258                     ok(hres == S_OK && V_VT(&result) == resvt,
5259                        "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
5260                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5261                        V_VT(&result));
5262             }
5263         }
5264     }
5265
5266     /* Test returned values. Since we know the returned type is correct
5267      * and that we handle all combinations of invalid types, just check
5268      * that good type combinations produce the desired value.
5269      * FIXME: Test VT_DECIMAL/VT_DISPATCH
5270      */
5271     VAROR(EMPTY,0,EMPTY,0,I2,0);
5272     VAROR(EMPTY,1,EMPTY,0,I2,0);
5273     VAROR(EMPTY,0,NULL,0,NULL,0);
5274     VAROR(EMPTY,0,I1,0,I4,0);
5275     VAROR(EMPTY,0,I1,1,I4,1);
5276     VAROR(EMPTY,0,UI1,0,I2,0);
5277     VAROR(EMPTY,0,UI1,1,I2,1);
5278     VAROR(EMPTY,0,I2,0,I2,0);
5279     VAROR(EMPTY,0,I2,1,I2,1);
5280     VAROR(EMPTY,0,UI2,0,I4,0);
5281     VAROR(EMPTY,0,UI2,1,I4,1);
5282     VAROR(EMPTY,0,I4,0,I4,0);
5283     VAROR(EMPTY,0,I4,1,I4,1);
5284     VAROR(EMPTY,0,UI4,0,I4,0);
5285     VAROR(EMPTY,0,UI4,1,I4,1);
5286     if (has_i8)
5287     {
5288         VAROR(EMPTY,0,I8,0,I8,0);
5289         VAROR(EMPTY,0,I8,1,I8,1);
5290         VAROR(EMPTY,0,UI8,0,I4,0);
5291         VAROR(EMPTY,0,UI8,1,I4,1);
5292     }
5293     VAROR(EMPTY,0,INT,0,I4,0);
5294     VAROR(EMPTY,0,INT,1,I4,1);
5295     VAROR(EMPTY,0,UINT,0,I4,0);
5296     VAROR(EMPTY,0,UINT,1,I4,1);
5297     VAROR(EMPTY,0,BOOL,0,I2,0);
5298     VAROR(EMPTY,0,BOOL,1,I2,1);
5299     VAROR(EMPTY,0,R4,0,I4,0);
5300     VAROR(EMPTY,0,R4,1,I4,1);
5301     VAROR(EMPTY,0,R8,0,I4,0);
5302     VAROR(EMPTY,0,R8,1,I4,1);
5303     rbstr = SysAllocString(szFalse);
5304     VAROR(EMPTY,0,BSTR,rbstr,I2,0);
5305     SysFreeString(rbstr);
5306     rbstr = SysAllocString(szTrue);
5307     VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
5308     SysFreeString(rbstr);
5309     VARORCY(EMPTY,0,10000,I4,1);
5310
5311     /* NULL OR 0 = NULL. NULL OR n = n */
5312     VAROR(NULL,0,NULL,0,NULL,0);
5313     VAROR(NULL,1,NULL,0,NULL,0);
5314     VAROR(NULL,0,I1,0,NULL,0);
5315     VAROR(NULL,0,I1,1,I4,1);
5316     VAROR(NULL,0,UI1,0,NULL,0);
5317     VAROR(NULL,0,UI1,1,UI1,1);
5318     VAROR(NULL,0,I2,0,NULL,0);
5319     VAROR(NULL,0,I2,1,I2,1);
5320     VAROR(NULL,0,UI2,0,NULL,0);
5321     VAROR(NULL,0,UI2,1,I4,1);
5322     VAROR(NULL,0,I4,0,NULL,0);
5323     VAROR(NULL,0,I4,1,I4,1);
5324     VAROR(NULL,0,UI4,0,NULL,0);
5325     VAROR(NULL,0,UI4,1,I4,1);
5326     if (has_i8)
5327     {
5328         VAROR(NULL,0,I8,0,NULL,0);
5329         VAROR(NULL,0,I8,1,I8,1);
5330         VAROR(NULL,0,UI8,0,NULL,0);
5331         VAROR(NULL,0,UI8,1,I4,1);
5332     }
5333     VAROR(NULL,0,INT,0,NULL,0);
5334     VAROR(NULL,0,INT,1,I4,1);
5335     VAROR(NULL,0,UINT,0,NULL,0);
5336     VAROR(NULL,0,UINT,1,I4,1);
5337     VAROR(NULL,0,BOOL,0,NULL,0);
5338     VAROR(NULL,0,BOOL,1,BOOL,1);
5339     VAROR(NULL,0,R4,0,NULL,0);
5340     VAROR(NULL,0,R4,1,I4,1);
5341     VAROR(NULL,0,R8,0,NULL,0);
5342     VAROR(NULL,0,R8,1,I4,1);
5343     rbstr = SysAllocString(szFalse);
5344     VAROR(NULL,0,BSTR,rbstr,NULL,0);
5345     SysFreeString(rbstr);
5346     rbstr = SysAllocString(szTrue);
5347     VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
5348     SysFreeString(rbstr);
5349     VARORCY(NULL,0,10000,I4,1);
5350     VARORCY(NULL,0,0,NULL,0);
5351
5352     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5353     VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
5354     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5355     VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5356     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5357     VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5358     VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
5359     VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
5360     VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
5361     VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
5362     VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5363     VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5364     VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
5365     VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
5366     VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
5367     VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
5368     VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5369     VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5370     VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
5371     VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
5372     VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5373     VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
5374     VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5375     VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5376     VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
5377     VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
5378     VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5379     VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
5380     VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
5381     VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5382     VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
5383     VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5384     if (has_i8)
5385     {
5386         VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5387         VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
5388         VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
5389         /* This returns DISP_E_OVERFLOW which indicates that a conversion
5390          * to I4 is performed.
5391          */
5392         /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
5393         VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
5394         VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5395     }
5396     VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5397     VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
5398     VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
5399     VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5400     VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
5401     VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5402     rbstr = SysAllocString(szFalse);
5403     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
5404     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
5405     SysFreeString(rbstr);
5406     rbstr = SysAllocString(szTrue);
5407     VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
5408     VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
5409     SysFreeString(rbstr);
5410     VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
5411     VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
5412     VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
5413
5414     VAROR(I1,-1,I1,-1,I4,-1);
5415     VAROR(I1,-1,I1,0,I4,-1);
5416     VAROR(I1,0,I1,0,I4,0);
5417     VAROR(I1,-1,UI1,255,I4,-1);
5418     VAROR(I1,-1,UI1,0,I4,-1);
5419     VAROR(I1,0,UI1,0,I4,0);
5420     VAROR(I1,-1,I2,-1,I4,-1);
5421     VAROR(I1,-1,I2,0,I4,-1);
5422     VAROR(I1,0,I2,0,I4,0);
5423     VAROR(I1,-1,UI2,65535,I4,-1);
5424     VAROR(I1,-1,UI2,0,I4,-1);
5425     VAROR(I1,0,UI2,0,I4,0);
5426     VAROR(I1,-1,I4,-1,I4,-1);
5427     VAROR(I1,-1,I4,0,I4,-1);
5428     VAROR(I1,0,I4,0,I4,0);
5429     VAROR(I1,-1,UI4,0xffffffff,I4,-1);
5430     VAROR(I1,-1,UI4,0,I4,-1);
5431     VAROR(I1,0,UI4,0,I4,0);
5432     VAROR(I1,-1,R4,-1,I4,-1);
5433     VAROR(I1,-1,R4,0,I4,-1);
5434     VAROR(I1,0,R4,0,I4,0);
5435     VAROR(I1,-1,R8,-1,I4,-1);
5436     VAROR(I1,-1,R8,0,I4,-1);
5437     VAROR(I1,0,R8,0,I4,0);
5438     VAROR(I1,-1,DATE,-1,I4,-1);
5439     VAROR(I1,-1,DATE,0,I4,-1);
5440     VAROR(I1,0,DATE,0,I4,0);
5441     if (has_i8)
5442     {
5443         VAROR(I1,-1,I8,-1,I8,-1);
5444         VAROR(I1,-1,I8,0,I8,-1);
5445         VAROR(I1,0,I8,0,I8,0);
5446         VAROR(I1,-1,UI8,0,I4,-1);
5447         VAROR(I1,0,UI8,0,I4,0);
5448     }
5449     VAROR(I1,-1,INT,-1,I4,-1);
5450     VAROR(I1,-1,INT,0,I4,-1);
5451     VAROR(I1,0,INT,0,I4,0);
5452     VAROR(I1,-1,UINT,0xffffffff,I4,-1);
5453     VAROR(I1,-1,UINT,0,I4,-1);
5454     VAROR(I1,0,UINT,0,I4,0);
5455     rbstr = SysAllocString(szFalse);
5456     VAROR(I1,0,BSTR,rbstr,I4,0);
5457     VAROR(I1,-1,BSTR,rbstr,I4,-1);
5458     SysFreeString(rbstr);
5459     rbstr = SysAllocString(szTrue);
5460     VAROR(I1,0,BSTR,rbstr,I4,-1);
5461     VAROR(I1,-1,BSTR,rbstr,I4,-1);
5462     SysFreeString(rbstr);
5463     VARORCY(I1,-1,10000,I4,-1);
5464     VARORCY(I1,-1,0,I4,-1);
5465     VARORCY(I1,0,0,I4,0);
5466
5467     VAROR(UI1,255,UI1,255,UI1,255);
5468     VAROR(UI1,255,UI1,0,UI1,255);
5469     VAROR(UI1,0,UI1,0,UI1,0);
5470     VAROR(UI1,255,I2,-1,I2,-1);
5471     VAROR(UI1,255,I2,0,I2,255);
5472     VAROR(UI1,0,I2,0,I2,0);
5473     VAROR(UI1,255,UI2,65535,I4,65535);
5474     VAROR(UI1,255,UI2,0,I4,255);
5475     VAROR(UI1,0,UI2,0,I4,0);
5476     VAROR(UI1,255,I4,-1,I4,-1);
5477     VAROR(UI1,255,I4,0,I4,255);
5478     VAROR(UI1,0,I4,0,I4,0);
5479     VAROR(UI1,255,UI4,0xffffffff,I4,-1);
5480     VAROR(UI1,255,UI4,0,I4,255);
5481     VAROR(UI1,0,UI4,0,I4,0);
5482     VAROR(UI1,255,R4,-1,I4,-1);
5483     VAROR(UI1,255,R4,0,I4,255);
5484     VAROR(UI1,0,R4,0,I4,0);
5485     VAROR(UI1,255,R8,-1,I4,-1);
5486     VAROR(UI1,255,R8,0,I4,255);
5487     VAROR(UI1,0,R8,0,I4,0);
5488     VAROR(UI1,255,DATE,-1,I4,-1);
5489     VAROR(UI1,255,DATE,0,I4,255);
5490     VAROR(UI1,0,DATE,0,I4,0);
5491     if (has_i8)
5492     {
5493         VAROR(UI1,255,I8,-1,I8,-1);
5494         VAROR(UI1,255,I8,0,I8,255);
5495         VAROR(UI1,0,I8,0,I8,0);
5496         VAROR(UI1,255,UI8,0,I4,255);
5497         VAROR(UI1,0,UI8,0,I4,0);
5498     }
5499     VAROR(UI1,255,INT,-1,I4,-1);
5500     VAROR(UI1,255,INT,0,I4,255);
5501     VAROR(UI1,0,INT,0,I4,0);
5502     VAROR(UI1,255,UINT,0xffffffff,I4,-1);
5503     VAROR(UI1,255,UINT,0,I4,255);
5504     VAROR(UI1,0,UINT,0,I4,0);
5505     rbstr = SysAllocString(szFalse);
5506     VAROR(UI1,0,BSTR,rbstr,I2,0);
5507     VAROR(UI1,255,BSTR,rbstr,I2,255);
5508     SysFreeString(rbstr);
5509     rbstr = SysAllocString(szTrue);
5510     VAROR(UI1,0,BSTR,rbstr,I2,-1);
5511     VAROR(UI1,255,BSTR,rbstr,I2,-1);
5512     SysFreeString(rbstr);
5513     VARORCY(UI1,255,10000,I4,255);
5514     VARORCY(UI1,255,0,I4,255);
5515     VARORCY(UI1,0,0,I4,0);
5516
5517     VAROR(I2,-1,I2,-1,I2,-1);
5518     VAROR(I2,-1,I2,0,I2,-1);
5519     VAROR(I2,0,I2,0,I2,0);
5520     VAROR(I2,-1,UI2,65535,I4,-1);
5521     VAROR(I2,-1,UI2,0,I4,-1);
5522     VAROR(I2,0,UI2,0,I4,0);
5523     VAROR(I2,-1,I4,-1,I4,-1);
5524     VAROR(I2,-1,I4,0,I4,-1);
5525     VAROR(I2,0,I4,0,I4,0);
5526     VAROR(I2,-1,UI4,0xffffffff,I4,-1);
5527     VAROR(I2,-1,UI4,0,I4,-1);
5528     VAROR(I2,0,UI4,0,I4,0);
5529     VAROR(I2,-1,R4,-1,I4,-1);
5530     VAROR(I2,-1,R4,0,I4,-1);
5531     VAROR(I2,0,R4,0,I4,0);
5532     VAROR(I2,-1,R8,-1,I4,-1);
5533     VAROR(I2,-1,R8,0,I4,-1);
5534     VAROR(I2,0,R8,0,I4,0);
5535     VAROR(I2,-1,DATE,-1,I4,-1);
5536     VAROR(I2,-1,DATE,0,I4,-1);
5537     VAROR(I2,0,DATE,0,I4,0);
5538     if (has_i8)
5539     {
5540         VAROR(I2,-1,I8,-1,I8,-1);
5541         VAROR(I2,-1,I8,0,I8,-1);
5542         VAROR(I2,0,I8,0,I8,0);
5543         VAROR(I2,-1,UI8,0,I4,-1);
5544         VAROR(I2,0,UI8,0,I4,0);
5545     }
5546     VAROR(I2,-1,INT,-1,I4,-1);
5547     VAROR(I2,-1,INT,0,I4,-1);
5548     VAROR(I2,0,INT,0,I4,0);
5549     VAROR(I2,-1,UINT,0xffffffff,I4,-1);
5550     VAROR(I2,-1,UINT,0,I4,-1);
5551     VAROR(I2,0,UINT,0,I4,0);
5552     rbstr = SysAllocString(szFalse);
5553     VAROR(I2,0,BSTR,rbstr,I2,0);
5554     VAROR(I2,-1,BSTR,rbstr,I2,-1);
5555     SysFreeString(rbstr);
5556     rbstr = SysAllocString(szTrue);
5557     VAROR(I2,0,BSTR,rbstr,I2,-1);
5558     VAROR(I2,-1,BSTR,rbstr,I2,-1);
5559     SysFreeString(rbstr);
5560     VARORCY(I2,-1,10000,I4,-1);
5561     VARORCY(I2,-1,0,I4,-1);
5562     VARORCY(I2,0,0,I4,0);
5563
5564     VAROR(UI2,65535,UI2,65535,I4,65535);
5565     VAROR(UI2,65535,UI2,0,I4,65535);
5566     VAROR(UI2,0,UI2,0,I4,0);
5567     VAROR(UI2,65535,I4,-1,I4,-1);
5568     VAROR(UI2,65535,I4,0,I4,65535);
5569     VAROR(UI2,0,I4,0,I4,0);
5570     VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
5571     VAROR(UI2,65535,UI4,0,I4,65535);
5572     VAROR(UI2,0,UI4,0,I4,0);
5573     VAROR(UI2,65535,R4,-1,I4,-1);
5574     VAROR(UI2,65535,R4,0,I4,65535);
5575     VAROR(UI2,0,R4,0,I4,0);
5576     VAROR(UI2,65535,R8,-1,I4,-1);
5577     VAROR(UI2,65535,R8,0,I4,65535);
5578     VAROR(UI2,0,R8,0,I4,0);
5579     VAROR(UI2,65535,DATE,-1,I4,-1);
5580     VAROR(UI2,65535,DATE,0,I4,65535);
5581     VAROR(UI2,0,DATE,0,I4,0);
5582     if (has_i8)
5583     {
5584         VAROR(UI2,65535,I8,-1,I8,-1);
5585         VAROR(UI2,65535,I8,0,I8,65535);
5586         VAROR(UI2,0,I8,0,I8,0);
5587         VAROR(UI2,65535,UI8,0,I4,65535);
5588         VAROR(UI2,0,UI8,0,I4,0);
5589     }
5590     VAROR(UI2,65535,INT,-1,I4,-1);
5591     VAROR(UI2,65535,INT,0,I4,65535);
5592     VAROR(UI2,0,INT,0,I4,0);
5593     VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
5594     VAROR(UI2,65535,UINT,0,I4,65535);
5595     VAROR(UI2,0,UINT,0,I4,0);
5596     rbstr = SysAllocString(szFalse);
5597     VAROR(UI2,0,BSTR,rbstr,I4,0);
5598     VAROR(UI2,65535,BSTR,rbstr,I4,65535);
5599     SysFreeString(rbstr);
5600     rbstr = SysAllocString(szTrue);
5601     VAROR(UI2,0,BSTR,rbstr,I4,-1);
5602     VAROR(UI2,65535,BSTR,rbstr,I4,-1);
5603     SysFreeString(rbstr);
5604     VARORCY(UI2,65535,10000,I4,65535);
5605     VARORCY(UI2,65535,0,I4,65535);
5606     VARORCY(UI2,0,0,I4,0);
5607
5608     VAROR(I4,-1,I4,-1,I4,-1);
5609     VAROR(I4,-1,I4,0,I4,-1);
5610     VAROR(I4,0,I4,0,I4,0);
5611     VAROR(I4,-1,UI4,0xffffffff,I4,-1);
5612     VAROR(I4,-1,UI4,0,I4,-1);
5613     VAROR(I4,0,UI4,0,I4,0);
5614     VAROR(I4,-1,R4,-1,I4,-1);
5615     VAROR(I4,-1,R4,0,I4,-1);
5616     VAROR(I4,0,R4,0,I4,0);
5617     VAROR(I4,-1,R8,-1,I4,-1);
5618     VAROR(I4,-1,R8,0,I4,-1);
5619     VAROR(I4,0,R8,0,I4,0);
5620     VAROR(I4,-1,DATE,-1,I4,-1);
5621     VAROR(I4,-1,DATE,0,I4,-1);
5622     VAROR(I4,0,DATE,0,I4,0);
5623     if (has_i8)
5624     {
5625         VAROR(I4,-1,I8,-1,I8,-1);
5626         VAROR(I4,-1,I8,0,I8,-1);
5627         VAROR(I4,0,I8,0,I8,0);
5628         VAROR(I4,-1,UI8,0,I4,-1);
5629         VAROR(I4,0,UI8,0,I4,0);
5630     }
5631     VAROR(I4,-1,INT,-1,I4,-1);
5632     VAROR(I4,-1,INT,0,I4,-1);
5633     VAROR(I4,0,INT,0,I4,0);
5634     VAROR(I4,-1,UINT,0xffffffff,I4,-1);
5635     VAROR(I4,-1,UINT,0,I4,-1);
5636     VAROR(I4,0,UINT,0,I4,0);
5637     rbstr = SysAllocString(szFalse);
5638     VAROR(I4,0,BSTR,rbstr,I4,0);
5639     VAROR(I4,-1,BSTR,rbstr,I4,-1);
5640     SysFreeString(rbstr);
5641     rbstr = SysAllocString(szTrue);
5642     VAROR(I4,0,BSTR,rbstr,I4,-1);
5643     VAROR(I4,-1,BSTR,rbstr,I4,-1);
5644     SysFreeString(rbstr);
5645     VARORCY(I4,-1,10000,I4,-1);
5646     VARORCY(I4,-1,0,I4,-1);
5647     VARORCY(I4,0,0,I4,0);
5648
5649     VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
5650     VAROR(UI4,0xffffffff,UI4,0,I4,-1);
5651     VAROR(UI4,0,UI4,0,I4,0);
5652     VAROR(UI4,0xffffffff,R4,-1,I4,-1);
5653     VAROR(UI4,0xffffffff,R4,0,I4,-1);
5654     VAROR(UI4,0,R4,0,I4,0);
5655     VAROR(UI4,0xffffffff,R8,-1,I4,-1);
5656     VAROR(UI4,0xffffffff,R8,0,I4,-1);
5657     VAROR(UI4,0,R8,0,I4,0);
5658     VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
5659     VAROR(UI4,0xffffffff,DATE,0,I4,-1);
5660     VAROR(UI4,0,DATE,0,I4,0);
5661     if (has_i8)
5662     {
5663         VAROR(UI4,0xffffffff,I8,-1,I8,-1);
5664         VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
5665         VAROR(UI4,0,I8,0,I8,0);
5666         VAROR(UI4,0xffffffff,UI8,0,I4,-1);
5667         VAROR(UI4,0,UI8,0,I4,0);
5668     }
5669     VAROR(UI4,0xffffffff,INT,-1,I4,-1);
5670     VAROR(UI4,0xffffffff,INT,0,I4,-1);
5671     VAROR(UI4,0,INT,0,I4,0);
5672     VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
5673     VAROR(UI4,0xffffffff,UINT,0,I4,-1);
5674     VAROR(UI4,0,UINT,0,I4,0);
5675     rbstr = SysAllocString(szFalse);
5676     VAROR(UI4,0,BSTR,rbstr,I4,0);
5677     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
5678     SysFreeString(rbstr);
5679     rbstr = SysAllocString(szTrue);
5680     VAROR(UI4,0,BSTR,rbstr,I4,-1);
5681     VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
5682     SysFreeString(rbstr);
5683     VARORCY(UI4,0xffffffff,10000,I4,-1);
5684     VARORCY(UI4,0xffffffff,0,I4,-1);
5685     VARORCY(UI4,0,0,I4,0);
5686
5687     VAROR(R4,-1,R4,-1,I4,-1);
5688     VAROR(R4,-1,R4,0,I4,-1);
5689     VAROR(R4,0,R4,0,I4,0);
5690     VAROR(R4,-1,R8,-1,I4,-1);
5691     VAROR(R4,-1,R8,0,I4,-1);
5692     VAROR(R4,0,R8,0,I4,0);
5693     VAROR(R4,-1,DATE,-1,I4,-1);
5694     VAROR(R4,-1,DATE,0,I4,-1);
5695     VAROR(R4,0,DATE,0,I4,0);
5696     if (has_i8)
5697     {
5698         VAROR(R4,-1,I8,-1,I8,-1);
5699         VAROR(R4,-1,I8,0,I8,-1);
5700         VAROR(R4,0,I8,0,I8,0);
5701         VAROR(R4,-1,UI8,0,I4,-1);
5702         VAROR(R4,0,UI8,0,I4,0);
5703     }
5704     VAROR(R4,-1,INT,-1,I4,-1);
5705     VAROR(R4,-1,INT,0,I4,-1);
5706     VAROR(R4,0,INT,0,I4,0);
5707     VAROR(R4,-1,UINT,0xffffffff,I4,-1);
5708     VAROR(R4,-1,UINT,0,I4,-1);
5709     VAROR(R4,0,UINT,0,I4,0);
5710     rbstr = SysAllocString(szFalse);
5711     VAROR(R4,0,BSTR,rbstr,I4,0);
5712     VAROR(R4,-1,BSTR,rbstr,I4,-1);
5713     SysFreeString(rbstr);
5714     rbstr = SysAllocString(szTrue);
5715     VAROR(R4,0,BSTR,rbstr,I4,-1);
5716     VAROR(R4,-1,BSTR,rbstr,I4,-1);
5717     SysFreeString(rbstr);
5718     VARORCY(R4,-1,10000,I4,-1);
5719     VARORCY(R4,-1,0,I4,-1);
5720     VARORCY(R4,0,0,I4,0);
5721
5722     VAROR(R8,-1,R8,-1,I4,-1);
5723     VAROR(R8,-1,R8,0,I4,-1);
5724     VAROR(R8,0,R8,0,I4,0);
5725     VAROR(R8,-1,DATE,-1,I4,-1);
5726     VAROR(R8,-1,DATE,0,I4,-1);
5727     VAROR(R8,0,DATE,0,I4,0);
5728     if (has_i8)
5729     {
5730         VAROR(R8,-1,I8,-1,I8,-1);
5731         VAROR(R8,-1,I8,0,I8,-1);
5732         VAROR(R8,0,I8,0,I8,0);
5733         VAROR(R8,-1,UI8,0,I4,-1);
5734         VAROR(R8,0,UI8,0,I4,0);
5735     }
5736     VAROR(R8,-1,INT,-1,I4,-1);
5737     VAROR(R8,-1,INT,0,I4,-1);
5738     VAROR(R8,0,INT,0,I4,0);
5739     VAROR(R8,-1,UINT,0xffffffff,I4,-1);
5740     VAROR(R8,-1,UINT,0,I4,-1);
5741     VAROR(R8,0,UINT,0,I4,0);
5742     rbstr = SysAllocString(szFalse);
5743     VAROR(R8,0,BSTR,rbstr,I4,0);
5744     VAROR(R8,-1,BSTR,rbstr,I4,-1);
5745     SysFreeString(rbstr);
5746     rbstr = SysAllocString(szTrue);
5747     VAROR(R8,0,BSTR,rbstr,I4,-1);
5748     VAROR(R8,-1,BSTR,rbstr,I4,-1);
5749     SysFreeString(rbstr);
5750     VARORCY(R8,-1,10000,I4,-1);
5751     VARORCY(R8,-1,0,I4,-1);
5752     VARORCY(R8,0,0,I4,0);
5753
5754     VAROR(DATE,-1,DATE,-1,I4,-1);
5755     VAROR(DATE,-1,DATE,0,I4,-1);
5756     VAROR(DATE,0,DATE,0,I4,0);
5757     if (has_i8)
5758     {
5759         VAROR(DATE,-1,I8,-1,I8,-1);
5760         VAROR(DATE,-1,I8,0,I8,-1);
5761         VAROR(DATE,0,I8,0,I8,0);
5762         VAROR(DATE,-1,UI8,0,I4,-1);
5763         VAROR(DATE,0,UI8,0,I4,0);
5764     }
5765     VAROR(DATE,-1,INT,-1,I4,-1);
5766     VAROR(DATE,-1,INT,0,I4,-1);
5767     VAROR(DATE,0,INT,0,I4,0);
5768     VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
5769     VAROR(DATE,-1,UINT,0,I4,-1);
5770     VAROR(DATE,0,UINT,0,I4,0);
5771     rbstr = SysAllocString(szFalse);
5772     VAROR(DATE,0,BSTR,rbstr,I4,0);
5773     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
5774     SysFreeString(rbstr);
5775     rbstr = SysAllocString(szTrue);
5776     VAROR(DATE,0,BSTR,rbstr,I4,-1);
5777     VAROR(DATE,-1,BSTR,rbstr,I4,-1);
5778     SysFreeString(rbstr);
5779     VARORCY(DATE,-1,10000,I4,-1);
5780     VARORCY(DATE,-1,0,I4,-1);
5781     VARORCY(DATE,0,0,I4,0);
5782
5783     if (has_i8)
5784     {
5785         VAROR(I8,-1,I8,-1,I8,-1);
5786         VAROR(I8,-1,I8,0,I8,-1);
5787         VAROR(I8,0,I8,0,I8,0);
5788         VAROR(I8,-1,UI8,0,I8,-1);
5789         VAROR(I8,0,UI8,0,I8,0);
5790         /* These overflow under native and Wine
5791         VAROR(I8,-1,INT,-1,I4,-1);
5792         VAROR(I8,-1,INT,0,I4,-1);
5793         VAROR(I8,0,INT,0,I4,0); */
5794         VAROR(I8,-1,UINT,0xffffffff,I8,-1);
5795         VAROR(I8,-1,UINT,0,I8,-1);
5796         VAROR(I8,0,UINT,0,I8,0);
5797         rbstr = SysAllocString(szFalse);
5798         VAROR(I8,0,BSTR,rbstr,I8,0);
5799         VAROR(I8,-1,BSTR,rbstr,I8,-1);
5800         SysFreeString(rbstr);
5801         rbstr = SysAllocString(szTrue);
5802         VAROR(I8,0,BSTR,rbstr,I8,-1);
5803         VAROR(I8,-1,BSTR,rbstr,I8,-1);
5804         SysFreeString(rbstr);
5805         VARORCY(I8,-1,10000,I8,-1);
5806         VARORCY(I8,-1,0,I8,-1);
5807         VARORCY(I8,0,0,I8,0);
5808
5809         VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
5810         VAROR(UI8,0xffff,UI8,0,I4,0xffff);
5811         VAROR(UI8,0,UI8,0,I4,0);
5812         VAROR(UI8,0xffff,INT,-1,I4,-1);
5813         VAROR(UI8,0xffff,INT,0,I4,0xffff);
5814         VAROR(UI8,0,INT,0,I4,0);
5815         VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
5816         VAROR(UI8,0xffff,UINT,0,I4,0xffff);
5817         VAROR(UI8,0,UINT,0,I4,0);
5818         rbstr = SysAllocString(szFalse);
5819         VAROR(UI8,0,BSTR,rbstr,I4,0);
5820         VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
5821         SysFreeString(rbstr);
5822         rbstr = SysAllocString(szTrue);
5823         VAROR(UI8,0,BSTR,rbstr,I4,-1);
5824         VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
5825         SysFreeString(rbstr);
5826         VARORCY(UI8,0xffff,10000,I4,0xffff);
5827         VARORCY(UI8,0xffff,0,I4,0xffff);
5828         VARORCY(UI8,0,0,I4,0);
5829     }
5830
5831     VAROR(INT,-1,INT,-1,I4,-1);
5832     VAROR(INT,-1,INT,0,I4,-1);
5833     VAROR(INT,0,INT,0,I4,0);
5834     VAROR(INT,-1,UINT,0xffff,I4,-1);
5835     VAROR(INT,-1,UINT,0,I4,-1);
5836     VAROR(INT,0,UINT,0,I4,0);
5837     rbstr = SysAllocString(szFalse);
5838     VAROR(INT,0,BSTR,rbstr,I4,0);
5839     VAROR(INT,-1,BSTR,rbstr,I4,-1);
5840     SysFreeString(rbstr);
5841     rbstr = SysAllocString(szTrue);
5842     VAROR(INT,0,BSTR,rbstr,I4,-1);
5843     VAROR(INT,-1,BSTR,rbstr,I4,-1);
5844     SysFreeString(rbstr);
5845     VARORCY(INT,-1,10000,I4,-1);
5846     VARORCY(INT,-1,0,I4,-1);
5847     VARORCY(INT,0,0,I4,0);
5848
5849     VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
5850     VAROR(UINT,0xffff,UINT,0,I4,0xffff);
5851     VAROR(UINT,0,UINT,0,I4,0);
5852     rbstr = SysAllocString(szFalse);
5853     VAROR(UINT,0,BSTR,rbstr,I4,0);
5854     VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
5855     SysFreeString(rbstr);
5856     rbstr = SysAllocString(szTrue);
5857     VAROR(UINT,0,BSTR,rbstr,I4,-1);
5858     VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
5859     SysFreeString(rbstr);
5860     VARORCY(UINT,0xffff,10000,I4,0xffff);
5861     VARORCY(UINT,0xffff,0,I4,0xffff);
5862     VARORCY(UINT,0,0,I4,0);
5863
5864     lbstr = SysAllocString(szFalse);
5865     rbstr = SysAllocString(szFalse);
5866     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
5867     SysFreeString(rbstr);
5868     rbstr = SysAllocString(szTrue);
5869     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
5870     SysFreeString(lbstr);
5871     lbstr = SysAllocString(szTrue);
5872     VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
5873     VARORCY(BSTR,lbstr,10000,I4,-1);
5874     SysFreeString(lbstr);
5875     lbstr = SysAllocString(szFalse);
5876     VARORCY(BSTR,lbstr,10000,I4,1);
5877     SysFreeString(lbstr);
5878     SysFreeString(rbstr);
5879 }
5880
5881 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
5882
5883 #define VAREQV(vt1,val1,vt2,val2,rvt,rval)           \
5884     V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
5885     V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5886     V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
5887     test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )
5888
5889 static void test_VarEqv(void)
5890 {
5891     VARIANT left, right, exp, result;
5892     VARTYPE i;
5893     HRESULT hres;
5894
5895     CHECKPTR(VarEqv);
5896
5897     /* Test all possible flag/vt combinations & the resulting vt type */
5898     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
5899     {
5900         VARTYPE leftvt, rightvt, resvt;
5901
5902         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5903         {
5904             SKIPTESTS(leftvt);
5905
5906             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5907             {
5908                 BOOL bFail = FALSE;
5909
5910                 SKIPTESTS(rightvt);
5911
5912                 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
5913                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5914                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5915                     continue;
5916
5917                 memset(&left, 0, sizeof(left));
5918                 memset(&right, 0, sizeof(right));
5919                 V_VT(&left) = leftvt | ExtraFlags[i];
5920                 V_VT(&right) = rightvt | ExtraFlags[i];
5921                 V_VT(&result) = VT_EMPTY;
5922                 resvt = VT_I4;
5923
5924                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5925                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5926                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5927                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
5928                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
5929                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5930                     leftvt == VT_ERROR || rightvt == VT_ERROR)
5931                 {
5932                     bFail = TRUE;
5933                 }
5934                 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5935                 {
5936                     if (leftvt == rightvt ||
5937                         leftvt == VT_I2 || rightvt == VT_I2 ||
5938                         leftvt == VT_UI1 || rightvt == VT_UI1 ||
5939                         leftvt == VT_BOOL || rightvt == VT_BOOL)
5940                         resvt = VT_I2;
5941                     else if (leftvt == VT_NULL || rightvt == VT_NULL)
5942                         resvt = VT_NULL;
5943                     else if (leftvt == VT_I8 || rightvt == VT_I8)
5944                         resvt = VT_I8;
5945                 }
5946                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
5947                 {
5948                     resvt = VT_NULL;
5949                 }
5950                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5951                 {
5952                     if (leftvt == rightvt)
5953                         resvt = VT_UI1;
5954                     else if (leftvt == rightvt ||
5955                         leftvt == VT_I2 || rightvt == VT_I2 ||
5956                         leftvt == VT_BOOL || rightvt == VT_BOOL)
5957                     {
5958                         resvt = VT_I2;
5959                     }
5960                     else if (leftvt == VT_I8 || rightvt == VT_I8)
5961                         resvt = VT_I8;
5962                 }
5963                 else if (leftvt == VT_I2 || rightvt == VT_I2)
5964                 {
5965                     if (leftvt == rightvt ||
5966                         leftvt == VT_BOOL || rightvt == VT_BOOL)
5967                         resvt = VT_I2;
5968                     else if (leftvt == VT_I8 || rightvt == VT_I8)
5969                         resvt = VT_I8;
5970                 }
5971                 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
5972                 {
5973                     resvt = VT_BOOL;
5974                 }
5975                 else if (leftvt == VT_I8 || rightvt == VT_I8)
5976                 {
5977                     if (leftvt == VT_INT || rightvt == VT_INT)
5978                         bFail = TRUE;
5979                     else
5980                         resvt = VT_I8;
5981                 }
5982                 hres = pVarEqv(&left, &right, &result);
5983                 if (bFail)
5984                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5985                        "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
5986                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5987                        V_VT(&result));
5988                 else
5989                     ok(hres == S_OK && V_VT(&result) == resvt,
5990                        "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
5991                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5992                        V_VT(&result));
5993             }
5994         }
5995     }
5996
5997     /* Test returned values */
5998     VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5999     VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
6000     VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
6001     VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
6002     VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
6003     VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
6004     VAREQV(BOOL,6,BOOL,7,BOOL,-2);
6005     VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
6006     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
6007     VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
6008     VAREQV(BOOL,6,I2,7,I2,-2);
6009     VAREQV(UI1,1,UI1,1,UI1,255);
6010     VAREQV(UI1,1,UI1,0,UI1,254);
6011     VAREQV(UI1,0,UI1,1,UI1,254);
6012     if (has_i8)
6013     {
6014         VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
6015         VAREQV(UI4,5,I8,19,I8,-23);
6016         VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
6017     }
6018 }
6019
6020 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
6021
6022 #define VARMUL(vt1,val1,vt2,val2,rvt,rval)               \
6023         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6024         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6025         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6026         test_var_call2( __LINE__, pVarMul, &left, &right, &exp )
6027
6028 static void test_VarMul(void)
6029 {
6030     VARIANT left, right, exp, result, cy, dec;
6031     VARTYPE i;
6032     BSTR lbstr, rbstr;
6033     HRESULT hres;
6034     double r;
6035
6036     CHECKPTR(VarMul);
6037
6038     lbstr = SysAllocString(L"12");
6039     rbstr = SysAllocString(L"12");
6040
6041     /* Test all possible flag/vt combinations & the resulting vt type */
6042     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
6043     {
6044         VARTYPE leftvt, rightvt, resvt;
6045
6046         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6047         {
6048
6049             SKIPTESTS(leftvt);
6050
6051             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6052             {
6053                 BOOL bFail = FALSE;
6054
6055                 SKIPTESTS(rightvt);
6056
6057                 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6058                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
6059                     continue;
6060
6061                 memset(&left, 0, sizeof(left));
6062                 memset(&right, 0, sizeof(right));
6063                 V_VT(&left) = leftvt | ExtraFlags[i];
6064                 if (leftvt == VT_BSTR)
6065                     V_BSTR(&left) = lbstr;
6066                 V_VT(&right) = rightvt | ExtraFlags[i];
6067                 if (rightvt == VT_BSTR)
6068                     V_BSTR(&right) = rbstr;
6069                 V_VT(&result) = VT_EMPTY;
6070                 resvt = VT_UNKNOWN;
6071
6072                 /* Don't ask me why but native VarMul cannot handle:
6073                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
6074                    Tested with DCOM98, Win2k, WinXP */
6075                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6076                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
6077                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
6078                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6079                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6080                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6081                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6082                     leftvt == VT_I1 || rightvt == VT_I1 ||
6083                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6084                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6085                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6086                     leftvt == VT_INT || rightvt == VT_INT ||
6087                     leftvt == VT_UINT || rightvt == VT_UINT) {
6088                     bFail = TRUE;
6089                 }
6090
6091                 if (leftvt == VT_NULL || rightvt == VT_NULL)
6092                     resvt = VT_NULL;
6093                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
6094                     resvt = VT_DECIMAL;
6095                 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
6096                          leftvt == VT_BSTR || rightvt == VT_BSTR ||
6097                          leftvt == VT_DATE || rightvt == VT_DATE)
6098                     resvt = VT_R8;
6099                 else if (leftvt == VT_R4 || rightvt == VT_R4) {
6100                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
6101                         leftvt == VT_I8 || rightvt == VT_I8 ||
6102                         leftvt == VT_CY || rightvt == VT_CY)
6103                         resvt = VT_R8;
6104                     else
6105                         resvt = VT_R4;
6106                 } else if (leftvt == VT_CY || rightvt == VT_CY)
6107                     resvt = VT_CY;
6108                 else if (leftvt == VT_I8 || rightvt == VT_I8)
6109                     resvt = VT_I8;
6110                 else if (leftvt == VT_I4 || rightvt == VT_I4)
6111                     resvt = VT_I4;
6112                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
6113                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
6114                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
6115                     resvt = VT_I2;
6116                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
6117                     resvt = VT_UI1;
6118
6119                 hres = pVarMul(&left, &right, &result);
6120                 if (bFail) {
6121                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6122                        "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
6123                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
6124                        V_VT(&result));
6125                 } else {
6126                     ok(hres == S_OK && V_VT(&result) == resvt,
6127                        "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
6128                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
6129                        V_VT(&result));
6130                 }
6131             }
6132         }
6133     }
6134
6135     /* Test returned values */
6136     VARMUL(I4,4,I4,2,I4,8);
6137     VARMUL(I2,4,I2,2,I2,8);
6138     VARMUL(I2,-13,I4,5,I4,-65);
6139     VARMUL(I4,-13,I4,5,I4,-65);
6140     VARMUL(I2,7,R4,0.5f,R4,3.5f);
6141     VARMUL(R4,0.5f,I4,5,R8,2.5);
6142     VARMUL(R8,7.1,BOOL,0,R8,0);
6143     VARMUL(BSTR,lbstr,I2,4,R8,48);
6144     VARMUL(BSTR,lbstr,BOOL,1,R8,12);
6145     VARMUL(BSTR,lbstr,R4,0.1f,R8,1.2);
6146     VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
6147     VARMUL(R4,0.2f,BSTR,rbstr,R8,2.4);
6148     VARMUL(DATE,2.25,I4,7,R8,15.75);
6149
6150     VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
6151     VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
6152     VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
6153     VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
6154     VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
6155     VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
6156     VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
6157     VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
6158     VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
6159     VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
6160     VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
6161     VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
6162
6163     /* Manuly test some VT_CY and VT_DECIMAL variants */
6164     V_VT(&cy) = VT_CY;
6165     hres = VarCyFromI4(4711, &V_CY(&cy));
6166     ok(hres == S_OK, "VarCyFromI4 failed!\n");
6167     V_VT(&dec) = VT_DECIMAL;
6168     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
6169     ok(hres == S_OK, "VarDecFromR4 failed!\n");
6170     memset(&left, 0, sizeof(left));
6171     memset(&right, 0, sizeof(right));
6172     V_VT(&left) = VT_I4;
6173     V_I4(&left) = -11;
6174     V_VT(&right) = VT_UI1;
6175     V_UI1(&right) = 9;
6176
6177     hres = pVarMul(&cy, &right, &result);
6178     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
6179     hres = VarR8FromCy(V_CY(&result), &r);
6180     ok(hres == S_OK && EQ_DOUBLE(r, 42399.0), "VarMul: CY value %f, expected %f\n", r, 42399.0);
6181
6182     hres = pVarMul(&left, &dec, &result);
6183     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
6184     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
6185     ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, 46.2);
6186
6187     SysFreeString(lbstr);
6188     SysFreeString(rbstr);
6189 }
6190
6191 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
6192
6193 #define VARADD(vt1,val1,vt2,val2,rvt,rval)               \
6194         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6195         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6196         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6197         test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )
6198
6199 static void test_VarAdd(void)
6200 {
6201     VARIANT left, right, exp, result, cy, dec;
6202     VARTYPE i;
6203     BSTR lbstr, rbstr;
6204     HRESULT hres;
6205     double r;
6206
6207     CHECKPTR(VarAdd);
6208
6209     lbstr = SysAllocString(L"12");
6210     rbstr = SysAllocString(L"12");
6211
6212     /* Test all possible flag/vt combinations & the resulting vt type */
6213     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
6214     {
6215         VARTYPE leftvt, rightvt, resvt;
6216
6217         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6218         {
6219
6220             SKIPTESTS(leftvt);
6221
6222             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6223             {
6224                 BOOL bFail = FALSE;
6225
6226                 SKIPTESTS(rightvt);
6227
6228                 if (leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
6229                     continue;
6230
6231                 memset(&left, 0, sizeof(left));
6232                 memset(&right, 0, sizeof(right));
6233                 V_VT(&left) = leftvt | ExtraFlags[i];
6234                 if (leftvt == VT_BSTR)
6235                     V_BSTR(&left) = lbstr;
6236                 V_VT(&right) = rightvt | ExtraFlags[i];
6237                 if (rightvt == VT_BSTR)
6238                     V_BSTR(&right) = rbstr;
6239                 V_VT(&result) = VT_EMPTY;
6240                 resvt = VT_ERROR;
6241
6242                 /* Don't ask me why but native VarAdd cannot handle:
6243                    VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
6244                    Tested with DCOM98, Win2k, WinXP */
6245                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6246                     !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
6247                     !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
6248                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
6249                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
6250                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6251                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
6252                     leftvt == VT_I1 || rightvt == VT_I1 ||
6253                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6254                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6255                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6256                     leftvt == VT_INT || rightvt == VT_INT ||
6257                     leftvt == VT_UINT || rightvt == VT_UINT) {
6258                     bFail = TRUE;
6259                 }
6260
6261                 if (leftvt == VT_NULL || rightvt == VT_NULL)
6262                     resvt = VT_NULL;
6263                 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
6264                     bFail = TRUE;
6265                 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
6266                     resvt = VT_DECIMAL;
6267                 else if (leftvt == VT_DATE || rightvt == VT_DATE)
6268                     resvt = VT_DATE;
6269                 else if (leftvt == VT_CY || rightvt == VT_CY)
6270                     resvt = VT_CY;
6271                 else if (leftvt == VT_R8 || rightvt == VT_R8)
6272                     resvt = VT_R8;
6273                 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
6274                     if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
6275                          leftvt == VT_EMPTY || rightvt == VT_EMPTY)
6276                         resvt = VT_BSTR;
6277                     else
6278                         resvt = VT_R8;
6279                 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
6280                     if (leftvt == VT_I4 || rightvt == VT_I4 ||
6281                         leftvt == VT_I8 || rightvt == VT_I8)
6282                         resvt = VT_R8;
6283                     else
6284                         resvt = VT_R4;
6285                 }
6286                 else if (leftvt == VT_I8 || rightvt == VT_I8)
6287                     resvt = VT_I8;
6288                 else if (leftvt == VT_I4 || rightvt == VT_I4)
6289                     resvt = VT_I4;
6290                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
6291                          leftvt == VT_BOOL || rightvt == VT_BOOL ||
6292                          (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
6293                     resvt = VT_I2;
6294                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
6295                     resvt = VT_UI1;
6296
6297                 hres = pVarAdd(&left, &right, &result);
6298                 if (bFail) {
6299                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6300                        "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX vt %d\n",
6301                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
6302                        V_VT(&result));
6303                 } else {
6304                     ok(hres == S_OK && V_VT(&result) == resvt,
6305                        "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%lX vt %d\n",
6306                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
6307                        V_VT(&result));
6308                 }
6309                 /* Note, we don't clear left/right deliberately here */
6310                 VariantClear(&result);
6311             }
6312         }
6313     }
6314
6315     /* Test returned values */
6316     VARADD(I4,4,I4,2,I4,6);
6317     VARADD(I2,4,I2,2,I2,6);
6318     VARADD(I2,-13,I4,5,I4,-8);
6319     VARADD(I4,-13,I4,5,I4,-8);
6320     VARADD(I2,7,R4,0.5f,R4,7.5f);
6321     VARADD(R4,0.5f,I4,5,R8,5.5);
6322     VARADD(R8,7.1,BOOL,0,R8,7.1);
6323     VARADD(BSTR,lbstr,I2,4,R8,16);
6324     VARADD(BSTR,lbstr,BOOL,1,R8,13);
6325     VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
6326     VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
6327     VARADD(DATE,2.25,I4,7,DATE,9.25);
6328     VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
6329
6330     VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
6331     VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
6332     VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
6333     VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
6334     VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
6335     VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
6336     VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
6337     VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
6338     VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
6339     VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
6340     VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
6341     VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
6342
6343     /* Manually test BSTR + BSTR */
6344     V_VT(&left) = VT_BSTR;
6345     V_BSTR(&left) = lbstr;
6346     V_VT(&right) = VT_BSTR;
6347     V_BSTR(&right) = rbstr;
6348     hres = pVarAdd(&left, &right, &result);
6349     ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
6350     hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
6351     ok(hres == S_OK && EQ_DOUBLE(r, 1212.0), "VarAdd: BSTR value %f, expected %f\n", r, 1212.0);
6352     VariantClear(&result);
6353
6354     /* Manuly test some VT_CY and VT_DECIMAL variants */
6355     V_VT(&cy) = VT_CY;
6356     hres = VarCyFromI4(4711, &V_CY(&cy));
6357     ok(hres == S_OK, "VarCyFromI4 failed!\n");
6358     V_VT(&dec) = VT_DECIMAL;
6359     hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
6360     ok(hres == S_OK, "VarDecFromR4 failed!\n");
6361     memset(&left, 0, sizeof(left));
6362     memset(&right, 0, sizeof(right));
6363     V_VT(&left) = VT_I4;
6364     V_I4(&left) = -11;
6365     V_VT(&right) = VT_UI1;
6366     V_UI1(&right) = 9;
6367
6368     hres = pVarAdd(&cy, &right, &result);
6369     ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
6370     hres = VarR8FromCy(V_CY(&result), &r);
6371     ok(hres == S_OK && EQ_DOUBLE(r, 4720.0), "VarAdd: CY value %f, expected %f\n", r, 4720.0);
6372
6373     hres = pVarAdd(&left, &dec, &result);
6374     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
6375     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
6376     ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, -15.2);
6377     VariantClear(&result);
6378
6379     SysFreeString(lbstr);
6380     SysFreeString(rbstr);
6381 }
6382
6383 static void test_VarCat(void)
6384 {
6385     LCID lcid;
6386     VARIANT left, right, result;
6387     CHAR orig_date_format[128];
6388     VARTYPE leftvt, rightvt, resultvt;
6389     HRESULT hres;
6390     HRESULT expected_error_num;
6391     int cmp;
6392     DummyDispatch dispatch;
6393
6394     /* Set date format for testing */
6395     lcid = LOCALE_USER_DEFAULT;
6396     GetLocaleInfoA(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
6397     SetLocaleInfoA(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
6398
6399     VariantInit(&left);
6400     VariantInit(&right);
6401     VariantInit(&result);
6402
6403     /* Check expected types for all combinations */
6404     for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6405     {
6406
6407         SKIPTESTS(leftvt);
6408
6409         /* Check if we need/have support for I8 and/or UI8 */
6410         if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
6411             continue;
6412
6413         for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6414         {
6415
6416             SKIPTESTS(rightvt);
6417             expected_error_num = S_OK;
6418             resultvt = VT_EMPTY;
6419
6420             if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6421                 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN  ||
6422                 leftvt == VT_RECORD || rightvt == VT_RECORD  ||
6423                 leftvt == 15 || rightvt == 15 /* Undefined type */)
6424                 continue;
6425
6426             /* Check if we need/have support for I8 and/or UI8 */
6427             if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
6428                 continue;
6429
6430             if (leftvt == VT_NULL && rightvt == VT_NULL)
6431                 resultvt = VT_NULL;
6432             else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
6433                 rightvt == VT_DATE || rightvt == VT_DECIMAL))
6434                 expected_error_num = DISP_E_TYPEMISMATCH;
6435             else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
6436                 leftvt == VT_R4 || leftvt == VT_R8 ||
6437                 leftvt == VT_CY || leftvt == VT_BOOL ||
6438                 leftvt == VT_BSTR || leftvt == VT_I1 ||
6439                 leftvt == VT_UI1 || leftvt == VT_UI2 ||
6440                 leftvt == VT_UI4 || leftvt == VT_I8 ||
6441                 leftvt == VT_UI8 || leftvt == VT_INT ||
6442                 leftvt == VT_UINT || leftvt == VT_EMPTY ||
6443                 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
6444                 leftvt == VT_DATE)
6445                 &&
6446                 (rightvt == VT_I2 || rightvt == VT_I4 ||
6447                 rightvt == VT_R4 || rightvt == VT_R8 ||
6448                 rightvt == VT_CY || rightvt == VT_BOOL ||
6449                 rightvt == VT_BSTR || rightvt == VT_I1 ||
6450                 rightvt == VT_UI1 || rightvt == VT_UI2 ||
6451                 rightvt == VT_UI4 || rightvt == VT_I8 ||
6452                 rightvt == VT_UI8 || rightvt == VT_INT ||
6453                 rightvt == VT_UINT || rightvt == VT_EMPTY ||
6454                 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
6455                 rightvt == VT_DATE))
6456                 resultvt = VT_BSTR;
6457             else if (rightvt == VT_ERROR && leftvt < VT_VOID)
6458                 expected_error_num = DISP_E_TYPEMISMATCH;
6459             else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
6460                 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
6461                 expected_error_num = DISP_E_TYPEMISMATCH;
6462             else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
6463                 rightvt == VT_DECIMAL)
6464                 expected_error_num = DISP_E_BADVARTYPE;
6465             else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
6466                 expected_error_num = DISP_E_TYPEMISMATCH;
6467             else if (leftvt == VT_VARIANT)
6468                 expected_error_num = DISP_E_TYPEMISMATCH;
6469             else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
6470                 leftvt == VT_NULL || leftvt ==  VT_I2 ||
6471                 leftvt == VT_I4 || leftvt == VT_R4 ||
6472                 leftvt == VT_R8 || leftvt == VT_CY ||
6473                 leftvt == VT_DATE || leftvt == VT_BSTR ||
6474                 leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
6475                 leftvt == VT_I1 || leftvt == VT_UI1 ||
6476                 leftvt == VT_UI2 || leftvt == VT_UI4 ||
6477                 leftvt == VT_I8 || leftvt == VT_UI8 ||
6478                 leftvt == VT_INT || leftvt == VT_UINT
6479                 ))
6480                 expected_error_num = DISP_E_TYPEMISMATCH;
6481             else
6482                 expected_error_num = DISP_E_BADVARTYPE;
6483
6484             V_VT(&left) = leftvt;
6485             V_VT(&right) = rightvt;
6486
6487             switch (leftvt) {
6488             case VT_BSTR:
6489                 V_BSTR(&left) = SysAllocString(L""); break;
6490             case VT_DATE:
6491                 V_DATE(&left) = 0.0; break;
6492             case VT_DECIMAL:
6493                 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
6494             default:
6495                 V_I8(&left) = 0;
6496             }
6497
6498             switch (rightvt) {
6499             case VT_BSTR:
6500                 V_BSTR(&right) = SysAllocString(L""); break;
6501             case VT_DATE:
6502                 V_DATE(&right) = 0.0; break;
6503             case VT_DECIMAL:
6504                 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
6505             default:
6506                 V_I8(&right) = 0;
6507             }
6508
6509             hres = VarCat(&left, &right, &result);
6510
6511             /* Determine the error code for the vt combination */
6512             ok(hres == expected_error_num,
6513                 "VarCat: %d, %d returned error, 0x%lX expected 0x%lX.\n",
6514                 leftvt, rightvt, hres, expected_error_num);
6515
6516             /* Check types are correct */
6517             ok(V_VT(&result) == resultvt,
6518                 "VarCat: %d, %d: expected vt %d, got vt %d\n",
6519                 leftvt, rightvt, resultvt, V_VT(&result));
6520
6521             VariantClear(&left);
6522             VariantClear(&right);
6523             VariantClear(&result);
6524         }
6525     }
6526
6527     /* Running single comparison tests to compare outputs */
6528
6529     /* Test concat strings */
6530     V_VT(&left) = VT_BSTR;
6531     V_VT(&right) = VT_BSTR;
6532     V_BSTR(&left) = SysAllocString(L"12");
6533     V_BSTR(&right) = SysAllocString(L"34");
6534     hres = VarCat(&left,&right,&result);
6535     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6536     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6537     ok(!wcscmp(V_BSTR(&result), L"1234"), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6538
6539     VariantClear(&left);
6540     VariantClear(&right);
6541     VariantClear(&result);
6542
6543     /* Test if expression is VT_ERROR */
6544     V_VT(&left) = VT_ERROR;
6545     V_VT(&right) = VT_BSTR;
6546     V_BSTR(&right) = SysAllocString(L"1234");
6547     hres = VarCat(&left,&right,&result);
6548     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08lx\n", hres);
6549     ok(V_VT(&result) == VT_EMPTY,
6550         "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
6551
6552     VariantClear(&left);
6553     VariantClear(&right);
6554     VariantClear(&result);
6555
6556     V_VT(&left) = VT_BSTR;
6557     V_VT(&right) = VT_ERROR;
6558     V_BSTR(&left) = SysAllocString(L"1234");
6559     hres = VarCat(&left,&right,&result);
6560     ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08lx\n", hres);
6561     ok(V_VT(&result) == VT_EMPTY,
6562         "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
6563
6564     VariantClear(&left);
6565     VariantClear(&right);
6566     VariantClear(&result);
6567
6568     /* Test combining boolean with number */
6569     V_VT(&left) = VT_INT;
6570     V_VT(&right) = VT_BOOL;
6571     V_INT(&left) = 12;
6572     V_BOOL(&right) = TRUE;
6573     hres = VarCat(&left,&right,&result);
6574     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6575     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6576     ok(!wcscmp(V_BSTR(&result), sz12_true), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6577
6578     VariantClear(&left);
6579     VariantClear(&right);
6580     VariantClear(&result);
6581
6582     V_VT(&left) = VT_INT;
6583     V_VT(&right) = VT_BOOL;
6584     V_INT(&left) = 12;
6585     V_BOOL(&right) = FALSE;
6586     hres = VarCat(&left,&right,&result);
6587     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6588     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6589     ok(!wcscmp(V_BSTR(&result), sz12_false), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6590
6591     VariantClear(&left);
6592     VariantClear(&right);
6593     VariantClear(&result);
6594
6595     /* Test when both expressions are numeric */
6596     V_VT(&left) = VT_INT;
6597     V_VT(&right) = VT_INT;
6598     V_INT(&left)  = 12;
6599     V_INT(&right) = 34;
6600     hres = VarCat(&left,&right,&result);
6601     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6602     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6603     ok(!wcscmp(V_BSTR(&result), L"1234"), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6604
6605     VariantClear(&left);
6606     VariantClear(&right);
6607     VariantClear(&result);
6608
6609     /* Test if one expression is numeric and the other is a string */
6610     V_VT(&left) = VT_INT;
6611     V_VT(&right) = VT_BSTR;
6612     V_INT(&left) = 12;
6613     V_BSTR(&right) = SysAllocString(L"34");
6614     hres = VarCat(&left,&right,&result);
6615     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6616     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6617     ok(!wcscmp(V_BSTR(&result), L"1234"), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6618
6619     VariantClear(&left);
6620     VariantClear(&right);
6621     VariantClear(&result);
6622
6623     V_VT(&left) = VT_BSTR;
6624     V_VT(&right) = VT_INT;
6625     V_BSTR(&left) = SysAllocString(L"12");
6626     V_INT(&right) = 34;
6627     hres = VarCat(&left,&right,&result);
6628     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6629     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6630     ok(!wcscmp(V_BSTR(&result), L"1234"), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6631
6632     VariantClear(&left);
6633     VariantClear(&right);
6634     VariantClear(&result);
6635
6636     /* Test concat dates with strings */
6637     V_VT(&left) = VT_BSTR;
6638     V_VT(&right) = VT_DATE;
6639     V_BSTR(&left) = SysAllocString(L"12");
6640     V_DATE(&right) = 29494.0;
6641     hres = VarCat(&left,&right,&result);
6642     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6643     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6644     ok(!wcscmp(V_BSTR(&result), L"129/30/1980"), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6645
6646     VariantClear(&left);
6647     VariantClear(&right);
6648     VariantClear(&result);
6649
6650     V_VT(&left) = VT_DATE;
6651     V_VT(&right) = VT_BSTR;
6652     V_DATE(&left) = 29494.0;
6653     V_BSTR(&right) = SysAllocString(L"12");
6654     hres = VarCat(&left,&right,&result);
6655     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6656     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6657     ok(!wcscmp(V_BSTR(&result), L"9/30/198012"), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6658
6659     VariantClear(&left);
6660     VariantClear(&right);
6661     VariantClear(&result);
6662
6663     /* Test of both expressions are empty */
6664     V_VT(&left) = VT_BSTR;
6665     V_VT(&right) = VT_BSTR;
6666     V_BSTR(&left) = SysAllocString(L"");
6667     V_BSTR(&right) = SysAllocString(L"");
6668     hres = VarCat(&left,&right,&result);
6669     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6670     ok(V_VT(&result) == VT_BSTR, "Unexpected return type %d.\n", V_VT(&result));
6671     ok(!wcscmp(V_BSTR(&result), L""), "Unexpected return value %s.\n", wine_dbgstr_w(V_BSTR(&result)));
6672
6673     /* Restore original date format settings */
6674     SetLocaleInfoA(lcid,LOCALE_SSHORTDATE,orig_date_format);
6675
6676     VariantClear(&left);
6677     VariantClear(&right);
6678     VariantClear(&result);
6679
6680     /* Dispatch conversion */
6681     init_test_dispatch(VT_NULL, &dispatch);
6682     V_VT(&left) = VT_DISPATCH;
6683     V_DISPATCH(&left) = &dispatch.IDispatch_iface;
6684
6685     SET_EXPECT(dispatch_invoke);
6686     hres = VarCat(&left, &right, &result);
6687     ok(hres == S_OK, "got 0x%08lx\n", hres);
6688     ok(V_VT(&result) == VT_BSTR, "got %d\n", V_VT(&result));
6689     ok(SysStringLen(V_BSTR(&result)) == 0, "got %d\n", SysStringLen(V_BSTR(&result)));
6690     CHECK_CALLED(dispatch_invoke);
6691
6692     VariantClear(&left);
6693     VariantClear(&right);
6694     VariantClear(&result);
6695
6696     init_test_dispatch(VT_NULL, &dispatch);
6697     V_VT(&right) = VT_DISPATCH;
6698     V_DISPATCH(&right) = &dispatch.IDispatch_iface;
6699
6700     SET_EXPECT(dispatch_invoke);
6701     hres = VarCat(&left, &right, &result);
6702     ok(hres == S_OK, "got 0x%08lx\n", hres);
6703     ok(V_VT(&result) == VT_BSTR, "got %d\n", V_VT(&result));
6704     ok(SysStringLen(V_BSTR(&result)) == 0, "got %d\n", SysStringLen(V_BSTR(&result)));
6705     CHECK_CALLED(dispatch_invoke);
6706
6707     VariantClear(&left);
6708     VariantClear(&right);
6709     VariantClear(&result);
6710
6711     init_test_dispatch(VT_UI1, &dispatch);
6712     V_VT(&right) = VT_DISPATCH;
6713     V_DISPATCH(&right) = &dispatch.IDispatch_iface;
6714
6715     V_VT(&left) = VT_BSTR;
6716     V_BSTR(&left) = SysAllocString(L"12");
6717     SET_EXPECT(dispatch_invoke);
6718     hres = VarCat(&left,&right,&result);
6719     ok(hres == S_OK, "VarCat failed with error 0x%08lx\n", hres);
6720     CHECK_CALLED(dispatch_invoke);
6721     ok(!lstrcmpW(V_BSTR(&result), L"1234"), "got %s\n", wine_dbgstr_w(V_BSTR(&result)));
6722
6723     VariantClear(&left);
6724     VariantClear(&right);
6725     VariantClear(&result);
6726
6727     init_test_dispatch(VT_NULL, &dispatch);
6728     dispatch.result = E_OUTOFMEMORY;
6729     V_VT(&right) = VT_DISPATCH;
6730     V_DISPATCH(&right) = &dispatch.IDispatch_iface;
6731
6732     SET_EXPECT(dispatch_invoke);
6733     hres = VarCat(&left, &right, &result);
6734     ok(hres == E_OUTOFMEMORY, "got 0x%08lx\n", hres);
6735     CHECK_CALLED(dispatch_invoke);
6736
6737     VariantClear(&left);
6738     VariantClear(&right);
6739     VariantClear(&result);
6740
6741     init_test_dispatch(VT_NULL, &dispatch);
6742     dispatch.result = DISP_E_TYPEMISMATCH;
6743     V_VT(&right) = VT_DISPATCH;
6744     V_DISPATCH(&right) = &dispatch.IDispatch_iface;
6745
6746     SET_EXPECT(dispatch_invoke);
6747     hres = VarCat(&left, &right, &result);
6748     ok(hres == DISP_E_TYPEMISMATCH, "got 0x%08lx\n", hres);
6749     CHECK_CALLED(dispatch_invoke);
6750
6751     VariantClear(&left);
6752     VariantClear(&right);
6753     VariantClear(&result);
6754
6755     /* Test boolean conversion */
6756     V_VT(&left) = VT_BOOL;
6757     V_BOOL(&left) = VARIANT_TRUE;
6758     V_VT(&right) = VT_BSTR;
6759     V_BSTR(&right) = SysAllocStringLen(NULL,0);
6760     hres = VarCat(&left, &right, &result);
6761     ok(hres == S_OK, "VarCat failed: %08lx\n", hres);
6762     VariantClear(&right);
6763
6764     cmp = lstrcmpW(V_BSTR(&result), L"True");
6765     VariantClear(&result);
6766     if(!cmp) {
6767         V_VT(&right) = VT_BOOL;
6768         V_BOOL(&right) = 100;
6769         hres = VarCat(&left, &right, &result);
6770         ok(hres == S_OK, "VarCat failed: %08lx\n", hres);
6771         test_bstr_var(&result, L"TrueTrue");
6772         VariantClear(&result);
6773
6774         V_BOOL(&right) = VARIANT_FALSE;
6775         hres = VarCat(&left, &right, &result);
6776         ok(hres == S_OK, "VarCat failed: %08lx\n", hres);
6777         test_bstr_var(&result, L"TrueFalse");
6778         VariantClear(&result);
6779     }else {
6780         skip("Got %s as True, assuming non-English locale\n", wine_dbgstr_w(V_BSTR(&result)));
6781     }
6782 }
6783
6784 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
6785
6786 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
6787         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6788         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6789         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6790         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
6791
6792 #define VARANDCY(vt1,val1,val2,rvt,rval)                 \
6793         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
6794         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
6795         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
6796         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
6797
6798 /* Skip any type that is not defined or produces an error for every case */
6799 #define SKIPTESTAND(a)                                \
6800         if (a == VT_ERROR || a == VT_VARIANT ||       \
6801             a == VT_DISPATCH || a == VT_UNKNOWN ||    \
6802             a > VT_UINT || a == 15 /*not defined*/)   \
6803             continue
6804
6805 static void test_VarAnd(void)
6806 {
6807     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
6808     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
6809     VARIANT left, right, exp, result;
6810     BSTR false_str, true_str;
6811     VARTYPE i;
6812     HRESULT hres;
6813
6814     CHECKPTR(VarAnd);
6815
6816     true_str = SysAllocString(szTrue);
6817     false_str = SysAllocString(szFalse);
6818
6819     /* Test all possible flag/vt combinations & the resulting vt type */
6820     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
6821     {
6822         VARTYPE leftvt, rightvt, resvt;
6823
6824         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6825         {
6826             SKIPTESTAND(leftvt);
6827
6828             /* Check if we need/have support for I8 and/or UI8 */
6829             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
6830                 continue;
6831
6832             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6833             {
6834                 BOOL bFail = FALSE;
6835                 SKIPTESTAND(rightvt);
6836
6837                 /* Check if we need/have support for I8 and/or UI8 */
6838                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
6839                     continue;
6840
6841                 memset(&left, 0, sizeof(left));
6842                 memset(&right, 0, sizeof(right));
6843                 V_VT(&left) = leftvt | ExtraFlags[i];
6844                 V_VT(&right) = rightvt | ExtraFlags[i];
6845                 V_VT(&result) = VT_EMPTY;
6846                 resvt = VT_EMPTY;
6847                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
6848                     V_BSTR(&left) = true_str;
6849                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
6850                     V_BSTR(&right) = true_str;
6851
6852                 /* Native VarAnd always returns an error when using extra
6853                  * flags or if the variant combination is I8 and INT.
6854                  */
6855                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
6856                     (leftvt == VT_INT && rightvt == VT_I8) ||
6857                     ExtraFlags[i] != 0)
6858                     bFail = TRUE;
6859
6860                 /* Determine return type */
6861                 else if (leftvt == VT_I8 || rightvt == VT_I8)
6862                     resvt = VT_I8;
6863                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
6864                     leftvt == VT_UINT || rightvt == VT_UINT ||
6865                     leftvt == VT_INT || rightvt == VT_INT ||
6866                     leftvt == VT_R4 || rightvt == VT_R4 ||
6867                     leftvt == VT_R8 || rightvt == VT_R8 ||
6868                     leftvt == VT_CY || rightvt == VT_CY ||
6869                     leftvt == VT_DATE || rightvt == VT_DATE ||
6870                     leftvt == VT_I1 || rightvt == VT_I1 ||
6871                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
6872                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
6873                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
6874                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
6875                     resvt = VT_I4;
6876                 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
6877                     leftvt == VT_I2 || rightvt == VT_I2 ||
6878                     leftvt == VT_EMPTY || rightvt == VT_EMPTY)
6879                     if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
6880                         (leftvt == VT_UI1 && rightvt == VT_NULL) ||
6881                         (leftvt == VT_UI1 && rightvt == VT_UI1))
6882                         resvt = VT_UI1;
6883                     else
6884                         resvt = VT_I2;
6885                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
6886                     (leftvt == VT_BSTR && rightvt == VT_BSTR))
6887                     resvt = VT_BOOL;
6888                 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
6889                     leftvt == VT_BSTR || rightvt == VT_BSTR)
6890                     resvt = VT_NULL;
6891                 else
6892                     bFail = TRUE;
6893
6894                 hres = pVarAnd(&left, &right, &result);
6895
6896                 /* Check expected HRESULT and if result variant type is correct */
6897                 if (bFail)
6898                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6899                         "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%lX\n",
6900                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i],
6901                         wine_dbgstr_vt(V_VT(&result)), hres);
6902                 else
6903                     ok (hres == S_OK && resvt == V_VT(&result),
6904                         "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%lX, got vt %s hr 0x%lX\n",
6905                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i], wine_dbgstr_vt(resvt),
6906                         S_OK, wine_dbgstr_vt(V_VT(&result)), hres);
6907             }
6908         }
6909     }
6910
6911     /*
6912      * Test returned values. Since we know the returned type is correct
6913      * and that we handle all combinations of invalid types, just check
6914      * that good type combinations produce the desired value.
6915      * FIXME: Test VT_DECIMAL
6916      */
6917     VARAND(EMPTY,0,EMPTY,0,I2,0);
6918     VARAND(EMPTY,1,EMPTY,0,I2,0);
6919     VARAND(EMPTY,1,EMPTY,1,I2,0);
6920     VARAND(EMPTY,0,NULL,0,I2,0);
6921     VARAND(EMPTY,1,NULL,0,I2,0);
6922     VARAND(EMPTY,1,NULL,1,I2,0);
6923     VARAND(EMPTY,0,I1,0,I4,0);
6924     VARAND(EMPTY,0,I1,1,I4,0);
6925     VARAND(EMPTY,1,I1,1,I4,0);
6926     VARAND(EMPTY,0,UI1,0,I2,0);
6927     VARAND(EMPTY,0,UI1,1,I2,0);
6928     VARAND(EMPTY,1,UI1,1,I2,0);
6929     VARAND(EMPTY,0,I2,0,I2,0);
6930     VARAND(EMPTY,0,I2,1,I2,0);
6931     VARAND(EMPTY,1,I2,1,I2,0);
6932     VARAND(EMPTY,0,UI2,0,I4,0);
6933     VARAND(EMPTY,0,UI2,1,I4,0);
6934     VARAND(EMPTY,1,UI2,1,I4,0);
6935     VARAND(EMPTY,0,I4,0,I4,0);
6936     VARAND(EMPTY,0,I4,1,I4,0);
6937     VARAND(EMPTY,1,I4,1,I4,0);
6938     VARAND(EMPTY,0,UI4,0,I4,0);
6939     VARAND(EMPTY,0,UI4,1,I4,0);
6940     VARAND(EMPTY,1,UI4,1,I4,0);
6941     if (has_i8)
6942     {
6943         VARAND(EMPTY,0,I8,0,I8,0);
6944         VARAND(EMPTY,0,I8,1,I8,0);
6945         VARAND(EMPTY,1,I8,1,I8,0);
6946         VARAND(EMPTY,0,UI8,0,I4,0);
6947         VARAND(EMPTY,0,UI8,1,I4,0);
6948         VARAND(EMPTY,1,UI8,1,I4,0);
6949     }
6950     VARAND(EMPTY,0,INT,0,I4,0);
6951     VARAND(EMPTY,0,INT,1,I4,0);
6952     VARAND(EMPTY,1,INT,1,I4,0);
6953     VARAND(EMPTY,0,UINT,0,I4,0);
6954     VARAND(EMPTY,0,UINT,1,I4,0);
6955     VARAND(EMPTY,1,UINT,1,I4,0);
6956     VARAND(EMPTY,0,BOOL,0,I2,0);
6957     VARAND(EMPTY,0,BOOL,1,I2,0);
6958     VARAND(EMPTY,1,BOOL,1,I2,0);
6959     VARAND(EMPTY,0,R4,0,I4,0);
6960     VARAND(EMPTY,0,R4,1,I4,0);
6961     VARAND(EMPTY,1,R4,1,I4,0);
6962     VARAND(EMPTY,0,R8,0,I4,0);
6963     VARAND(EMPTY,0,R8,1,I4,0);
6964     VARAND(EMPTY,1,R8,1,I4,0);
6965     VARAND(EMPTY,0,BSTR,false_str,I2,0);
6966     VARAND(EMPTY,0,BSTR,true_str,I2,0);
6967     VARANDCY(EMPTY,0,10000,I4,0);
6968
6969     /* NULL OR 0 = NULL. NULL OR n = n */
6970     VARAND(NULL,0,NULL,0,NULL,0);
6971     VARAND(NULL,1,NULL,0,NULL,0);
6972     VARAND(NULL,0,I1,0,I4,0);
6973     VARAND(NULL,0,I1,1,NULL,0);
6974     VARAND(NULL,0,UI1,0,UI1,0);
6975     VARAND(NULL,0,UI1,1,NULL,0);
6976     VARAND(NULL,0,I2,0,I2,0);
6977     VARAND(NULL,0,I2,1,NULL,0);
6978     VARAND(NULL,0,UI2,0,I4,0);
6979     VARAND(NULL,0,UI2,1,NULL,0);
6980     VARAND(NULL,0,I4,0,I4,0);
6981     VARAND(NULL,0,I4,1,NULL,0);
6982     VARAND(NULL,0,UI4,0,I4,0);
6983     VARAND(NULL,0,UI4,1,NULL,0);
6984     if (has_i8)
6985     {
6986         VARAND(NULL,0,I8,0,I8,0);
6987         VARAND(NULL,0,I8,1,NULL,0);
6988         VARAND(NULL,0,UI8,0,I4,0);
6989         VARAND(NULL,0,UI8,1,NULL,0);
6990     }
6991     VARAND(NULL,0,INT,0,I4,0);
6992     VARAND(NULL,0,INT,1,NULL,0);
6993     VARAND(NULL,0,UINT,0,I4,0);
6994     VARAND(NULL,0,UINT,1,NULL,0);
6995     VARAND(NULL,0,BOOL,0,BOOL,0);
6996     VARAND(NULL,0,BOOL,1,NULL,0);
6997     VARAND(NULL,0,R4,0,I4,0);
6998     VARAND(NULL,0,R4,1,NULL,0);
6999     VARAND(NULL,0,R8,0,I4,0);
7000     VARAND(NULL,0,R8,1,NULL,0);
7001     VARAND(NULL,0,BSTR,false_str,BOOL,0);
7002     VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
7003     VARANDCY(NULL,0,10000,NULL,0);
7004     VARANDCY(NULL,0,0,I4,0);
7005     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
7006     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
7007     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
7008     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
7009
7010     /* Assume x,y & y,x are the same from now on to reduce the number of tests */
7011     VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
7012     VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
7013     VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
7014     VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
7015     VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
7016     VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
7017     VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
7018     VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
7019     VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
7020     VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
7021     VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
7022     VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
7023     VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
7024     VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
7025     VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
7026     VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
7027     VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
7028     VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
7029     VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
7030     VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
7031     VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
7032     VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
7033     VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
7034     VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
7035     VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
7036     VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
7037     VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
7038     if (has_i8)
7039     {
7040         VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
7041         VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
7042         VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
7043         VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
7044         VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
7045     }
7046     VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
7047     VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
7048     VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
7049     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
7050     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
7051     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
7052     VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
7053     VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
7054     VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
7055     VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
7056     VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
7057     VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
7058     VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
7059     VARAND(I1,-1,I1,-1,I4,-1);
7060     VARAND(I1,-1,I1,0,I4,0);
7061     VARAND(I1,0,I1,0,I4,0);
7062     VARAND(I1,-1,UI1,255,I4,255);
7063     VARAND(I1,-1,UI1,0,I4,0);
7064     VARAND(I1,0,UI1,0,I4,0);
7065     VARAND(I1,-1,I2,-1,I4,-1);
7066     VARAND(I1,-1,I2,0,I4,0);
7067     VARAND(I1,0,I2,0,I4,0);
7068     VARAND(I1,-1,UI2,65535,I4,65535);
7069     VARAND(I1,-1,UI2,0,I4,0);
7070     VARAND(I1,0,UI2,0,I4,0);
7071     VARAND(I1,-1,I4,-1,I4,-1);
7072     VARAND(I1,-1,I4,0,I4,0);
7073     VARAND(I1,0,I4,0,I4,0);
7074     VARAND(I1,-1,UI4,0xffffffff,I4,-1);
7075     VARAND(I1,-1,UI4,0,I4,0);
7076     VARAND(I1,0,UI4,0,I4,0);
7077     VARAND(I1,-1,R4,-1,I4,-1);
7078     VARAND(I1,-1,R4,0,I4,0);
7079     VARAND(I1,0,R4,0,I4,0);
7080     VARAND(I1,-1,R8,-1,I4,-1);
7081     VARAND(I1,-1,R8,0,I4,0);
7082     VARAND(I1,0,R8,0,I4,0);
7083     VARAND(I1,-1,DATE,-1,I4,-1);
7084     VARAND(I1,-1,DATE,0,I4,0);
7085     VARAND(I1,0,DATE,0,I4,0);
7086     if (has_i8)
7087     {
7088         VARAND(I1,-1,I8,-1,I8,-1);
7089         VARAND(I1,-1,I8,0,I8,0);
7090         VARAND(I1,0,I8,0,I8,0);
7091         VARAND(I1,-1,UI8,0,I4,0);
7092         VARAND(I1,0,UI8,0,I4,0);
7093     }
7094     VARAND(I1,-1,INT,-1,I4,-1);
7095     VARAND(I1,-1,INT,0,I4,0);
7096     VARAND(I1,0,INT,0,I4,0);
7097     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
7098     VARAND(I1,-1,UINT,0,I4,0);
7099     VARAND(I1,0,UINT,0,I4,0);
7100     VARAND(I1,0,BSTR,false_str,I4,0);
7101     VARAND(I1,-1,BSTR,false_str,I4,0);
7102     VARAND(I1,0,BSTR,true_str,I4,0);
7103     VARAND(I1,-1,BSTR,true_str,I4,-1);
7104     VARANDCY(I1,-1,10000,I4,1);
7105     VARANDCY(I1,-1,0,I4,0);
7106     VARANDCY(I1,0,0,I4,0);
7107
7108     VARAND(UI1,255,UI1,255,UI1,255);
7109     VARAND(UI1,255,UI1,0,UI1,0);
7110     VARAND(UI1,0,UI1,0,UI1,0);
7111     VARAND(UI1,255,I2,-1,I2,255);
7112     VARAND(UI1,255,I2,0,I2,0);
7113     VARAND(UI1,0,I2,0,I2,0);
7114     VARAND(UI1,255,UI2,65535,I4,255);
7115     VARAND(UI1,255,UI2,0,I4,0);
7116     VARAND(UI1,0,UI2,0,I4,0);
7117     VARAND(UI1,255,I4,-1,I4,255);
7118     VARAND(UI1,255,I4,0,I4,0);
7119     VARAND(UI1,0,I4,0,I4,0);
7120     VARAND(UI1,255,UI4,0xffffffff,I4,255);
7121     VARAND(UI1,255,UI4,0,I4,0);
7122     VARAND(UI1,0,UI4,0,I4,0);
7123     VARAND(UI1,255,R4,-1,I4,255);
7124     VARAND(UI1,255,R4,0,I4,0);
7125     VARAND(UI1,0,R4,0,I4,0);
7126     VARAND(UI1,255,R8,-1,I4,255);
7127     VARAND(UI1,255,R8,0,I4,0);
7128     VARAND(UI1,0,R8,0,I4,0);
7129     VARAND(UI1,255,DATE,-1,I4,255);
7130     VARAND(UI1,255,DATE,0,I4,0);
7131     VARAND(UI1,0,DATE,0,I4,0);
7132     if (has_i8)
7133     {
7134         VARAND(UI1,255,I8,-1,I8,255);
7135         VARAND(UI1,255,I8,0,I8,0);
7136         VARAND(UI1,0,I8,0,I8,0);
7137         VARAND(UI1,255,UI8,0,I4,0);
7138         VARAND(UI1,0,UI8,0,I4,0);
7139     }
7140     VARAND(UI1,255,INT,-1,I4,255);
7141     VARAND(UI1,255,INT,0,I4,0);
7142     VARAND(UI1,0,INT,0,I4,0);
7143     VARAND(UI1,255,UINT,0xffffffff,I4,255);
7144     VARAND(UI1,255,UINT,0,I4,0);
7145     VARAND(UI1,0,UINT,0,I4,0);
7146     VARAND(UI1,0,BSTR,false_str,I2,0);
7147     VARAND(UI1,255,BSTR,false_str,I2,0);
7148     VARAND(UI1,0,BSTR,true_str,I2,0);
7149     VARAND(UI1,255,BSTR,true_str,I2,255);
7150     VARANDCY(UI1,255,10000,I4,1);
7151     VARANDCY(UI1,255,0,I4,0);
7152     VARANDCY(UI1,0,0,I4,0);
7153
7154     VARAND(I2,-1,I2,-1,I2,-1);
7155     VARAND(I2,-1,I2,0,I2,0);
7156     VARAND(I2,0,I2,0,I2,0);
7157     VARAND(I2,-1,UI2,65535,I4,65535);
7158     VARAND(I2,-1,UI2,0,I4,0);
7159     VARAND(I2,0,UI2,0,I4,0);
7160     VARAND(I2,-1,I4,-1,I4,-1);
7161     VARAND(I2,-1,I4,0,I4,0);
7162     VARAND(I2,0,I4,0,I4,0);
7163     VARAND(I2,-1,UI4,0xffffffff,I4,-1);
7164     VARAND(I2,-1,UI4,0,I4,0);
7165     VARAND(I2,0,UI4,0,I4,0);
7166     VARAND(I2,-1,R4,-1,I4,-1);
7167     VARAND(I2,-1,R4,0,I4,0);
7168     VARAND(I2,0,R4,0,I4,0);
7169     VARAND(I2,-1,R8,-1,I4,-1);
7170     VARAND(I2,-1,R8,0,I4,0);
7171     VARAND(I2,0,R8,0,I4,0);
7172     VARAND(I2,-1,DATE,-1,I4,-1);
7173     VARAND(I2,-1,DATE,0,I4,0);
7174     VARAND(I2,0,DATE,0,I4,0);
7175     if (has_i8)
7176     {
7177         VARAND(I2,-1,I8,-1,I8,-1);
7178         VARAND(I2,-1,I8,0,I8,0);
7179         VARAND(I2,0,I8,0,I8,0);
7180         VARAND(I2,-1,UI8,0,I4,0);
7181         VARAND(I2,0,UI8,0,I4,0);
7182     }
7183     VARAND(I2,-1,INT,-1,I4,-1);
7184     VARAND(I2,-1,INT,0,I4,0);
7185     VARAND(I2,0,INT,0,I4,0);
7186     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
7187     VARAND(I2,-1,UINT,0,I4,0);
7188     VARAND(I2,0,UINT,0,I4,0);
7189     VARAND(I2,0,BSTR,false_str,I2,0);
7190     VARAND(I2,-1,BSTR,false_str,I2,0);
7191     VARAND(I2,0,BSTR,true_str,I2,0);
7192     VARAND(I2,-1,BSTR,true_str,I2,-1);
7193     VARANDCY(I2,-1,10000,I4,1);
7194     VARANDCY(I2,-1,0,I4,0);
7195     VARANDCY(I2,0,0,I4,0);
7196
7197     VARAND(UI2,65535,UI2,65535,I4,65535);
7198     VARAND(UI2,65535,UI2,0,I4,0);
7199     VARAND(UI2,0,UI2,0,I4,0);
7200     VARAND(UI2,65535,I4,-1,I4,65535);
7201     VARAND(UI2,65535,I4,0,I4,0);
7202     VARAND(UI2,0,I4,0,I4,0);
7203     VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
7204     VARAND(UI2,65535,UI4,0,I4,0);
7205     VARAND(UI2,0,UI4,0,I4,0);
7206     VARAND(UI2,65535,R4,-1,I4,65535);
7207     VARAND(UI2,65535,R4,0,I4,0);
7208     VARAND(UI2,0,R4,0,I4,0);
7209     VARAND(UI2,65535,R8,-1,I4,65535);
7210     VARAND(UI2,65535,R8,0,I4,0);
7211     VARAND(UI2,0,R8,0,I4,0);
7212     VARAND(UI2,65535,DATE,-1,I4,65535);
7213     VARAND(UI2,65535,DATE,0,I4,0);
7214     VARAND(UI2,0,DATE,0,I4,0);
7215     if (has_i8)
7216     {
7217         VARAND(UI2,65535,I8,-1,I8,65535);
7218         VARAND(UI2,65535,I8,0,I8,0);
7219         VARAND(UI2,0,I8,0,I8,0);
7220         VARAND(UI2,65535,UI8,0,I4,0);
7221         VARAND(UI2,0,UI8,0,I4,0);
7222     }
7223     VARAND(UI2,65535,INT,-1,I4,65535);
7224     VARAND(UI2,65535,INT,0,I4,0);
7225     VARAND(UI2,0,INT,0,I4,0);
7226     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
7227     VARAND(UI2,65535,UINT,0,I4,0);
7228     VARAND(UI2,0,UINT,0,I4,0);
7229     VARAND(UI2,0,BSTR,false_str,I4,0);
7230     VARAND(UI2,65535,BSTR,false_str,I4,0);
7231     VARAND(UI2,0,BSTR,true_str,I4,0);
7232     VARAND(UI2,65535,BSTR,true_str,I4,65535);
7233     VARANDCY(UI2,65535,10000,I4,1);
7234     VARANDCY(UI2,65535,0,I4,0);
7235     VARANDCY(UI2,0,0,I4,0);
7236
7237     VARAND(I4,-1,I4,-1,I4,-1);
7238     VARAND(I4,-1,I4,0,I4,0);
7239     VARAND(I4,0,I4,0,I4,0);
7240     VARAND(I4,-1,UI4,0xffffffff,I4,-1);
7241     VARAND(I4,-1,UI4,0,I4,0);
7242     VARAND(I4,0,UI4,0,I4,0);
7243     VARAND(I4,-1,R4,-1,I4,-1);
7244     VARAND(I4,-1,R4,0,I4,0);
7245     VARAND(I4,0,R4,0,I4,0);
7246     VARAND(I4,-1,R8,-1,I4,-1);
7247     VARAND(I4,-1,R8,0,I4,0);
7248     VARAND(I4,0,R8,0,I4,0);
7249     VARAND(I4,-1,DATE,-1,I4,-1);
7250     VARAND(I4,-1,DATE,0,I4,0);
7251     VARAND(I4,0,DATE,0,I4,0);
7252     if (has_i8)
7253     {
7254         VARAND(I4,-1,I8,-1,I8,-1);
7255         VARAND(I4,-1,I8,0,I8,0);
7256         VARAND(I4,0,I8,0,I8,0);
7257         VARAND(I4,-1,UI8,0,I4,0);
7258         VARAND(I4,0,UI8,0,I4,0);
7259     }
7260     VARAND(I4,-1,INT,-1,I4,-1);
7261     VARAND(I4,-1,INT,0,I4,0);
7262     VARAND(I4,0,INT,0,I4,0);
7263     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
7264     VARAND(I4,-1,UINT,0,I4,0);
7265     VARAND(I4,0,UINT,0,I4,0);
7266     VARAND(I4,0,BSTR,false_str,I4,0);
7267     VARAND(I4,-1,BSTR,false_str,I4,0);
7268     VARAND(I4,0,BSTR,true_str,I4,0);
7269     VARAND(I4,-1,BSTR,true_str,I4,-1);
7270     VARANDCY(I4,-1,10000,I4,1);
7271     VARANDCY(I4,-1,0,I4,0);
7272     VARANDCY(I4,0,0,I4,0);
7273
7274     VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
7275     VARAND(UI4,0xffffffff,UI4,0,I4,0);
7276     VARAND(UI4,0,UI4,0,I4,0);
7277     VARAND(UI4,0xffffffff,R4,-1,I4,-1);
7278     VARAND(UI4,0xffffffff,R4,0,I4,0);
7279     VARAND(UI4,0,R4,0,I4,0);
7280     VARAND(UI4,0xffffffff,R8,-1,I4,-1);
7281     VARAND(UI4,0xffffffff,R8,0,I4,0);
7282     VARAND(UI4,0,R8,0,I4,0);
7283     VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
7284     VARAND(UI4,0xffffffff,DATE,0,I4,0);
7285     VARAND(UI4,0,DATE,0,I4,0);
7286     if (has_i8)
7287     {
7288         VARAND(UI4,0xffffffff,I8,0,I8,0);
7289         VARAND(UI4,0,I8,0,I8,0);
7290         VARAND(UI4,0xffffffff,UI8,0,I4,0);
7291         VARAND(UI4,0,UI8,0,I4,0);
7292     }
7293     VARAND(UI4,0xffffffff,INT,-1,I4,-1);
7294     VARAND(UI4,0xffffffff,INT,0,I4,0);
7295     VARAND(UI4,0,INT,0,I4,0);
7296     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
7297     VARAND(UI4,0xffffffff,UINT,0,I4,0);
7298     VARAND(UI4,0,UINT,0,I4,0);
7299     VARAND(UI4,0,BSTR,false_str,I4,0);
7300     VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
7301     VARAND(UI4,0,BSTR,true_str,I4,0);
7302     VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
7303     VARANDCY(UI4,0xffffffff,10000,I4,1);
7304     VARANDCY(UI4,0xffffffff,0,I4,0);
7305     VARANDCY(UI4,0,0,I4,0);
7306
7307     VARAND(R4,-1,R4,-1,I4,-1);
7308     VARAND(R4,-1,R4,0,I4,0);
7309     VARAND(R4,0,R4,0,I4,0);
7310     VARAND(R4,-1,R8,-1,I4,-1);
7311     VARAND(R4,-1,R8,0,I4,0);
7312     VARAND(R4,0,R8,0,I4,0);
7313     VARAND(R4,-1,DATE,-1,I4,-1);
7314     VARAND(R4,-1,DATE,0,I4,0);
7315     VARAND(R4,0,DATE,0,I4,0);
7316     if (has_i8)
7317     {
7318         VARAND(R4,-1,I8,-1,I8,-1);
7319         VARAND(R4,-1,I8,0,I8,0);
7320         VARAND(R4,0,I8,0,I8,0);
7321         VARAND(R4,-1,UI8,0,I4,0);
7322         VARAND(R4,0,UI8,0,I4,0);
7323     }
7324     VARAND(R4,-1,INT,-1,I4,-1);
7325     VARAND(R4,-1,INT,0,I4,0);
7326     VARAND(R4,0,INT,0,I4,0);
7327     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
7328     VARAND(R4,-1,UINT,0,I4,0);
7329     VARAND(R4,0,UINT,0,I4,0);
7330     VARAND(R4,0,BSTR,false_str,I4,0);
7331     VARAND(R4,-1,BSTR,false_str,I4,0);
7332     VARAND(R4,0,BSTR,true_str,I4,0);
7333     VARAND(R4,-1,BSTR,true_str,I4,-1);
7334     VARANDCY(R4,-1,10000,I4,1);
7335     VARANDCY(R4,-1,0,I4,0);
7336     VARANDCY(R4,0,0,I4,0);
7337
7338     VARAND(R8,-1,R8,-1,I4,-1);
7339     VARAND(R8,-1,R8,0,I4,0);
7340     VARAND(R8,0,R8,0,I4,0);
7341     VARAND(R8,-1,DATE,-1,I4,-1);
7342     VARAND(R8,-1,DATE,0,I4,0);
7343     VARAND(R8,0,DATE,0,I4,0);
7344     if (has_i8)
7345     {
7346         VARAND(R8,-1,I8,-1,I8,-1);
7347         VARAND(R8,-1,I8,0,I8,0);
7348         VARAND(R8,0,I8,0,I8,0);
7349         VARAND(R8,-1,UI8,0,I4,0);
7350         VARAND(R8,0,UI8,0,I4,0);
7351     }
7352     VARAND(R8,-1,INT,-1,I4,-1);
7353     VARAND(R8,-1,INT,0,I4,0);
7354     VARAND(R8,0,INT,0,I4,0);
7355     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
7356     VARAND(R8,-1,UINT,0,I4,0);
7357     VARAND(R8,0,UINT,0,I4,0);
7358     VARAND(R8,0,BSTR,false_str,I4,0);
7359     VARAND(R8,-1,BSTR,false_str,I4,0);
7360     VARAND(R8,0,BSTR,true_str,I4,0);
7361     VARAND(R8,-1,BSTR,true_str,I4,-1);
7362     VARANDCY(R8,-1,10000,I4,1);
7363     VARANDCY(R8,-1,0,I4,0);
7364     VARANDCY(R8,0,0,I4,0);
7365
7366     VARAND(DATE,-1,DATE,-1,I4,-1);
7367     VARAND(DATE,-1,DATE,0,I4,0);
7368     VARAND(DATE,0,DATE,0,I4,0);
7369     if (has_i8)
7370     {
7371         VARAND(DATE,-1,I8,-1,I8,-1);
7372         VARAND(DATE,-1,I8,0,I8,0);
7373         VARAND(DATE,0,I8,0,I8,0);
7374         VARAND(DATE,-1,UI8,0,I4,0);
7375         VARAND(DATE,0,UI8,0,I4,0);
7376     }
7377     VARAND(DATE,-1,INT,-1,I4,-1);
7378     VARAND(DATE,-1,INT,0,I4,0);
7379     VARAND(DATE,0,INT,0,I4,0);
7380     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
7381     VARAND(DATE,-1,UINT,0,I4,0);
7382     VARAND(DATE,0,UINT,0,I4,0);
7383     VARAND(DATE,0,BSTR,false_str,I4,0);
7384     VARAND(DATE,-1,BSTR,false_str,I4,0);
7385     VARAND(DATE,0,BSTR,true_str,I4,0);
7386     VARAND(DATE,-1,BSTR,true_str,I4,-1);
7387     VARANDCY(DATE,-1,10000,I4,1);
7388     VARANDCY(DATE,-1,0,I4,0);
7389     VARANDCY(DATE,0,0,I4,0);
7390
7391     if (has_i8)
7392     {
7393         VARAND(I8,-1,I8,-1,I8,-1);
7394         VARAND(I8,-1,I8,0,I8,0);
7395         VARAND(I8,0,I8,0,I8,0);
7396         VARAND(I8,-1,UI8,0,I8,0);
7397         VARAND(I8,0,UI8,0,I8,0);
7398         VARAND(I8,-1,UINT,0,I8,0);
7399         VARAND(I8,0,UINT,0,I8,0);
7400         VARAND(I8,0,BSTR,false_str,I8,0);
7401         VARAND(I8,-1,BSTR,false_str,I8,0);
7402         VARAND(I8,0,BSTR,true_str,I8,0);
7403         VARAND(I8,-1,BSTR,true_str,I8,-1);
7404         VARANDCY(I8,-1,10000,I8,1);
7405         VARANDCY(I8,-1,0,I8,0);
7406         VARANDCY(I8,0,0,I8,0);
7407
7408         VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
7409         VARAND(UI8,0xffff,UI8,0,I4,0);
7410         VARAND(UI8,0,UI8,0,I4,0);
7411         VARAND(UI8,0xffff,INT,-1,I4,65535);
7412         VARAND(UI8,0xffff,INT,0,I4,0);
7413         VARAND(UI8,0,INT,0,I4,0);
7414         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
7415         VARAND(UI8,0xffff,UINT,0,I4,0);
7416         VARAND(UI8,0,UINT,0,I4,0);
7417         VARAND(UI8,0,BSTR,false_str,I4,0);
7418         VARAND(UI8,0xffff,BSTR,false_str,I4,0);
7419         VARAND(UI8,0,BSTR,true_str,I4,0);
7420         VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
7421         VARANDCY(UI8,0xffff,10000,I4,1);
7422         VARANDCY(UI8,0xffff,0,I4,0);
7423         VARANDCY(UI8,0,0,I4,0);
7424     }
7425
7426     VARAND(INT,-1,INT,-1,I4,-1);
7427     VARAND(INT,-1,INT,0,I4,0);
7428     VARAND(INT,0,INT,0,I4,0);
7429     VARAND(INT,-1,UINT,0xffff,I4,65535);
7430     VARAND(INT,-1,UINT,0,I4,0);
7431     VARAND(INT,0,UINT,0,I4,0);
7432     VARAND(INT,0,BSTR,false_str,I4,0);
7433     VARAND(INT,-1,BSTR,false_str,I4,0);
7434     VARAND(INT,0,BSTR,true_str,I4,0);
7435     VARAND(INT,-1,BSTR,true_str,I4,-1);
7436     VARANDCY(INT,-1,10000,I4,1);
7437     VARANDCY(INT,-1,0,I4,0);
7438     VARANDCY(INT,0,0,I4,0);
7439
7440     VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
7441     VARAND(UINT,0xffff,UINT,0,I4,0);
7442     VARAND(UINT,0,UINT,0,I4,0);
7443     VARAND(UINT,0,BSTR,false_str,I4,0);
7444     VARAND(UINT,0xffff,BSTR, false_str,I4,0);
7445     VARAND(UINT,0,BSTR,true_str,I4,0);
7446     VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
7447     VARANDCY(UINT,0xffff,10000,I4,1);
7448     VARANDCY(UINT,0xffff,0,I4,0);
7449     VARANDCY(UINT,0,0,I4,0);
7450
7451     VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
7452     VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
7453     VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
7454     VARANDCY(BSTR,true_str,10000,I4,1);
7455     VARANDCY(BSTR,false_str,10000,I4,0);
7456
7457     SysFreeString(true_str);
7458     SysFreeString(false_str);
7459 }
7460
7461 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
7462 {
7463     HRESULT hres;
7464
7465     hres = VarCmp(left,right,lcid,flags);
7466     ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%lx, got hres=0x%lx\n",
7467                        wine_dbgstr_variant(left), wine_dbgstr_variant(right), result, hres );
7468 }
7469 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
7470                         HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
7471 {
7472     test_cmp( line, lcid, 0, left, right, res1 );
7473     V_VT(left) |= VT_RESERVED;
7474     test_cmp( line, lcid, 0, left, right, res2 );
7475     V_VT(left) &= ~VT_RESERVED;
7476     V_VT(right) |= VT_RESERVED;
7477     test_cmp( line, lcid, 0, left, right, res3 );
7478     V_VT(left) |= VT_RESERVED;
7479     test_cmp( line, lcid, 0, left, right, res4 );
7480     ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
7481 }
7482
7483 /* ERROR from wingdi.h is interfering here */
7484 #undef ERROR
7485 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
7486         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
7487         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
7488         test_cmp( __LINE__, lcid, flags, &left, &right, result )
7489 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
7490         V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
7491         V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
7492         test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
7493 #define VARCMP(vt1,val1,vt2,val2,result) \
7494         VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
7495 /* The above macros do not work for VT_NULL as NULL gets expanded first */
7496 #define V_NULL_  V_NULL
7497 #define VT_NULL_ VT_NULL
7498
7499 static void test_VarCmp(void)
7500 {
7501     VARIANT left, right;
7502     VARTYPE i;
7503     LCID lcid;
7504     HRESULT hres;
7505     DECIMAL dec;
7506     BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
7507     BSTR bstr2cents, bstr1few;
7508
7509     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
7510     bstrempty = SysAllocString(L"");
7511     bstrhuh = SysAllocString(L"huh?");
7512     bstr2cents = SysAllocString(L"2cents");
7513     bstr0 = SysAllocString(L"0");
7514     bstr1 = SysAllocString(L"1");
7515     bstr7 = SysAllocString(L"7");
7516     bstr42 = SysAllocString(L"42");
7517     bstr1neg = SysAllocString(L"-1");
7518     bstr666neg = SysAllocString(L"-666");
7519     bstr1few = SysAllocString(L"1.00000001");
7520
7521     /* Test all possible flag/vt combinations & the resulting vt type */
7522     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
7523     {
7524         VARTYPE leftvt, rightvt;
7525
7526         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7527         {
7528
7529             SKIPTESTS(leftvt);
7530
7531             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7532             {
7533                 BOOL bFail = FALSE;
7534                 HRESULT expect = VARCMP_EQ;
7535
7536                 SKIPTESTS(rightvt);
7537
7538                 memset(&left, 0, sizeof(left));
7539                 memset(&right, 0, sizeof(right));
7540                 V_VT(&left) = leftvt | ExtraFlags[i];
7541                 if (leftvt == VT_BSTR) {
7542                     V_BSTR(&left) = bstr1neg;
7543                     if (ExtraFlags[i] & VT_RESERVED)
7544                         expect = VARCMP_LT;
7545                     else
7546                         expect = VARCMP_GT;
7547                 }
7548                 V_VT(&right) = rightvt | ExtraFlags[i];
7549                 if (rightvt == VT_BSTR) {
7550                     V_BSTR(&right) = bstr1neg;
7551                     if (ExtraFlags[i] & VT_RESERVED)
7552                         expect = VARCMP_GT;
7553                     else
7554                         expect = VARCMP_LT;
7555                 }
7556
7557                 /* Don't ask me why but native VarCmp cannot handle:
7558                    VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
7559                    VT_INT is only supported as left variant. Go figure.
7560                    Tested with DCOM98, Win2k, WinXP */
7561                 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
7562                     !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
7563                     !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
7564                     leftvt == VT_CLSID || rightvt == VT_CLSID ||
7565                     leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
7566                     leftvt == VT_ERROR || rightvt == VT_ERROR ||
7567                     leftvt == VT_RECORD || rightvt == VT_RECORD ||
7568                     leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
7569                     leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
7570                     leftvt == VT_I1 || rightvt == VT_I1 ||
7571                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
7572                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
7573                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
7574                     rightvt == VT_INT ||
7575                     leftvt == VT_UINT || rightvt == VT_UINT) {
7576                     bFail = TRUE;
7577                 }
7578
7579                 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
7580                     !(ExtraFlags[i] & ~VT_RESERVED)) {
7581                     expect = VARCMP_EQ;
7582                     bFail = FALSE;
7583                 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
7584                     expect = VARCMP_NULL;
7585                 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
7586                     expect = VARCMP_EQ;
7587                 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
7588                     expect = VARCMP_GT;
7589                 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
7590                     expect = VARCMP_LT;
7591
7592                 hres = VarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
7593                 if (bFail) {
7594                     ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
7595                        "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%lX\n",
7596                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
7597                 } else {
7598                     ok(hres == expect,
7599                        "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%lX, got 0x%lX\n",
7600                        leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
7601                        hres);
7602                 }
7603             }
7604         }
7605     }
7606
7607     /* VARCMP{,EX} run each 4 tests with a permutation of all possible
7608        input variants with (1) and without (0) VT_RESERVED set. The order
7609        of the permutations is (0,0); (1,0); (0,1); (1,1) */
7610     VARCMP(INT,4711,I2,4711,VARCMP_EQ);
7611     VARCMP(INT,4711,I2,-4711,VARCMP_GT);
7612     VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
7613     VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
7614     VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
7615     VARCMP(I4,1,R8,1.0,VARCMP_EQ);
7616     VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
7617     ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
7618     VARCMP(I4,1,UI1,1,VARCMP_EQ);
7619     VARCMP(I2,2,I2,2,VARCMP_EQ);
7620     VARCMP(I2,1,I2,2,VARCMP_LT);
7621     VARCMP(I2,2,I2,1,VARCMP_GT);
7622     VARCMP(I2,2,EMPTY,1,VARCMP_GT);
7623     VARCMP(I2,2,NULL_,1,VARCMP_NULL);
7624
7625     /* BSTR handling, especially in conjunction with VT_RESERVED */
7626     VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
7627     VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
7628     VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
7629     VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
7630     VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
7631     VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
7632     VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
7633     VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
7634     VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
7635     VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
7636     VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
7637     VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
7638     VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
7639     VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
7640     VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7641     VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7642     VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
7643     VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7644     VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
7645     _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
7646     VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7647     VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
7648     VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
7649     VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
7650     VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7651     VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
7652     VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7653     VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7654     VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7655     VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7656     VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
7657     VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7658     VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
7659     VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7660     VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
7661     VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7662     VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
7663     VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
7664     VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7665     VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
7666     VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
7667     VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
7668     VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
7669     VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
7670     VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
7671     VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
7672     VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
7673     VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
7674     VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
7675     VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
7676     VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
7677     VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
7678     VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
7679     VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
7680     VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
7681
7682     /* DECIMAL handling */
7683     setdec(&dec,0,0,0,0);
7684     VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
7685     setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
7686     VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT);    /* R8 has bigger range */
7687     VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT);  /* DATE has bigger range */
7688     setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
7689     VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
7690     setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001);    /* 1+1e-20 */
7691     VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
7692
7693     /* Show that DATE is handled just as a R8 */
7694     VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
7695     VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
7696     VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
7697     VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT);      /* 1e-15 == 8.64e-11 seconds */
7698     VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
7699     VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
7700     VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
7701     VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
7702     VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
7703
7704     /* R4 precision handling */
7705     VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
7706     VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
7707     VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
7708     VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
7709     VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
7710     VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
7711     VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
7712     setdec(&dec,8,0,0,0x5F5E101);         /* 1+1e-8 */
7713     VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
7714
7715     SysFreeString(bstrhuh);
7716     SysFreeString(bstrempty);
7717     SysFreeString(bstr0);
7718     SysFreeString(bstr1);
7719     SysFreeString(bstr7);
7720     SysFreeString(bstr42);
7721     SysFreeString(bstr1neg);
7722     SysFreeString(bstr666neg);
7723     SysFreeString(bstr2cents);
7724     SysFreeString(bstr1few);
7725 }
7726
7727 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
7728
7729 #define VARPOW(vt1,val1,vt2,val2,rvt,rval)               \
7730         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
7731         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7732         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
7733         test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
7734
7735 /* Skip any type that is not defined or produces an error for every case */
7736 #define SKIPTESTPOW(a)                            \
7737     if (a == VT_ERROR || a == VT_VARIANT ||       \
7738         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
7739         a == VT_RECORD || a > VT_UINT ||          \
7740         a == 15 /*not defined*/)                  \
7741         continue
7742
7743 static void test_VarPow(void)
7744 {
7745     VARIANT left, right, exp, result, cy, dec;
7746     BSTR num2_str, num3_str;
7747     VARTYPE i;
7748     HRESULT hres;
7749
7750     CHECKPTR(VarPow);
7751
7752     num2_str = SysAllocString(L"2");
7753     num3_str = SysAllocString(L"3");
7754
7755     /* Test all possible flag/vt combinations & the resulting vt type */
7756     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
7757     {
7758         VARTYPE leftvt, rightvt, resvt;
7759
7760         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7761         {
7762             SKIPTESTPOW(leftvt);
7763
7764             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7765             {
7766                 BOOL bFail = FALSE;
7767                 SKIPTESTPOW(rightvt);
7768
7769                 /* Native crashes with VT_BYREF */
7770                 if (ExtraFlags[i] == VT_BYREF)
7771                     continue;
7772
7773                 memset(&left, 0, sizeof(left));
7774                 memset(&right, 0, sizeof(right));
7775                 V_VT(&left) = leftvt | ExtraFlags[i];
7776                 V_VT(&right) = rightvt | ExtraFlags[i];
7777                 V_VT(&result) = VT_EMPTY;
7778                 resvt = VT_EMPTY;
7779
7780                 if (leftvt == VT_BSTR)
7781                     V_BSTR(&left) = num2_str;
7782                 if (rightvt == VT_BSTR)
7783                     V_BSTR(&right) = num2_str;
7784
7785                 /* Native VarPow always returns an error when using extra flags */
7786                 if (ExtraFlags[i] != 0)
7787                     bFail = TRUE;
7788
7789                 /* Determine return type */
7790                 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
7791                          ((leftvt != VT_I8 && leftvt != VT_UI8 &&
7792                            rightvt != VT_I8 && rightvt != VT_UI8) || has_i8))
7793                     resvt = VT_NULL;
7794                 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
7795                     leftvt == VT_I4 || leftvt == VT_R4 ||
7796                     leftvt == VT_R8 || leftvt == VT_CY ||
7797                     leftvt == VT_DATE || leftvt == VT_BSTR ||
7798                     leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
7799                     (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
7800                     (has_i8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
7801                     leftvt == VT_INT || leftvt == VT_UINT) &&
7802                     (rightvt == VT_EMPTY || rightvt == VT_I2 ||
7803                     rightvt == VT_I4 || rightvt == VT_R4 ||
7804                     rightvt == VT_R8 || rightvt == VT_CY ||
7805                     rightvt == VT_DATE || rightvt == VT_BSTR ||
7806                     rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
7807                     (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
7808                     (has_i8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
7809                     rightvt == VT_INT || rightvt == VT_UINT))
7810                     resvt = VT_R8;
7811                 else
7812                     bFail = TRUE;
7813
7814                 hres = pVarPow(&left, &right, &result);
7815
7816                 /* Check expected HRESULT and if result variant type is correct */
7817                 if (bFail)
7818                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
7819                         "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%lX\n",
7820                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i],
7821                         wine_dbgstr_vt(V_VT(&result)), hres);
7822                 else
7823                     ok (hres == S_OK && resvt == V_VT(&result),
7824                         "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%lX, got vt %s hr 0x%lX\n",
7825                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i], wine_dbgstr_vt(resvt),
7826                         S_OK, wine_dbgstr_vt(V_VT(&result)), hres);
7827             }
7828         }
7829     }
7830
7831     /* Check return values for valid variant type combinations */
7832     VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
7833     VARPOW(EMPTY,0,NULL,0,NULL,0);
7834     VARPOW(EMPTY,0,I2,3,R8,0.0);
7835     VARPOW(EMPTY,0,I4,3,R8,0.0);
7836     VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
7837     VARPOW(EMPTY,0,R8,3.0,R8,0.0);
7838     VARPOW(EMPTY,0,DATE,3,R8,0.0);
7839     VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
7840     VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
7841     VARPOW(EMPTY,0,I1,3,R8,0.0);
7842     VARPOW(EMPTY,0,UI1,3,R8,0.0);
7843     VARPOW(EMPTY,0,UI2,3,R8,0.0);
7844     VARPOW(EMPTY,0,UI4,3,R8,0.0);
7845     if (has_i8)
7846     {
7847         VARPOW(EMPTY,0,I8,3,R8,0.0);
7848         VARPOW(EMPTY,0,UI8,3,R8,0.0);
7849     }
7850     VARPOW(EMPTY,0,INT,3,R8,0.0);
7851     VARPOW(EMPTY,0,UINT,3,R8,0.0);
7852     VARPOW(NULL,0,EMPTY,0,NULL,0);
7853     VARPOW(NULL,0,NULL,0,NULL,0);
7854     VARPOW(NULL,0,I2,3,NULL,0);
7855     VARPOW(NULL,0,I4,3,NULL,0);
7856     VARPOW(NULL,0,R4,3.0f,NULL,0);
7857     VARPOW(NULL,0,R8,3.0,NULL,0);
7858     VARPOW(NULL,0,DATE,3,NULL,0);
7859     VARPOW(NULL,0,BSTR,num3_str,NULL,0);
7860     VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7861     VARPOW(NULL,0,I1,3,NULL,0);
7862     VARPOW(NULL,0,UI1,3,NULL,0);
7863     VARPOW(NULL,0,UI2,3,NULL,0);
7864     VARPOW(NULL,0,UI4,3,NULL,0);
7865     if (has_i8)
7866     {
7867         VARPOW(NULL,0,I8,3,NULL,0);
7868         VARPOW(NULL,0,UI8,3,NULL,0);
7869     }
7870     VARPOW(NULL,0,INT,3,NULL,0);
7871     VARPOW(NULL,0,UINT,3,NULL,0);
7872     VARPOW(I2,2,EMPTY,0,R8,1.0);
7873     VARPOW(I2,2,NULL,0,NULL,0);
7874     VARPOW(I2,2,I2,3,R8,8.0);
7875     VARPOW(I2,2,I4,3,R8,8.0);
7876     VARPOW(I2,2,R4,3.0f,R8,8.0);
7877     VARPOW(I2,2,R8,3.0,R8,8.0);
7878     VARPOW(I2,2,DATE,3,R8,8.0);
7879     VARPOW(I2,2,BSTR,num3_str,R8,8.0);
7880     VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
7881     VARPOW(I2,2,I1,3,R8,8.0);
7882     VARPOW(I2,2,UI1,3,R8,8.0);
7883     VARPOW(I2,2,UI2,3,R8,8.0);
7884     VARPOW(I2,2,UI4,3,R8,8.0);
7885     if (has_i8)
7886     {
7887         VARPOW(I2,2,I8,3,R8,8.0);
7888         VARPOW(I2,2,UI8,3,R8,8.0);
7889     }
7890     VARPOW(I2,2,INT,3,R8,8.0);
7891     VARPOW(I2,2,UINT,3,R8,8.0);
7892     VARPOW(I4,2,EMPTY,0,R8,1.0);
7893     VARPOW(I4,2,NULL,0,NULL,0);
7894     VARPOW(I4,2,I2,3,R8,8.0);
7895     VARPOW(I4,2,I4,3,R8,8.0);
7896     VARPOW(I4,2,R4,3.0f,R8,8.0);
7897     VARPOW(I4,2,R8,3.0,R8,8.0);
7898     VARPOW(I4,2,DATE,3,R8,8.0);
7899     VARPOW(I4,2,BSTR,num3_str,R8,8.0);
7900     VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
7901     VARPOW(I4,2,I1,3,R8,8.0);
7902     VARPOW(I4,2,UI1,3,R8,8.0);
7903     VARPOW(I4,2,UI2,3,R8,8.0);
7904     VARPOW(I4,2,UI4,3,R8,8.0);
7905     if (has_i8)
7906     {
7907         VARPOW(I4,2,I8,3,R8,8.0);
7908         VARPOW(I4,2,UI8,3,R8,8.0);
7909     }
7910     VARPOW(I4,2,INT,3,R8,8.0);
7911     VARPOW(I4,2,UINT,3,R8,8.0);
7912     VARPOW(R4,2,EMPTY,0,R8,1.0);
7913     VARPOW(R4,2,NULL,0,NULL,0);
7914     VARPOW(R4,2,I2,3,R8,8.0);
7915     VARPOW(R4,2,I4,3,R8,8.0);
7916     VARPOW(R4,2,R4,3.0f,R8,8.0);
7917     VARPOW(R4,2,R8,3.0,R8,8.0);
7918     VARPOW(R4,2,DATE,3,R8,8.0);
7919     VARPOW(R4,2,BSTR,num3_str,R8,8.0);
7920     VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
7921     VARPOW(R4,2,I1,3,R8,8.0);
7922     VARPOW(R4,2,UI1,3,R8,8.0);
7923     VARPOW(R4,2,UI2,3,R8,8.0);
7924     VARPOW(R4,2,UI4,3,R8,8.0);
7925     if (has_i8)
7926     {
7927         VARPOW(R4,2,I8,3,R8,8.0);
7928         VARPOW(R4,2,UI8,3,R8,8.0);
7929     }
7930     VARPOW(R4,2,INT,3,R8,8.0);
7931     VARPOW(R4,2,UINT,3,R8,8.0);
7932     VARPOW(R8,2,EMPTY,0,R8,1.0);
7933     VARPOW(R8,2,NULL,0,NULL,0);
7934     VARPOW(R8,2,I2,3,R8,8.0);
7935     VARPOW(R8,2,I4,3,R8,8.0);
7936     VARPOW(R8,2,R4,3.0f,R8,8.0);
7937     VARPOW(R8,2,R8,3.0,R8,8.0);
7938     VARPOW(R8,2,DATE,3,R8,8.0);
7939     VARPOW(R8,2,BSTR,num3_str,R8,8.0);
7940     VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
7941     VARPOW(R8,2,I1,3,R8,8.0);
7942     VARPOW(R8,2,UI1,3,R8,8.0);
7943     VARPOW(R8,2,UI2,3,R8,8.0);
7944     VARPOW(R8,2,UI4,3,R8,8.0);
7945     if (has_i8)
7946     {
7947         VARPOW(R8,2,I8,3,R8,8.0);
7948         VARPOW(R8,2,UI8,3,R8,8.0);
7949     }
7950     VARPOW(R8,2,INT,3,R8,8.0);
7951     VARPOW(R8,2,UINT,3,R8,8.0);
7952     VARPOW(DATE,2,EMPTY,0,R8,1.0);
7953     VARPOW(DATE,2,NULL,0,NULL,0);
7954     VARPOW(DATE,2,I2,3,R8,8.0);
7955     VARPOW(DATE,2,I4,3,R8,8.0);
7956     VARPOW(DATE,2,R4,3.0f,R8,8.0);
7957     VARPOW(DATE,2,R8,3.0,R8,8.0);
7958     VARPOW(DATE,2,DATE,3,R8,8.0);
7959     VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
7960     VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
7961     VARPOW(DATE,2,I1,3,R8,8.0);
7962     VARPOW(DATE,2,UI1,3,R8,8.0);
7963     VARPOW(DATE,2,UI2,3,R8,8.0);
7964     VARPOW(DATE,2,UI4,3,R8,8.0);
7965     if (has_i8)
7966     {
7967         VARPOW(DATE,2,I8,3,R8,8.0);
7968         VARPOW(DATE,2,UI8,3,R8,8.0);
7969     }
7970     VARPOW(DATE,2,INT,3,R8,8.0);
7971     VARPOW(DATE,2,UINT,3,R8,8.0);
7972     VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
7973     VARPOW(BSTR,num2_str,NULL,0,NULL,0);
7974     VARPOW(BSTR,num2_str,I2,3,R8,8.0);
7975     VARPOW(BSTR,num2_str,I4,3,R8,8.0);
7976     VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
7977     VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
7978     VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
7979     VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
7980     VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
7981     VARPOW(BSTR,num2_str,I1,3,R8,8.0);
7982     VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
7983     VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
7984     VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
7985     if (has_i8)
7986     {
7987         VARPOW(BSTR,num2_str,I8,3,R8,8.0);
7988         VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
7989     }
7990     VARPOW(BSTR,num2_str,INT,3,R8,8.0);
7991     VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
7992     VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
7993     VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7994     VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
7995     VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
7996     VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
7997     VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
7998     VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
7999     VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
8000     VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
8001     VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
8002     VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
8003     VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
8004     VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
8005     if (has_i8)
8006     {
8007         VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
8008         VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
8009     }
8010     VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
8011     VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
8012     VARPOW(I1,2,EMPTY,0,R8,1.0);
8013     VARPOW(I1,2,NULL,0,NULL,0);
8014     VARPOW(I1,2,I2,3,R8,8.0);
8015     VARPOW(I1,2,I4,3,R8,8.0);
8016     VARPOW(I1,2,R4,3.0f,R8,8.0);
8017     VARPOW(I1,2,R8,3.0,R8,8.0);
8018     VARPOW(I1,2,DATE,3,R8,8.0);
8019     VARPOW(I1,2,BSTR,num3_str,R8,8.0);
8020     VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
8021     VARPOW(I1,2,I1,3,R8,8.0);
8022     VARPOW(I1,2,UI1,3,R8,8.0);
8023     VARPOW(I1,2,UI2,3,R8,8.0);
8024     VARPOW(I1,2,UI4,3,R8,8.0);
8025     if (has_i8)
8026     {
8027         VARPOW(I1,2,I8,3,R8,8.0);
8028         VARPOW(I1,2,UI8,3,R8,8.0);
8029     }
8030     VARPOW(I1,2,INT,3,R8,8.0);
8031     VARPOW(I1,2,UINT,3,R8,8.0);
8032     VARPOW(UI1,2,EMPTY,0,R8,1.0);
8033     VARPOW(UI1,2,NULL,0,NULL,0);
8034     VARPOW(UI1,2,I2,3,R8,8.0);
8035     VARPOW(UI1,2,I4,3,R8,8.0);
8036     VARPOW(UI1,2,R4,3.0f,R8,8.0);
8037     VARPOW(UI1,2,R8,3.0,R8,8.0);
8038     VARPOW(UI1,2,DATE,3,R8,8.0);
8039     VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
8040     VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
8041     VARPOW(UI1,2,I1,3,R8,8.0);
8042     VARPOW(UI1,2,UI1,3,R8,8.0);
8043     VARPOW(UI1,2,UI2,3,R8,8.0);
8044     VARPOW(UI1,2,UI4,3,R8,8.0);
8045     if (has_i8)
8046     {
8047         VARPOW(UI1,2,I8,3,R8,8.0);
8048         VARPOW(UI1,2,UI8,3,R8,8.0);
8049     }
8050     VARPOW(UI1,2,INT,3,R8,8.0);
8051     VARPOW(UI1,2,UINT,3,R8,8.0);
8052     VARPOW(UI2,2,EMPTY,0,R8,1.0);
8053     VARPOW(UI2,2,NULL,0,NULL,0);
8054     VARPOW(UI2,2,I2,3,R8,8.0);
8055     VARPOW(UI2,2,I4,3,R8,8.0);
8056     VARPOW(UI2,2,R4,3.0f,R8,8.0);
8057     VARPOW(UI2,2,R8,3.0,R8,8.0);
8058     VARPOW(UI2,2,DATE,3,R8,8.0);
8059     VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
8060     VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
8061     VARPOW(UI2,2,I1,3,R8,8.0);
8062     VARPOW(UI2,2,UI1,3,R8,8.0);
8063     VARPOW(UI2,2,UI2,3,R8,8.0);
8064     VARPOW(UI2,2,UI4,3,R8,8.0);
8065     if (has_i8)
8066     {
8067         VARPOW(UI2,2,I8,3,R8,8.0);
8068         VARPOW(UI2,2,UI8,3,R8,8.0);
8069     }
8070     VARPOW(UI2,2,INT,3,R8,8.0);
8071     VARPOW(UI2,2,UINT,3,R8,8.0);
8072     VARPOW(UI4,2,EMPTY,0,R8,1.0);
8073     VARPOW(UI4,2,NULL,0,NULL,0);
8074     VARPOW(UI4,2,I2,3,R8,8.0);
8075     VARPOW(UI4,2,I4,3,R8,8.0);
8076     VARPOW(UI4,2,R4,3.0f,R8,8.0);
8077     VARPOW(UI4,2,R8,3.0,R8,8.0);
8078     VARPOW(UI4,2,DATE,3,R8,8.0);
8079     VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
8080     VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
8081     VARPOW(UI4,2,I1,3,R8,8.0);
8082     VARPOW(UI4,2,UI1,3,R8,8.0);
8083     VARPOW(UI4,2,UI2,3,R8,8.0);
8084     VARPOW(UI4,2,UI4,3,R8,8.0);
8085     if (has_i8)
8086     {
8087         VARPOW(UI4,2,I8,3,R8,8.0);
8088         VARPOW(UI4,2,UI8,3,R8,8.0);
8089     }
8090     VARPOW(UI4,2,INT,3,R8,8.0);
8091     VARPOW(UI4,2,UINT,3,R8,8.0);
8092     if (has_i8)
8093     {
8094         VARPOW(I8,2,EMPTY,0,R8,1.0);
8095         VARPOW(I8,2,NULL,0,NULL,0);
8096         VARPOW(I8,2,I2,3,R8,8.0);
8097         VARPOW(I8,2,I4,3,R8,8.0);
8098         VARPOW(I8,2,R4,3.0f,R8,8.0);
8099         VARPOW(I8,2,R8,3.0,R8,8.0);
8100         VARPOW(I8,2,DATE,3,R8,8.0);
8101         VARPOW(I8,2,BSTR,num3_str,R8,8.0);
8102         VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
8103         VARPOW(I8,2,I1,3,R8,8.0);
8104         VARPOW(I8,2,UI1,3,R8,8.0);
8105         VARPOW(I8,2,UI2,3,R8,8.0);
8106         VARPOW(I8,2,UI4,3,R8,8.0);
8107         VARPOW(I8,2,I8,3,R8,8.0);
8108         VARPOW(I8,2,UI8,3,R8,8.0);
8109         VARPOW(I8,2,INT,3,R8,8.0);
8110         VARPOW(I8,2,UINT,3,R8,8.0);
8111         VARPOW(UI8,2,EMPTY,0,R8,1.0);
8112         VARPOW(UI8,2,NULL,0,NULL,0);
8113         VARPOW(UI8,2,I2,3,R8,8.0);
8114         VARPOW(UI8,2,I4,3,R8,8.0);
8115         VARPOW(UI8,2,R4,3.0f,R8,8.0);
8116         VARPOW(UI8,2,R8,3.0,R8,8.0);
8117         VARPOW(UI8,2,DATE,3,R8,8.0);
8118         VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
8119         VARPOW(UI8,2,I1,3,R8,8.0);
8120         VARPOW(UI8,2,UI1,3,R8,8.0);
8121         VARPOW(UI8,2,UI2,3,R8,8.0);
8122         VARPOW(UI8,2,UI4,3,R8,8.0);
8123         VARPOW(UI8,2,I8,3,R8,8.0);
8124         VARPOW(UI8,2,UI8,3,R8,8.0);
8125         VARPOW(UI8,2,INT,3,R8,8.0);
8126         VARPOW(UI8,2,UINT,3,R8,8.0);
8127     }
8128     VARPOW(INT,2,EMPTY,0,R8,1.0);
8129     VARPOW(INT,2,NULL,0,NULL,0);
8130     VARPOW(INT,2,I2,3,R8,8.0);
8131     VARPOW(INT,2,I4,3,R8,8.0);
8132     VARPOW(INT,2,R4,3.0f,R8,8.0);
8133     VARPOW(INT,2,R8,3.0,R8,8.0);
8134     VARPOW(INT,2,DATE,3,R8,8.0);
8135     VARPOW(INT,2,BSTR,num3_str,R8,8.0);
8136     VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
8137     VARPOW(INT,2,I1,3,R8,8.0);
8138     VARPOW(INT,2,UI1,3,R8,8.0);
8139     VARPOW(INT,2,UI2,3,R8,8.0);
8140     VARPOW(INT,2,UI4,3,R8,8.0);
8141     if (has_i8)
8142     {
8143         VARPOW(INT,2,I8,3,R8,8.0);
8144         VARPOW(INT,2,UI8,3,R8,8.0);
8145     }
8146     VARPOW(INT,2,INT,3,R8,8.0);
8147     VARPOW(INT,2,UINT,3,R8,8.0);
8148     VARPOW(UINT,2,EMPTY,0,R8,1.0);
8149     VARPOW(UINT,2,NULL,0,NULL,0);
8150     VARPOW(UINT,2,I2,3,R8,8.0);
8151     VARPOW(UINT,2,I4,3,R8,8.0);
8152     VARPOW(UINT,2,R4,3.0f,R8,8.0);
8153     VARPOW(UINT,2,R8,3.0,R8,8.0);
8154     VARPOW(UINT,2,DATE,3,R8,8.0);
8155     VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
8156     VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
8157     VARPOW(UINT,2,I1,3,R8,8.0);
8158     VARPOW(UINT,2,UI1,3,R8,8.0);
8159     VARPOW(UINT,2,UI2,3,R8,8.0);
8160     VARPOW(UINT,2,UI4,3,R8,8.0);
8161     if (has_i8)
8162     {
8163         VARPOW(UINT,2,I8,3,R8,8.0);
8164         VARPOW(UINT,2,UI8,3,R8,8.0);
8165     }
8166     VARPOW(UINT,2,INT,3,R8,8.0);
8167     VARPOW(UINT,2,UINT,3,R8,8.0);
8168
8169     /* Manually test some VT_CY, VT_DECIMAL variants */
8170     V_VT(&cy) = VT_CY;
8171     hres = VarCyFromI4(2, &V_CY(&cy));
8172     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8173     V_VT(&dec) = VT_DECIMAL;
8174     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8175     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8176     memset(&left, 0, sizeof(left));
8177     memset(&right, 0, sizeof(right));
8178     V_VT(&left) = VT_I4;
8179     V_I4(&left) = 100;
8180     V_VT(&right) = VT_I8;
8181     V_UI1(&right) = 2;
8182
8183     hres = pVarPow(&cy, &cy, &result);
8184     ok(hres == S_OK && V_VT(&result) == VT_R8,
8185         "VARPOW: expected coerced hres 0x%lX type VT_R8, got hres 0x%lX type %s!\n",
8186         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
8187     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
8188         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
8189
8190     hres = pVarPow(&cy, &right, &result);
8191     if (hres == S_OK)
8192     {
8193         ok(V_VT(&result) == VT_R8,
8194            "VARPOW: expected coerced hres 0x%lX type VT_R8, got hres 0x%lX type %s!\n",
8195            S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
8196         ok(EQ_DOUBLE(V_R8(&result), 4.0),
8197            "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
8198     }
8199     else
8200     {
8201         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
8202            "VARPOW: expected coerced hres 0x%lX type VT_EMPTY, got hres 0x%lX type %s!\n",
8203            DISP_E_BADVARTYPE, hres, wine_dbgstr_vt(V_VT(&result)));
8204     }
8205
8206     hres = pVarPow(&left, &cy, &result);
8207     ok(hres == S_OK && V_VT(&result) == VT_R8,
8208         "VARPOW: expected coerced hres 0x%lX type VT_R8, got hres 0x%lX type %s!\n",
8209         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
8210     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
8211         "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
8212
8213     hres = pVarPow(&left, &dec, &result);
8214     ok(hres == S_OK && V_VT(&result) == VT_R8,
8215         "VARPOW: expected coerced hres 0x%lX type VT_R8, got hres 0x%lX type %s!\n",
8216         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
8217     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
8218         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
8219
8220     hres = pVarPow(&dec, &dec, &result);
8221     ok(hres == S_OK && V_VT(&result) == VT_R8,
8222         "VARPOW: expected coerced hres 0x%lX type VT_R8, got hres 0x%lX type %s!\n",
8223         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
8224     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
8225         "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
8226
8227     hres = pVarPow(&dec, &right, &result);
8228     if (hres == S_OK)
8229     {
8230         ok(V_VT(&result) == VT_R8,
8231            "VARPOW: expected coerced hres 0x%lX type VT_R8, got hres 0x%lX type %s!\n",
8232            S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
8233         ok(EQ_DOUBLE(V_R8(&result), 4.0),
8234            "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
8235     }
8236     else
8237     {
8238         ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
8239            "VARPOW: expected coerced hres 0x%lX type VT_EMPTY, got hres 0x%lX type %s!\n",
8240            DISP_E_BADVARTYPE, hres, wine_dbgstr_vt(V_VT(&result)));
8241     }
8242
8243     SysFreeString(num2_str);
8244     SysFreeString(num3_str);
8245 }
8246
8247 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
8248
8249 #define VARDIV(vt1,val1,vt2,val2,rvt,rval)               \
8250         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
8251         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8252         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
8253         test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
8254
8255 /* Skip any type that is not defined or produces an error for every case */
8256 #define SKIPTESTDIV(a)                            \
8257     if (a == VT_ERROR || a == VT_VARIANT ||       \
8258         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
8259         a == VT_RECORD || a > VT_UINT ||          \
8260         a == VT_I1 || a == VT_UI8 ||              \
8261         a == VT_INT || a == VT_UINT ||            \
8262         a == VT_UI2 || a == VT_UI4 ||             \
8263         a == 15 /*not defined*/)                  \
8264         continue
8265
8266 static void test_VarDiv(void)
8267 {
8268     static const WCHAR str1[] = { '1','\0' };
8269     static const WCHAR str2[] = { '2','\0' };
8270     VARIANT left, right, exp, result, cy, dec;
8271     BSTR num1_str, num2_str;
8272     VARTYPE i;
8273     HRESULT hres;
8274     double r;
8275
8276     CHECKPTR(VarDiv);
8277
8278     num1_str = SysAllocString(str1);
8279     num2_str = SysAllocString(str2);
8280
8281     /* Test all possible flag/vt combinations & the resulting vt type */
8282     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
8283     {
8284         VARTYPE leftvt, rightvt, resvt;
8285
8286         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8287         {
8288             SKIPTESTDIV(leftvt);
8289
8290             /* Check if we need/have support for I8 */
8291             if (leftvt == VT_I8 && !has_i8)
8292                 continue;
8293
8294             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8295             {
8296                 BOOL bFail = FALSE;
8297                 SKIPTESTDIV(rightvt);
8298
8299                 /* Check if we need/have support for I8 */
8300                 if (rightvt == VT_I8 && !has_i8)
8301                     continue;
8302
8303                 /* Native crashes with VT_BYREF */
8304                 if (ExtraFlags[i] == VT_BYREF)
8305                     continue;
8306
8307                 memset(&left, 0, sizeof(left));
8308                 memset(&right, 0, sizeof(right));
8309                 V_VT(&left) = leftvt | ExtraFlags[i];
8310                 V_VT(&right) = rightvt | ExtraFlags[i];
8311                 V_VT(&result) = VT_EMPTY;
8312                 resvt = VT_EMPTY;
8313
8314                 if (leftvt == VT_BSTR)
8315                     V_BSTR(&left) = num2_str;
8316                 else if (leftvt == VT_DECIMAL)
8317                 {
8318                     VarDecFromR8(2.0, &V_DECIMAL(&left));
8319                     V_VT(&left) = leftvt | ExtraFlags[i];
8320                 }
8321
8322                 /* Division by 0 is undefined */
8323                 switch(rightvt)
8324                 {
8325                 case VT_BSTR:
8326                     V_BSTR(&right) = num2_str;
8327                     break;
8328                 case VT_DECIMAL:
8329                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8330                     V_VT(&right) = rightvt | ExtraFlags[i];
8331                     break;
8332                 case VT_BOOL:
8333                     V_BOOL(&right) = VARIANT_TRUE;
8334                     break;
8335                 case VT_I2: V_I2(&right) = 2; break;
8336                 case VT_I4: V_I4(&right) = 2; break;
8337                 case VT_R4: V_R4(&right) = 2.0f; break;
8338                 case VT_R8: V_R8(&right) = 2.0; break;
8339                 case VT_CY: V_CY(&right).int64 = 2; break;
8340                 case VT_DATE: V_DATE(&right) = 2; break;
8341                 case VT_UI1: V_UI1(&right) = 2; break;
8342                 case VT_I8: V_I8(&right) = 2; break;
8343                 default: break;
8344                 }
8345
8346                 /* Determine return type */
8347                 if (rightvt != VT_EMPTY)
8348                 {
8349                     if (leftvt == VT_NULL || rightvt == VT_NULL)
8350                         resvt = VT_NULL;
8351                     else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
8352                         resvt = VT_DECIMAL;
8353                     else if (leftvt == VT_I8 || rightvt == VT_I8 ||
8354                         leftvt == VT_CY || rightvt == VT_CY ||
8355                         leftvt == VT_DATE || rightvt == VT_DATE ||
8356                         leftvt == VT_I4 || rightvt == VT_I4 ||
8357                         leftvt == VT_BSTR || rightvt == VT_BSTR ||
8358                         leftvt == VT_I2 || rightvt == VT_I2 ||
8359                         leftvt == VT_BOOL || rightvt == VT_BOOL ||
8360                         leftvt == VT_R8 || rightvt == VT_R8 ||
8361                         leftvt == VT_UI1 || rightvt == VT_UI1)
8362                     {
8363                         if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
8364                             (leftvt == VT_R4 && rightvt == VT_UI1))
8365                             resvt = VT_R4;
8366                         else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
8367                             rightvt == VT_I2)) || (rightvt == VT_R4 &&
8368                             (leftvt == VT_BOOL || leftvt == VT_I2)))
8369                             resvt = VT_R4;
8370                         else
8371                             resvt = VT_R8;
8372                     }
8373                     else if (leftvt == VT_R4 || rightvt == VT_R4)
8374                         resvt = VT_R4;
8375                 }
8376                 else if (leftvt == VT_NULL)
8377                     resvt = VT_NULL;
8378                 else
8379                     bFail = TRUE;
8380
8381                 /* Native VarDiv always returns an error when using extra flags */
8382                 if (ExtraFlags[i] != 0)
8383                     bFail = TRUE;
8384
8385                 hres = pVarDiv(&left, &right, &result);
8386
8387                 /* Check expected HRESULT and if result variant type is correct */
8388                 if (bFail)
8389                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
8390                         hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
8391                         "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%lX\n",
8392                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i],
8393                         wine_dbgstr_vt(V_VT(&result)), hres);
8394                 else
8395                     ok (hres == S_OK && resvt == V_VT(&result),
8396                         "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%lX, got vt %s hr 0x%lX\n",
8397                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i], wine_dbgstr_vt(resvt),
8398                         S_OK, wine_dbgstr_vt(V_VT(&result)), hres);
8399             }
8400         }
8401     }
8402
8403     /* Test return values for all the good cases */
8404     VARDIV(EMPTY,0,NULL,0,NULL,0);
8405     VARDIV(EMPTY,0,I2,2,R8,0.0);
8406     VARDIV(EMPTY,0,I4,2,R8,0.0);
8407     VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
8408     VARDIV(EMPTY,0,R8,2.0,R8,0.0);
8409     VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
8410     VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
8411     VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
8412     VARDIV(EMPTY,0,UI1,2,R8,0.0);
8413     if (has_i8)
8414     {
8415         VARDIV(EMPTY,0,I8,2,R8,0.0);
8416     }
8417     VARDIV(NULL,0,EMPTY,0,NULL,0);
8418     VARDIV(NULL,0,NULL,0,NULL,0);
8419     VARDIV(NULL,0,I2,2,NULL,0);
8420     VARDIV(NULL,0,I4,2,NULL,0);
8421     VARDIV(NULL,0,R4,2.0f,NULL,0);
8422     VARDIV(NULL,0,R8,2.0,NULL,0);
8423     VARDIV(NULL,0,DATE,2,NULL,0);
8424     VARDIV(NULL,0,BSTR,num2_str,NULL,0);
8425     VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
8426     VARDIV(NULL,0,UI1,2,NULL,0);
8427     if (has_i8)
8428     {
8429         VARDIV(NULL,0,I8,2,NULL,0);
8430     }
8431     VARDIV(I2,2,NULL,0,NULL,0);
8432     VARDIV(I2,1,I2,2,R8,0.5);
8433     VARDIV(I2,1,I4,2,R8,0.5);
8434     VARDIV(I2,1,R4,2,R4,0.5f);
8435     VARDIV(I2,1,R8,2.0,R8,0.5);
8436     VARDIV(I2,1,DATE,2,R8,0.5);
8437     VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
8438     VARDIV(I2,1,UI1,2,R8,0.5);
8439     if (has_i8)
8440     {
8441         VARDIV(I2,1,I8,2,R8,0.5);
8442     }
8443     VARDIV(I4,1,NULL,0,NULL,0);
8444     VARDIV(I4,1,I2,2,R8,0.5);
8445     VARDIV(I4,1,I4,2,R8,0.5);
8446     VARDIV(I4,1,R4,2.0f,R8,0.5);
8447     VARDIV(I4,1,R8,2.0,R8,0.5);
8448     VARDIV(I4,1,DATE,2,R8,0.5);
8449     VARDIV(I4,1,BSTR,num2_str,R8,0.5);
8450     VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
8451     VARDIV(I4,1,UI1,2,R8,0.5);
8452     if (has_i8)
8453     {
8454         VARDIV(I4,1,I8,2,R8,0.5);
8455     }
8456     VARDIV(R4,1.0f,NULL,0,NULL,0);
8457     VARDIV(R4,1.0f,I2,2,R4,0.5f);
8458     VARDIV(R4,1.0f,I4,2,R8,0.5);
8459     VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
8460     VARDIV(R4,1.0f,R8,2.0,R8,0.5);
8461     VARDIV(R4,1.0f,DATE,2,R8,0.5);
8462     VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
8463     VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
8464     VARDIV(R4,1.0f,UI1,2,R4,0.5f);
8465     if (has_i8)
8466     {
8467         VARDIV(R4,1.0f,I8,2,R8,0.5);
8468     }
8469     VARDIV(R8,1.0,NULL,0,NULL,0);
8470     VARDIV(R8,1.0,I2,2,R8,0.5);
8471     VARDIV(R8,1.0,I4,2,R8,0.5);
8472     VARDIV(R8,1.0,R4,2.0f,R8,0.5);
8473     VARDIV(R8,1.0,R8,2.0,R8,0.5);
8474     VARDIV(R8,1.0,DATE,2,R8,0.5);
8475     VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
8476     VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
8477     VARDIV(R8,1.0,UI1,2,R8,0.5);
8478     if (has_i8)
8479     {
8480         VARDIV(R8,1.0,I8,2,R8,0.5);
8481     }
8482     VARDIV(DATE,1,NULL,0,NULL,0);
8483     VARDIV(DATE,1,I2,2,R8,0.5);
8484     VARDIV(DATE,1,I4,2,R8,0.5);
8485     VARDIV(DATE,1,R4,2.0f,R8,0.5);
8486     VARDIV(DATE,1,R8,2.0,R8,0.5);
8487     VARDIV(DATE,1,DATE,2,R8,0.5);
8488     VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
8489     VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
8490     VARDIV(DATE,1,UI1,2,R8,0.5);
8491     if (has_i8)
8492     {
8493         VARDIV(DATE,1,I8,2,R8,0.5);
8494     }
8495     VARDIV(BSTR,num1_str,NULL,0,NULL,0);
8496     VARDIV(BSTR,num1_str,I2,2,R8,0.5);
8497     VARDIV(BSTR,num1_str,I4,2,R8,0.5);
8498     VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
8499     VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
8500     VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
8501     VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
8502     VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
8503     VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
8504     if (has_i8)
8505     {
8506         VARDIV(BSTR,num1_str,I8,2,R8,0.5);
8507     }
8508     VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8509     VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
8510     VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
8511     VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
8512     VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
8513     VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
8514     VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
8515     VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
8516     VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
8517     VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
8518     VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
8519     VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
8520     VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
8521     VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
8522     if (has_i8)
8523     {
8524         VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
8525     }
8526     VARDIV(UI1,1,NULL,0,NULL,0);
8527     VARDIV(UI1,1,I2,2,R8,0.5);
8528     VARDIV(UI1,1,I4,2,R8,0.5);
8529     VARDIV(UI1,1,R4,2.0f,R4,0.5f);
8530     VARDIV(UI1,1,R8,2.0,R8,0.5);
8531     VARDIV(UI1,1,DATE,2,R8,0.5);
8532     VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
8533     VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
8534     VARDIV(UI1,1,UI1,2,R8,0.5);
8535     if (has_i8)
8536     {
8537         VARDIV(UI1,1,I8,2,R8,0.5);
8538         VARDIV(I8,1,NULL,0,NULL,0);
8539         VARDIV(I8,1,I2,2,R8,0.5);
8540         VARDIV(I8,1,I4,2,R8,0.5);
8541         VARDIV(I8,1,R4,2.0f,R8,0.5);
8542         VARDIV(I8,1,R8,2.0,R8,0.5);
8543         VARDIV(I8,1,DATE,2,R8,0.5);
8544         VARDIV(I8,1,BSTR,num2_str,R8,0.5);
8545         VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
8546         VARDIV(I8,1,UI1,2,R8,0.5);
8547         VARDIV(I8,1,I8,2,R8,0.5);
8548     }
8549
8550     /* Manually test some VT_CY, VT_DECIMAL variants */
8551     V_VT(&cy) = VT_CY;
8552     hres = VarCyFromI4(10000, &V_CY(&cy));
8553     ok(hres == S_OK, "VarCyFromI4 failed!\n");
8554     V_VT(&dec) = VT_DECIMAL;
8555     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8556     ok(hres == S_OK, "VarDecFromR4 failed!\n");
8557     memset(&left, 0, sizeof(left));
8558     memset(&right, 0, sizeof(right));
8559     V_VT(&left) = VT_I4;
8560     V_I4(&left) = 100;
8561     V_VT(&right) = VT_UI1;
8562     V_UI1(&right) = 2;
8563
8564     hres = pVarDiv(&cy, &cy, &result);
8565     ok(hres == S_OK && V_VT(&result) == VT_R8,
8566         "VARDIV: expected coerced type VT_R8, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
8567     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
8568         "VARDIV: CY value %f, expected %f\n", V_R8(&result), 1.0);
8569
8570     hres = pVarDiv(&cy, &right, &result);
8571     ok(hres == S_OK && V_VT(&result) == VT_R8,
8572         "VARDIV: expected coerced type VT_R8, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
8573     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
8574         "VARDIV: CY value %f, expected %f\n", V_R8(&result), 5000.0);
8575
8576     hres = pVarDiv(&left, &cy, &result);
8577     ok(hres == S_OK && V_VT(&result) == VT_R8,
8578         "VARDIV: expected coerced type VT_R8, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
8579     ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
8580         "VARDIV: CY value %f, expected %f\n", V_R8(&result), 0.01);
8581
8582     hres = pVarDiv(&left, &dec, &result);
8583     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
8584         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
8585     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
8586     ok(hres == S_OK && EQ_DOUBLE(r, 50.0), "VARDIV: DECIMAL value %f, expected %f\n", r, 50.0);
8587
8588     hres = pVarDiv(&dec, &dec, &result);
8589     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
8590         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
8591     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
8592     ok(hres == S_OK && EQ_DOUBLE(r, 1.0), "VARDIV: DECIMAL value %f, expected %f\n", r, 1.0);
8593
8594     hres = pVarDiv(&dec, &right, &result);
8595     ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
8596         "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", wine_dbgstr_vt(V_VT(&result)));
8597     hres = VarR8FromDec(&V_DECIMAL(&result), &r);
8598     ok(hres == S_OK && EQ_DOUBLE(r, 1.0), "VARDIV: DECIMAL value %f, expected %f\n", r, 1.0);
8599
8600     /* Check for division by zero and overflow */
8601     V_VT(&left) = VT_R8;
8602     V_I4(&left) = 1;
8603     V_VT(&right) = VT_R8;
8604     V_I4(&right) = 0;
8605     hres = pVarDiv(&left, &right, &result);
8606     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8607         "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%lX\n", hres);
8608
8609     V_VT(&left) = VT_R8;
8610     V_I4(&left) = 0;
8611     V_VT(&right) = VT_R8;
8612     V_I4(&right) = 0;
8613     hres = pVarDiv(&left, &right, &result);
8614     ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
8615         "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%lX\n", hres);
8616
8617     SysFreeString(num1_str);
8618     SysFreeString(num2_str);
8619 }
8620
8621 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
8622
8623 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval)              \
8624         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
8625         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8626         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
8627         test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
8628
8629 /* Skip any type that is not defined or produces an error for every case */
8630 #define SKIPTESTIDIV(a)                           \
8631     if (a == VT_ERROR || a == VT_VARIANT ||       \
8632         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
8633         a == VT_RECORD || a > VT_UINT ||          \
8634         a == 15 /*not defined*/)                  \
8635         continue
8636
8637 static void test_VarIdiv(void)
8638 {
8639     VARIANT left, right, exp, result, cy, dec;
8640     BSTR num1_str, num2_str;
8641     VARTYPE i;
8642     HRESULT hres;
8643
8644     CHECKPTR(VarIdiv);
8645
8646     num1_str = SysAllocString(L"1");
8647     num2_str = SysAllocString(L"2");
8648
8649     /* Test all possible flag/vt combinations & the resulting vt type */
8650     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
8651     {
8652         VARTYPE leftvt, rightvt, resvt;
8653
8654         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8655         {
8656             SKIPTESTIDIV(leftvt);
8657
8658             /* Check if we need/have support for I8 and/or UI8 */
8659             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
8660                 continue;
8661
8662             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8663             {
8664                 BOOL bFail = FALSE;
8665                 SKIPTESTIDIV(rightvt);
8666
8667                 /* Native crashes with extra flag VT_BYREF */
8668                 if (ExtraFlags[i] == VT_BYREF)
8669                     continue;
8670
8671                 /* Check if we need/have support for I8 and/or UI8 */
8672                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
8673                     continue;
8674
8675                 memset(&left, 0, sizeof(left));
8676                 memset(&right, 0, sizeof(right));
8677                 V_VT(&left) = leftvt | ExtraFlags[i];
8678                 V_VT(&right) = rightvt | ExtraFlags[i];
8679                 V_VT(&result) = VT_EMPTY;
8680                 resvt = VT_EMPTY;
8681
8682                 if (leftvt == VT_BSTR)
8683                     V_BSTR(&left) = num2_str;
8684                 else if (leftvt == VT_DECIMAL)
8685                 {
8686                     VarDecFromR8(2.0, &V_DECIMAL(&left));
8687                     V_VT(&left) = leftvt | ExtraFlags[i];
8688                 }
8689
8690                 /* Division by 0 is undefined */
8691                 switch(rightvt)
8692                 {
8693                 case VT_BSTR:
8694                     V_BSTR(&right) = num2_str;
8695                     break;
8696                 case VT_DECIMAL:
8697                     VarDecFromR8(2.0, &V_DECIMAL(&right));
8698                     V_VT(&right) = rightvt | ExtraFlags[i];
8699                     break;
8700                 case VT_BOOL:
8701                     V_BOOL(&right) = VARIANT_TRUE;
8702                     break;
8703                 case VT_CY:
8704                     VarCyFromI4(10000, &V_CY(&right));
8705                     V_VT(&right) = rightvt | ExtraFlags[i];
8706                     break;
8707                 case VT_I2: V_I2(&right) = 2; break;
8708                 case VT_I4: V_I4(&right) = 2; break;
8709                 case VT_R4: V_R4(&right) = 2.0f; break;
8710                 case VT_R8: V_R8(&right) = 2.0; break;
8711                 case VT_DATE: V_DATE(&right) = 2; break;
8712                 case VT_I1: V_I1(&right) = 2; break;
8713                 case VT_UI1: V_UI1(&right) = 2; break;
8714                 case VT_UI2: V_UI2(&right) = 2; break;
8715                 case VT_UI4: V_UI4(&right) = 2; break;
8716                 case VT_I8: V_I8(&right) = 2; break;
8717                 case VT_UI8: V_UI8(&right) = 2; break;
8718                 case VT_INT: V_INT(&right) = 2; break;
8719                 case VT_UINT: V_UINT(&right) = 2; break;
8720                 default: break;
8721                 }
8722
8723                 /* Native VarIdiv always returns an error when using extra
8724                  * flags or if the variant combination is I8 and INT.
8725                  */
8726                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8727                     (leftvt == VT_INT && rightvt == VT_I8) ||
8728                     (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
8729                     ExtraFlags[i] != 0)
8730                     bFail = TRUE;
8731
8732                 /* Determine variant type */
8733                 else if (leftvt == VT_NULL || rightvt == VT_NULL)
8734                     resvt = VT_NULL;
8735                 else if (leftvt == VT_I8 || rightvt == VT_I8)
8736                     resvt = VT_I8;
8737                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8738                     leftvt == VT_INT || rightvt == VT_INT ||
8739                     leftvt == VT_UINT || rightvt == VT_UINT ||
8740                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
8741                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
8742                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
8743                     leftvt == VT_I1 || rightvt == VT_I1 ||
8744                     leftvt == VT_BSTR || rightvt == VT_BSTR ||
8745                     leftvt == VT_DATE || rightvt == VT_DATE ||
8746                     leftvt == VT_CY || rightvt == VT_CY ||
8747                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8748                     leftvt == VT_R8 || rightvt == VT_R8 ||
8749                     leftvt == VT_R4 || rightvt == VT_R4)
8750                     resvt = VT_I4;
8751                 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
8752                     leftvt == VT_BOOL || rightvt == VT_BOOL ||
8753                     leftvt == VT_EMPTY)
8754                     resvt = VT_I2;
8755                 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
8756                     resvt = VT_UI1;
8757                 else
8758                     bFail = TRUE;
8759
8760                 hres = pVarIdiv(&left, &right, &result);
8761
8762                 /* Check expected HRESULT and if result variant type is correct */
8763                 if (bFail)
8764                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
8765                         hres == DISP_E_DIVBYZERO,
8766                         "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%lX\n",
8767                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i],
8768                         wine_dbgstr_vt(V_VT(&result)), hres);
8769                 else
8770                     ok (hres == S_OK && resvt == V_VT(&result),
8771                         "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%lX, got vt %s hr 0x%lX\n",
8772                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i], wine_dbgstr_vt(resvt),
8773                         S_OK, wine_dbgstr_vt(V_VT(&result)), hres);
8774             }
8775         }
8776     }
8777
8778     /* Test return values for all the good cases */
8779     VARIDIV(EMPTY,0,NULL,0,NULL,0);
8780     VARIDIV(EMPTY,0,I2,1,I2,0);
8781     VARIDIV(EMPTY,0,I4,1,I4,0);
8782     VARIDIV(EMPTY,0,R4,1.0f,I4,0);
8783     VARIDIV(EMPTY,0,R8,1.0,I4,0);
8784     VARIDIV(EMPTY,0,DATE,1.0,I4,0);
8785     VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
8786     VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
8787     VARIDIV(EMPTY,0,I1,1,I4,0);
8788     VARIDIV(EMPTY,0,UI1,1,I2,0);
8789     VARIDIV(EMPTY,0,UI2,1,I4,0);
8790     VARIDIV(EMPTY,0,UI4,1,I4,0);
8791     if (has_i8)
8792     {
8793         VARIDIV(EMPTY,0,I8,1,I8,0);
8794         VARIDIV(EMPTY,0,UI8,1,I4,0);
8795     }
8796     VARIDIV(EMPTY,0,INT,1,I4,0);
8797     VARIDIV(EMPTY,0,UINT,1,I4,0);
8798     VARIDIV(NULL,0,EMPTY,0,NULL,0);
8799     VARIDIV(NULL,0,NULL,0,NULL,0);
8800     VARIDIV(NULL,0,I2,1,NULL,0);
8801     VARIDIV(NULL,0,I4,1,NULL,0);
8802     VARIDIV(NULL,0,R4,1,NULL,0);
8803     VARIDIV(NULL,0,R8,1,NULL,0);
8804     VARIDIV(NULL,0,DATE,1,NULL,0);
8805     VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
8806     VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
8807     VARIDIV(NULL,0,I1,1,NULL,0);
8808     VARIDIV(NULL,0,UI1,1,NULL,0);
8809     VARIDIV(NULL,0,UI2,1,NULL,0);
8810     VARIDIV(NULL,0,UI4,1,NULL,0);
8811     if (has_i8)
8812     {
8813         VARIDIV(NULL,0,I8,1,NULL,0);
8814         VARIDIV(NULL,0,UI8,1,NULL,0);
8815     }
8816     VARIDIV(NULL,0,INT,1,NULL,0);
8817     VARIDIV(NULL,0,UINT,1,NULL,0);
8818     VARIDIV(I2,2,NULL,0,NULL,0);
8819     VARIDIV(I2,2,I2,1,I2,2);
8820     VARIDIV(I2,2,I4,1,I4,2);
8821     VARIDIV(I2,2,R4,1,I4,2);
8822     VARIDIV(I2,2,R8,1,I4,2);
8823     VARIDIV(I2,2,DATE,1,I4,2);
8824     VARIDIV(I2,2,BSTR,num1_str,I4,2);
8825     VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
8826     VARIDIV(I2,2,I1,1,I4,2);
8827     VARIDIV(I2,2,UI1,1,I2,2);
8828     VARIDIV(I2,2,UI2,1,I4,2);
8829     VARIDIV(I2,2,UI4,1,I4,2);
8830     if (has_i8)
8831     {
8832         VARIDIV(I2,2,I8,1,I8,2);
8833         VARIDIV(I2,2,UI8,1,I4,2);
8834     }
8835     VARIDIV(I2,2,INT,1,I4,2);
8836     VARIDIV(I2,2,UINT,1,I4,2);
8837     VARIDIV(I4,2,NULL,0,NULL,0);
8838     VARIDIV(I4,2,I2,1,I4,2);
8839     VARIDIV(I4,2,I4,1,I4,2);
8840     VARIDIV(I4,2,R4,1,I4,2);
8841     VARIDIV(I4,2,R8,1,I4,2);
8842     VARIDIV(I4,2,DATE,1,I4,2);
8843     VARIDIV(I4,2,BSTR,num1_str,I4,2);
8844     VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
8845     VARIDIV(I4,2,I1,1,I4,2);
8846     VARIDIV(I4,2,UI1,1,I4,2);
8847     VARIDIV(I4,2,UI2,1,I4,2);
8848     VARIDIV(I4,2,UI4,1,I4,2);
8849     if (has_i8)
8850     {
8851         VARIDIV(I4,2,I8,1,I8,2);
8852         VARIDIV(I4,2,UI8,1,I4,2);
8853     }
8854     VARIDIV(I4,2,INT,1,I4,2);
8855     VARIDIV(I4,2,UINT,1,I4,2);
8856     VARIDIV(R4,2.0f,NULL,0,NULL,0);
8857     VARIDIV(R4,2.0f,I2,1,I4,2);
8858     VARIDIV(R4,2.0f,I4,1,I4,2);
8859     VARIDIV(R4,2.0f,R4,1.0f,I4,2);
8860     VARIDIV(R4,2.0f,R8,1.0,I4,2);
8861     VARIDIV(R4,2.0f,DATE,1,I4,2);
8862     VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
8863     VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
8864     VARIDIV(R4,2.0f,I1,1,I4,2);
8865     VARIDIV(R4,2.0f,UI1,1,I4,2);
8866     VARIDIV(R4,2.0f,UI2,1,I4,2);
8867     VARIDIV(R4,2.0f,UI4,1,I4,2);
8868     if (has_i8)
8869     {
8870         VARIDIV(R4,2.0f,I8,1,I8,2);
8871         VARIDIV(R4,2.0f,UI8,1,I4,2);
8872     }
8873     VARIDIV(R4,2.0f,INT,1,I4,2);
8874     VARIDIV(R4,2.0f,UINT,1,I4,2);
8875     VARIDIV(R8,2.0,NULL,0,NULL,0);
8876     VARIDIV(R8,2.0,I2,1,I4,2);
8877     VARIDIV(R8,2.0,I4,1,I4,2);
8878     VARIDIV(R8,2.0,R4,1,I4,2);
8879     VARIDIV(R8,2.0,R8,1,I4,2);
8880     VARIDIV(R8,2.0,DATE,1,I4,2);
8881     VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
8882     VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
8883     VARIDIV(R8,2.0,I1,1,I4,2);
8884     VARIDIV(R8,2.0,UI1,1,I4,2);
8885     VARIDIV(R8,2.0,UI2,1,I4,2);
8886     VARIDIV(R8,2.0,UI4,1,I4,2);
8887     if (has_i8)
8888     {
8889         VARIDIV(R8,2.0,I8,1,I8,2);
8890         VARIDIV(R8,2.0,UI8,1,I4,2);
8891     }
8892     VARIDIV(R8,2.0,INT,1,I4,2);
8893     VARIDIV(R8,2.0,UINT,1,I4,2);
8894     VARIDIV(DATE,2,NULL,0,NULL,0);
8895     VARIDIV(DATE,2,I2,1,I4,2);
8896     VARIDIV(DATE,2,I4,1,I4,2);
8897     VARIDIV(DATE,2,R4,1,I4,2);
8898     VARIDIV(DATE,2,R8,1,I4,2);
8899     VARIDIV(DATE,2,DATE,1,I4,2);
8900     VARIDIV(DATE,2,BSTR,num1_str,I4,2);
8901     VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
8902     VARIDIV(DATE,2,I1,1,I4,2);
8903     VARIDIV(DATE,2,UI1,1,I4,2);
8904     VARIDIV(DATE,2,UI2,1,I4,2);
8905     VARIDIV(DATE,2,UI4,1,I4,2);
8906     if (has_i8)
8907     {
8908         VARIDIV(DATE,2,I8,1,I8,2);
8909         VARIDIV(DATE,2,UI8,1,I4,2);
8910     }
8911     VARIDIV(DATE,2,INT,1,I4,2);
8912     VARIDIV(DATE,2,UINT,1,I4,2);
8913     VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
8914     VARIDIV(BSTR,num2_str,I2,1,I4,2);
8915     VARIDIV(BSTR,num2_str,I4,1,I4,2);
8916     VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
8917     VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
8918     VARIDIV(BSTR,num2_str,DATE,1,I4,2);
8919     VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
8920     VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
8921     VARIDIV(BSTR,num2_str,I1,1,I4,2);
8922     VARIDIV(BSTR,num2_str,UI1,1,I4,2);
8923     VARIDIV(BSTR,num2_str,UI2,1,I4,2);
8924     VARIDIV(BSTR,num2_str,UI4,1,I4,2);
8925     if (has_i8)
8926     {
8927         VARIDIV(BSTR,num2_str,I8,1,I8,2);
8928         VARIDIV(BSTR,num2_str,UI8,1,I4,2);
8929     }
8930     VARIDIV(BSTR,num2_str,INT,1,I4,2);
8931     VARIDIV(BSTR,num2_str,UINT,1,I4,2);
8932     VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8933     VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
8934     VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
8935     VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
8936     VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
8937     VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
8938     VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
8939     VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
8940     VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
8941     VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
8942     VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
8943     VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
8944     if (has_i8)
8945     {
8946         VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
8947         VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
8948     }
8949     VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
8950     VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
8951     VARIDIV(I1,2,NULL,0,NULL,0);
8952     VARIDIV(I1,2,I2,1,I4,2);
8953     VARIDIV(I1,2,I4,1,I4,2);
8954     VARIDIV(I1,2,R4,1.0f,I4,2);
8955     VARIDIV(I1,2,R8,1.0,I4,2);
8956     VARIDIV(I1,2,DATE,1,I4,2);
8957     VARIDIV(I1,2,BSTR,num1_str,I4,2);
8958     VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
8959     VARIDIV(I1,2,I1,1,I4,2);
8960     VARIDIV(I1,2,UI1,1,I4,2);
8961     VARIDIV(I1,2,UI2,1,I4,2);
8962     VARIDIV(I1,2,UI4,1,I4,2);
8963     if (has_i8)
8964     {
8965         VARIDIV(I1,2,I8,1,I8,2);
8966         VARIDIV(I1,2,UI8,1,I4,2);
8967     }
8968     VARIDIV(I1,2,INT,1,I4,2);
8969     VARIDIV(I1,2,UINT,1,I4,2);
8970     VARIDIV(UI1,2,NULL,0,NULL,0);
8971     VARIDIV(UI1,2,I2,1,I2,2);
8972     VARIDIV(UI1,2,I4,1,I4,2);
8973     VARIDIV(UI1,2,R4,1.0f,I4,2);
8974     VARIDIV(UI1,2,R8,1.0,I4,2);
8975     VARIDIV(UI1,2,DATE,1,I4,2);
8976     VARIDIV(UI1,2,BSTR,num1_str,I4,2);
8977     VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
8978     VARIDIV(UI1,2,I1,1,I4,2);
8979     VARIDIV(UI1,2,UI1,1,UI1,2);
8980     VARIDIV(UI1,2,UI2,1,I4,2);
8981     VARIDIV(UI1,2,UI4,1,I4,2);
8982     if (has_i8)
8983     {
8984         VARIDIV(UI1,2,I8,1,I8,2);
8985         VARIDIV(UI1,2,UI8,1,I4,2);
8986     }
8987     VARIDIV(UI1,2,INT,1,I4,2);
8988     VARIDIV(UI1,2,UINT,1,I4,2);
8989     VARIDIV(UI2,2,NULL,0,NULL,0);
8990     VARIDIV(UI2,2,I2,1,I4,2);
8991     VARIDIV(UI2,2,I4,1,I4,2);
8992     VARIDIV(UI2,2,R4,1.0f,I4,2);
8993     VARIDIV(UI2,2,R8,1.0,I4,2);
8994     VARIDIV(UI2,2,DATE,1,I4,2);
8995     VARIDIV(UI2,2,BSTR,num1_str,I4,2);
8996     VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
8997     VARIDIV(UI2,2,I1,1,I4,2);
8998     VARIDIV(UI2,2,UI1,1,I4,2);
8999     VARIDIV(UI2,2,UI2,1,I4,2);
9000     VARIDIV(UI2,2,UI4,1,I4,2);
9001     if (has_i8)
9002     {
9003         VARIDIV(UI2,2,I8,1,I8,2);
9004         VARIDIV(UI2,2,UI8,1,I4,2);
9005     }
9006     VARIDIV(UI2,2,INT,1,I4,2);
9007     VARIDIV(UI2,2,UINT,1,I4,2);
9008     VARIDIV(UI4,2,NULL,0,NULL,0);
9009     VARIDIV(UI4,2,I2,1,I4,2);
9010     VARIDIV(UI4,2,I4,1,I4,2);
9011     VARIDIV(UI4,2,R4,1.0f,I4,2);
9012     VARIDIV(UI4,2,R8,1.0,I4,2);
9013     VARIDIV(UI4,2,DATE,1,I4,2);
9014     VARIDIV(UI4,2,BSTR,num1_str,I4,2);
9015     VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
9016     VARIDIV(UI4,2,I1,1,I4,2);
9017     VARIDIV(UI4,2,UI1,1,I4,2);
9018     VARIDIV(UI4,2,UI2,1,I4,2);
9019     VARIDIV(UI4,2,UI4,1,I4,2);
9020     if (has_i8)
9021     {
9022         VARIDIV(UI4,2,I8,1,I8,2);
9023         VARIDIV(UI4,2,UI8,1,I4,2);
9024     }
9025     VARIDIV(UI4,2,INT,1,I4,2);
9026     VARIDIV(UI4,2,UINT,1,I4,2);
9027     if (has_i8)
9028     {
9029         VARIDIV(I8,2,NULL,0,NULL,0);
9030         VARIDIV(I8,2,I2,1,I8,2);
9031         VARIDIV(I8,2,I4,1,I8,2);
9032         VARIDIV(I8,2,R4,1.0f,I8,2);
9033         VARIDIV(I8,2,R8,1.0,I8,2);
9034         VARIDIV(I8,2,DATE,1,I8,2);
9035         VARIDIV(I8,2,BSTR,num1_str,I8,2);
9036         VARIDIV(I8,2,BOOL,1,I8,2);
9037         VARIDIV(I8,2,I1,1,I8,2);
9038         VARIDIV(I8,2,UI1,1,I8,2);
9039         VARIDIV(I8,2,UI2,1,I8,2);
9040         VARIDIV(I8,2,UI4,1,I8,2);
9041         VARIDIV(I8,2,I8,1,I8,2);
9042         VARIDIV(I8,2,UI8,1,I8,2);
9043         VARIDIV(I8,2,UINT,1,I8,2);
9044         VARIDIV(UI8,2,NULL,0,NULL,0);
9045         VARIDIV(UI8,2,I2,1,I4,2);
9046         VARIDIV(UI8,2,I4,1,I4,2);
9047         VARIDIV(UI8,2,R4,1.0f,I4,2);
9048         VARIDIV(UI8,2,R8,1.0,I4,2);
9049         VARIDIV(UI8,2,DATE,1,I4,2);
9050         VARIDIV(UI8,2,BSTR,num1_str,I4,2);
9051         VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
9052         VARIDIV(UI8,2,I1,1,I4,2);
9053         VARIDIV(UI8,2,UI1,1,I4,2);
9054         VARIDIV(UI8,2,UI2,1,I4,2);
9055         VARIDIV(UI8,2,UI4,1,I4,2);
9056         VARIDIV(UI8,2,I8,1,I8,2);
9057         VARIDIV(UI8,2,UI8,1,I4,2);
9058         VARIDIV(UI8,2,INT,1,I4,2);
9059         VARIDIV(UI8,2,UINT,1,I4,2);
9060     }
9061     VARIDIV(INT,2,NULL,0,NULL,0);
9062     VARIDIV(INT,2,I2,1,I4,2);
9063     VARIDIV(INT,2,I4,1,I4,2);
9064     VARIDIV(INT,2,R4,1.0f,I4,2);
9065     VARIDIV(INT,2,R8,1.0,I4,2);
9066     VARIDIV(INT,2,DATE,1,I4,2);
9067     VARIDIV(INT,2,BSTR,num1_str,I4,2);
9068     VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
9069     VARIDIV(INT,2,I1,1,I4,2);
9070     VARIDIV(INT,2,UI1,1,I4,2);
9071     VARIDIV(INT,2,UI2,1,I4,2);
9072     VARIDIV(INT,2,UI4,1,I4,2);
9073     if (has_i8)
9074     {
9075         VARIDIV(INT,2,UI8,1,I4,2);
9076     }
9077     VARIDIV(INT,2,INT,1,I4,2);
9078     VARIDIV(INT,2,UINT,1,I4,2);
9079     VARIDIV(UINT,2,NULL,0,NULL,0);
9080     VARIDIV(UINT,2,I2,1,I4,2);
9081     VARIDIV(UINT,2,I4,1,I4,2);
9082     VARIDIV(UINT,2,R4,1.0f,I4,2);
9083     VARIDIV(UINT,2,R8,1.0,I4,2);
9084     VARIDIV(UINT,2,DATE,1,I4,2);
9085     VARIDIV(UINT,2,BSTR,num1_str,I4,2);
9086     VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
9087     VARIDIV(UINT,2,I1,1,I4,2);
9088     VARIDIV(UINT,2,UI1,1,I4,2);
9089     VARIDIV(UINT,2,UI2,1,I4,2);
9090     VARIDIV(UINT,2,UI4,1,I4,2);
9091     if (has_i8)
9092     {
9093         VARIDIV(UINT,2,I8,1,I8,2);
9094         VARIDIV(UINT,2,UI8,1,I4,2);
9095     }
9096     VARIDIV(UINT,2,INT,1,I4,2);
9097     VARIDIV(UINT,2,UINT,1,I4,2);
9098
9099     /* Manually test some VT_CY, VT_DECIMAL variants */
9100     V_VT(&cy) = VT_CY;
9101     hres = VarCyFromI4(10000, &V_CY(&cy));
9102     ok(hres == S_OK, "VarCyFromI4 failed!\n");
9103     V_VT(&dec) = VT_DECIMAL;
9104     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
9105     ok(hres == S_OK, "VarDecFromR4 failed!\n");
9106     memset(&left, 0, sizeof(left));
9107     memset(&right, 0, sizeof(right));
9108     V_VT(&left) = VT_I4;
9109     V_I4(&left) = 100;
9110     V_VT(&right) = VT_I8;
9111     V_UI1(&right) = 2;
9112
9113     hres = pVarIdiv(&cy, &cy, &result);
9114     ok(hres == S_OK && V_VT(&result) == VT_I4,
9115         "VARIDIV: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9116         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9117     ok(hres == S_OK && V_I4(&result) == 1,
9118         "VARIDIV: CY value %ld, expected %d\n", V_I4(&result), 1);
9119
9120     if (has_i8)
9121     {
9122         hres = pVarIdiv(&cy, &right, &result);
9123         ok(hres == S_OK && V_VT(&result) == VT_I8,
9124             "VARIDIV: expected coerced hres 0x%lX type VT_I8, got hres 0x%lX type %s!\n",
9125             S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9126         ok(hres == S_OK && V_I8(&result) == 5000,
9127             "VARIDIV: CY value %#I64x, expected %#x\n",
9128             V_I8(&result), 5000);
9129     }
9130
9131     hres = pVarIdiv(&left, &cy, &result);
9132     ok(hres == S_OK && V_VT(&result) == VT_I4,
9133         "VARIDIV: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9134         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9135     ok(hres == S_OK && V_I4(&result) == 0,
9136         "VARIDIV: CY value %ld, expected %d\n", V_I4(&result), 0);
9137
9138     hres = pVarIdiv(&left, &dec, &result);
9139     ok(hres == S_OK && V_VT(&result) == VT_I4,
9140         "VARIDIV: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9141         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9142     ok(hres == S_OK && V_I4(&result) == 50,
9143         "VARIDIV: DECIMAL value %ld, expected %d\n", V_I4(&result), 50);
9144
9145     hres = pVarIdiv(&dec, &dec, &result);
9146     ok(hres == S_OK && V_VT(&result) == VT_I4,
9147         "VARIDIV: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9148         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9149     ok(hres == S_OK && V_I4(&result) == 1,
9150         "VARIDIV: DECIMAL value %ld, expected %d\n", V_I4(&result), 1);
9151
9152     if (has_i8)
9153     {
9154         hres = pVarIdiv(&dec, &right, &result);
9155         ok(hres == S_OK && V_VT(&result) == VT_I8,
9156             "VARIDIV: expected coerced hres 0x%lX type VT_I8, got hres 0x%lX type %s!\n",
9157             S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9158         ok(hres == S_OK && V_I8(&result) == 1,
9159             "VARIDIV: DECIMAL value %I64d, expected %d\n",
9160             V_I8(&result), 1);
9161     }
9162
9163     /* Check for division by zero */
9164     V_VT(&left) = VT_INT;
9165     V_I4(&left) = 1;
9166     V_VT(&right) = VT_INT;
9167     V_I4(&right) = 0;
9168     hres = pVarIdiv(&left, &right, &result);
9169     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
9170         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%lX\n", hres);
9171
9172     V_VT(&left) = VT_INT;
9173     V_I4(&left) = 0;
9174     V_VT(&right) = VT_INT;
9175     V_I4(&right) = 0;
9176     hres = pVarIdiv(&left, &right, &result);
9177     ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
9178         "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%lX\n", hres);
9179
9180     SysFreeString(num1_str);
9181     SysFreeString(num2_str);
9182 }
9183
9184
9185 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
9186
9187 #define VARIMP(vt1,val1,vt2,val2,rvt,rval)              \
9188         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
9189         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
9190         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
9191         test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
9192
9193 /* Skip any type that is not defined or produces an error for every case */
9194 #define SKIPTESTIMP(a)                            \
9195     if (a == VT_ERROR || a == VT_VARIANT ||       \
9196         a == VT_DISPATCH || a == VT_UNKNOWN ||    \
9197         a == VT_RECORD || a > VT_UINT ||          \
9198         a == 15 /*not defined*/)                  \
9199         continue
9200
9201 static void test_VarImp(void)
9202 {
9203     static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
9204     static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
9205     VARIANT left, right, exp, result, cy, dec;
9206     BSTR true_str, false_str;
9207     VARTYPE i;
9208     HRESULT hres;
9209
9210     CHECKPTR(VarImp);
9211
9212     true_str = SysAllocString(szTrue);
9213     false_str = SysAllocString(szFalse);
9214
9215     /* Test all possible flag/vt combinations & the resulting vt type */
9216     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
9217     {
9218         VARTYPE leftvt, rightvt, resvt;
9219
9220         for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
9221         {
9222             SKIPTESTIMP(leftvt);
9223
9224             /* Check if we need/have support for I8 and/or UI8 */
9225             if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
9226                 continue;
9227
9228             for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
9229             {
9230                 BOOL bFail = FALSE;
9231                 SKIPTESTIMP(rightvt);
9232
9233                 /* Native crashes when using the extra flag VT_BYREF
9234                  * or with the following VT combinations
9235                  */
9236                 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
9237                     (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
9238                     ExtraFlags[i] == VT_BYREF)
9239                     continue;
9240
9241                 /* Check if we need/have support for I8 and/or UI8 */
9242                 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
9243                     continue;
9244
9245                 memset(&left, 0, sizeof(left));
9246                 memset(&right, 0, sizeof(right));
9247                 V_VT(&left) = leftvt | ExtraFlags[i];
9248                 V_VT(&right) = rightvt | ExtraFlags[i];
9249                 V_VT(&result) = VT_EMPTY;
9250                 resvt = VT_EMPTY;
9251
9252                 if (leftvt == VT_BSTR)
9253                     V_BSTR(&left) = true_str;
9254
9255                 /* This allows us to test return types that are not NULL
9256                  * (NULL Imp value = n, NULL Imp 0 = NULL)
9257                  */
9258                 switch(rightvt)
9259                 {
9260                 case VT_BSTR:
9261                     V_BSTR(&right) = true_str;
9262                     break;
9263                 case VT_DECIMAL:
9264                     VarDecFromR8(2.0, &V_DECIMAL(&right));
9265                     V_VT(&right) = rightvt | ExtraFlags[i];
9266                     break;
9267                 case VT_BOOL:
9268                     V_BOOL(&right) = VARIANT_TRUE;
9269                     break;
9270                 case VT_I1: V_I1(&right) = 2; break;
9271                 case VT_I2: V_I2(&right) = 2; break;
9272                 case VT_I4: V_I4(&right) = 2; break;
9273                 case VT_R4: V_R4(&right) = 2.0f; break;
9274                 case VT_R8: V_R8(&right) = 2.0; break;
9275                 case VT_CY: V_CY(&right).int64 = 10000; break;
9276                 case VT_DATE: V_DATE(&right) = 2; break;
9277                 case VT_I8: V_I8(&right) = 2; break;
9278                 case VT_INT: V_INT(&right) = 2; break;
9279                 case VT_UINT: V_UINT(&right) = 2; break;
9280                 case VT_UI1: V_UI1(&right) = 2; break;
9281                 case VT_UI2: V_UI2(&right) = 2; break;
9282                 case VT_UI4: V_UI4(&right) = 2; break;
9283                 case VT_UI8: V_UI8(&right) = 2; break;
9284                 default: break;
9285                 }
9286
9287                 /* Native VarImp always returns an error when using extra
9288                  * flags or if the variants are I8 and INT.
9289                  */
9290                 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
9291                     ExtraFlags[i] != 0)
9292                     bFail = TRUE;
9293
9294                 /* Determine result type */
9295                 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
9296                     (leftvt == VT_NULL && rightvt == VT_NULL) ||
9297                     (leftvt == VT_NULL && rightvt == VT_EMPTY))
9298                     resvt = VT_NULL;
9299                 else if (leftvt == VT_I8 || rightvt == VT_I8)
9300                     resvt = VT_I8;
9301                 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
9302                     leftvt == VT_INT || rightvt == VT_INT ||
9303                     leftvt == VT_UINT || rightvt == VT_UINT ||
9304                     leftvt == VT_UI4 || rightvt == VT_UI4 ||
9305                     leftvt == VT_UI8 || rightvt == VT_UI8 ||
9306                     leftvt == VT_UI2 || rightvt == VT_UI2 ||
9307                     leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
9308                     leftvt == VT_DATE || rightvt == VT_DATE ||
9309                     leftvt == VT_CY || rightvt == VT_CY ||
9310                     leftvt == VT_R8 || rightvt == VT_R8 ||
9311                     leftvt == VT_R4 || rightvt == VT_R4 ||
9312                     leftvt == VT_I1 || rightvt == VT_I1)
9313                     resvt = VT_I4;
9314                 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
9315                     (leftvt == VT_UI1 && rightvt == VT_NULL) ||
9316                     (leftvt == VT_NULL && rightvt == VT_UI1))
9317                     resvt = VT_UI1;
9318                 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
9319                     leftvt == VT_I2 || rightvt == VT_I2 ||
9320                     leftvt == VT_UI1 || rightvt == VT_UI1)
9321                     resvt = VT_I2;
9322                 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
9323                     leftvt == VT_BSTR || rightvt == VT_BSTR)
9324                     resvt = VT_BOOL;
9325
9326                 hres = pVarImp(&left, &right, &result);
9327
9328                 /* Check expected HRESULT and if result variant type is correct */
9329                 if (bFail)
9330                     ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
9331                         "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%lX\n",
9332                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i],
9333                         wine_dbgstr_vt(V_VT(&result)), hres);
9334                 else
9335                     ok (hres == S_OK && resvt == V_VT(&result),
9336                         "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%lX, got vt %s hr 0x%lX\n",
9337                         wine_dbgstr_vt(leftvt), ExtraFlags[i], wine_dbgstr_vt(rightvt), ExtraFlags[i], wine_dbgstr_vt(resvt),
9338                         S_OK, wine_dbgstr_vt(V_VT(&result)), hres);
9339             }
9340         }
9341     }
9342
9343     VARIMP(EMPTY,0,EMPTY,0,I2,-1);
9344     VARIMP(EMPTY,0,NULL,0,I2,-1);
9345     VARIMP(EMPTY,0,I2,-1,I2,-1);
9346     VARIMP(EMPTY,0,I4,-1,I4,-1);
9347     VARIMP(EMPTY,0,R4,0.0f,I4,-1);
9348     VARIMP(EMPTY,0,R8,-1.0,I4,-1);
9349     VARIMP(EMPTY,0,DATE,0,I4,-1);
9350     VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
9351     VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
9352     VARIMP(EMPTY,0,I1,0,I4,-1);
9353     VARIMP(EMPTY,0,UI1,1,I2,-1);
9354     VARIMP(EMPTY,0,UI2,1,I4,-1);
9355     VARIMP(EMPTY,0,UI4,1,I4,-1);
9356     if (has_i8)
9357     {
9358         VARIMP(EMPTY,0,I8,1,I8,-1);
9359         VARIMP(EMPTY,0,UI8,1,I4,-1);
9360     }
9361     VARIMP(EMPTY,0,INT,-1,I4,-1);
9362     VARIMP(EMPTY,0,UINT,1,I4,-1);
9363     VARIMP(NULL,0,EMPTY,0,NULL,0);
9364     VARIMP(NULL,0,NULL,0,NULL,0);
9365     VARIMP(NULL,0,I2,-1,I2,-1);
9366     VARIMP(NULL,0,I4,-1,I4,-1);
9367     VARIMP(NULL,0,R4,0.0f,NULL,0);
9368     VARIMP(NULL,0,R8,-1.0,I4,-1);
9369     VARIMP(NULL,0,DATE,0,NULL,0);
9370     VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
9371     VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
9372     VARIMP(NULL,0,I1,0,NULL,0);
9373     VARIMP(NULL,0,UI1,1,UI1,1);
9374     VARIMP(NULL,0,UI2,1,I4,1);
9375     VARIMP(NULL,0,UI4,1,I4,1);
9376     if (has_i8)
9377     {
9378         VARIMP(NULL,0,I8,1,I8,1);
9379         VARIMP(NULL,0,UI8,1,I4,1);
9380     }
9381     VARIMP(NULL,0,INT,-1,I4,-1);
9382     VARIMP(NULL,0,UINT,1,I4,1);
9383     VARIMP(I2,-1,EMPTY,0,I2,0);
9384     VARIMP(I2,-1,I2,-1,I2,-1);
9385     VARIMP(I2,-1,I4,-1,I4,-1);
9386     VARIMP(I2,-1,R4,0.0f,I4,0);
9387     VARIMP(I2,-1,R8,-1.0,I4,-1);
9388     VARIMP(I2,-1,DATE,0,I4,0);
9389     VARIMP(I2,-1,BSTR,true_str,I2,-1);
9390     VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
9391     VARIMP(I2,-1,I1,0,I4,0);
9392     VARIMP(I2,-1,UI1,1,I2,1);
9393     VARIMP(I2,-1,UI2,1,I4,1);
9394     VARIMP(I2,-1,UI4,1,I4,1);
9395     if (has_i8)
9396     {
9397         VARIMP(I2,-1,I8,1,I8,1);
9398         VARIMP(I2,-1,UI8,1,I4,1);
9399     }
9400     VARIMP(I2,-1,INT,-1,I4,-1);
9401     VARIMP(I2,-1,UINT,1,I4,1);
9402     VARIMP(I4,2,EMPTY,0,I4,-3);
9403     VARIMP(I4,2,NULL,0,I4,-3);
9404     VARIMP(I4,2,I2,-1,I4,-1);
9405     VARIMP(I4,2,I4,-1,I4,-1);
9406     VARIMP(I4,2,R4,0.0f,I4,-3);
9407     VARIMP(I4,2,R8,-1.0,I4,-1);
9408     VARIMP(I4,2,DATE,0,I4,-3);
9409     VARIMP(I4,2,BSTR,true_str,I4,-1);
9410     VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
9411     VARIMP(I4,2,I1,0,I4,-3);
9412     VARIMP(I4,2,UI1,1,I4,-3);
9413     VARIMP(I4,2,UI2,1,I4,-3);
9414     VARIMP(I4,2,UI4,1,I4,-3);
9415     if (has_i8)
9416     {
9417         VARIMP(I4,2,I8,1,I8,-3);
9418         VARIMP(I4,2,UI8,1,I4,-3);
9419     }
9420     VARIMP(I4,2,INT,-1,I4,-1);
9421     VARIMP(I4,2,UINT,1,I4,-3);
9422     VARIMP(R4,-1.0f,EMPTY,0,I4,0);
9423     VARIMP(R4,-1.0f,NULL,0,NULL,0);
9424     VARIMP(R4,-1.0f,I2,-1,I4,-1);
9425     VARIMP(R4,-1.0f,I4,-1,I4,-1);
9426     VARIMP(R4,-1.0f,R4,0.0f,I4,0);
9427     VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
9428     VARIMP(R4,-1.0f,DATE,1,I4,1);
9429     VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
9430     VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
9431     VARIMP(R4,-1.0f,I1,0,I4,0);
9432     VARIMP(R4,-1.0f,UI1,1,I4,1);
9433     VARIMP(R4,-1.0f,UI2,1,I4,1);
9434     VARIMP(R4,-1.0f,UI4,1,I4,1);
9435     if (has_i8)
9436     {
9437         VARIMP(R4,-1.0f,I8,1,I8,1);
9438         VARIMP(R4,-1.0f,UI8,1,I4,1);
9439     }
9440     VARIMP(R4,-1.0f,INT,-1,I4,-1);
9441     VARIMP(R4,-1.0f,UINT,1,I4,1);
9442     VARIMP(R8,1.0,EMPTY,0,I4,-2);
9443     VARIMP(R8,1.0,NULL,0,I4,-2);
9444     VARIMP(R8,1.0,I2,-1,I4,-1);
9445     VARIMP(R8,1.0,I4,-1,I4,-1);
9446     VARIMP(R8,1.0,R4,0.0f,I4,-2);
9447     VARIMP(R8,1.0,R8,-1.0,I4,-1);
9448     VARIMP(R8,1.0,DATE,0,I4,-2);
9449     VARIMP(R8,1.0,BSTR,true_str,I4,-1);
9450     VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
9451     VARIMP(R8,1.0,I1,0,I4,-2);
9452     VARIMP(R8,1.0,UI1,1,I4,-1);
9453     VARIMP(R8,1.0,UI2,1,I4,-1);
9454     VARIMP(R8,1.0,UI4,1,I4,-1);
9455     if (has_i8)
9456     {
9457         VARIMP(R8,1.0,I8,1,I8,-1);
9458         VARIMP(R8,1.0,UI8,1,I4,-1);
9459     }
9460     VARIMP(R8,1.0,INT,-1,I4,-1);
9461     VARIMP(R8,1.0,UINT,1,I4,-1);
9462     VARIMP(DATE,0,EMPTY,0,I4,-1);
9463     VARIMP(DATE,0,NULL,0,I4,-1);
9464     VARIMP(DATE,0,I2,-1,I4,-1);
9465     VARIMP(DATE,0,I4,-1,I4,-1);
9466     VARIMP(DATE,0,R4,0.0f,I4,-1);
9467     VARIMP(DATE,0,R8,-1.0,I4,-1);
9468     VARIMP(DATE,0,DATE,0,I4,-1);
9469     VARIMP(DATE,0,BSTR,true_str,I4,-1);
9470     VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
9471     VARIMP(DATE,0,I1,0,I4,-1);
9472     VARIMP(DATE,0,UI1,1,I4,-1);
9473     VARIMP(DATE,0,UI2,1,I4,-1);
9474     VARIMP(DATE,0,UI4,1,I4,-1);
9475     if (has_i8)
9476     {
9477         VARIMP(DATE,0,I8,1,I8,-1);
9478         VARIMP(DATE,0,UI8,1,I4,-1);
9479     }
9480     VARIMP(DATE,0,INT,-1,I4,-1);
9481     VARIMP(DATE,0,UINT,1,I4,-1);
9482     VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
9483     VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
9484     VARIMP(BSTR,false_str,I2,-1,I2,-1);
9485     VARIMP(BSTR,false_str,I4,-1,I4,-1);
9486     VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
9487     VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
9488     VARIMP(BSTR,false_str,DATE,0,I4,-1);
9489     VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
9490     VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
9491     VARIMP(BSTR,false_str,I1,0,I4,-1);
9492     VARIMP(BSTR,false_str,UI1,1,I2,-1);
9493     VARIMP(BSTR,false_str,UI2,1,I4,-1);
9494     VARIMP(BSTR,false_str,UI4,1,I4,-1);
9495     if (has_i8)
9496     {
9497         VARIMP(BSTR,false_str,I8,1,I8,-1);
9498         VARIMP(BSTR,false_str,UI8,1,I4,-1);
9499     }
9500     VARIMP(BSTR,false_str,INT,-1,I4,-1);
9501     VARIMP(BSTR,false_str,UINT,1,I4,-1);
9502     VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
9503     VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
9504     VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
9505     VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
9506     VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
9507     VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
9508     VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
9509     VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
9510     VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
9511     VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
9512     VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
9513     VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
9514     VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
9515     if (has_i8)
9516     {
9517         VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
9518         VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
9519     }
9520     VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
9521     VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
9522     VARIMP(I1,-1,EMPTY,0,I4,0);
9523     VARIMP(I1,-1,NULL,0,NULL,0);
9524     VARIMP(I1,-1,I2,-1,I4,-1);
9525     VARIMP(I1,-1,I4,-1,I4,-1);
9526     VARIMP(I1,-1,R4,0.0f,I4,0);
9527     VARIMP(I1,-1,R8,-1.0,I4,-1);
9528     VARIMP(I1,-1,DATE,0,I4,0);
9529     VARIMP(I1,-1,BSTR,true_str,I4,-1);
9530     VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
9531     VARIMP(I1,-1,I1,0,I4,0);
9532     VARIMP(I1,-1,UI1,1,I4,1);
9533     VARIMP(I1,-1,UI2,1,I4,1);
9534     VARIMP(I1,-1,UI4,1,I4,1);
9535     if (has_i8)
9536     {
9537         VARIMP(I1,-1,I8,1,I8,1);
9538         VARIMP(I1,-1,UI8,1,I4,1);
9539     }
9540     VARIMP(I1,-1,INT,-1,I4,-1);
9541     VARIMP(I1,-1,UINT,1,I4,1);
9542     VARIMP(UI1,0,EMPTY,0,I2,-1);
9543     VARIMP(UI1,0,NULL,0,UI1,255);
9544     VARIMP(UI1,0,I2,-1,I2,-1);
9545     VARIMP(UI1,0,I4,-1,I4,-1);
9546     VARIMP(UI1,0,R4,0.0f,I4,-1);
9547     VARIMP(UI1,0,R8,-1.0,I4,-1);
9548     VARIMP(UI1,0,DATE,0,I4,-1);
9549     VARIMP(UI1,0,BSTR,true_str,I2,-1);
9550     VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
9551     VARIMP(UI1,0,I1,0,I4,-1);
9552     VARIMP(UI1,0,UI1,1,UI1,255);
9553     VARIMP(UI1,0,UI2,1,I4,-1);
9554     VARIMP(UI1,0,UI4,1,I4,-1);
9555     if (has_i8)
9556     {
9557         VARIMP(UI1,0,I8,1,I8,-1);
9558         VARIMP(UI1,0,UI8,1,I4,-1);
9559     }
9560     VARIMP(UI1,0,INT,-1,I4,-1);
9561     VARIMP(UI1,0,UINT,1,I4,-1);
9562     VARIMP(UI2,0,EMPTY,0,I4,-1);
9563     VARIMP(UI2,0,NULL,0,I4,-1);
9564     VARIMP(UI2,0,I2,-1,I4,-1);
9565     VARIMP(UI2,0,I4,-1,I4,-1);
9566     VARIMP(UI2,0,R4,0.0f,I4,-1);
9567     VARIMP(UI2,0,R8,-1.0,I4,-1);
9568     VARIMP(UI2,0,DATE,0,I4,-1);
9569     VARIMP(UI2,0,BSTR,true_str,I4,-1);
9570     VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
9571     VARIMP(UI2,0,I1,0,I4,-1);
9572     VARIMP(UI2,0,UI1,1,I4,-1);
9573     VARIMP(UI2,0,UI2,1,I4,-1);
9574     VARIMP(UI2,0,UI4,1,I4,-1);
9575     if (has_i8)
9576     {
9577         VARIMP(UI2,0,I8,1,I8,-1);
9578         VARIMP(UI2,0,UI8,1,I4,-1);
9579     }
9580     VARIMP(UI2,0,INT,-1,I4,-1);
9581     VARIMP(UI2,0,UINT,1,I4,-1);
9582     VARIMP(UI4,0,EMPTY,0,I4,-1);
9583     VARIMP(UI4,0,NULL,0,I4,-1);
9584     VARIMP(UI4,0,I2,-1,I4,-1);
9585     VARIMP(UI4,0,I4,-1,I4,-1);
9586     VARIMP(UI4,0,R4,0.0f,I4,-1);
9587     VARIMP(UI4,0,R8,-1.0,I4,-1);
9588     VARIMP(UI4,0,DATE,0,I4,-1);
9589     VARIMP(UI4,0,BSTR,true_str,I4,-1);
9590     VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
9591     VARIMP(UI4,0,I1,0,I4,-1);
9592     VARIMP(UI4,0,UI1,1,I4,-1);
9593     VARIMP(UI4,0,UI2,1,I4,-1);
9594     VARIMP(UI4,0,UI4,1,I4,-1);
9595     if (has_i8)
9596     {
9597         VARIMP(UI4,0,I8,1,I8,-1);
9598         VARIMP(UI4,0,UI8,1,I4,-1);
9599     }
9600     VARIMP(UI4,0,INT,-1,I4,-1);
9601     VARIMP(UI4,0,UINT,1,I4,-1);
9602     if (has_i8)
9603     {
9604         VARIMP(I8,-1,EMPTY,0,I8,0);
9605         VARIMP(I8,-1,NULL,0,NULL,0);
9606         VARIMP(I8,-1,I2,-1,I8,-1);
9607         VARIMP(I8,-1,I4,-1,I8,-1);
9608         VARIMP(I8,-1,R4,0.0f,I8,0);
9609         VARIMP(I8,-1,R8,-1.0,I8,-1);
9610         VARIMP(I8,-1,DATE,0,I8,0);
9611         VARIMP(I8,-1,BSTR,true_str,I8,-1);
9612         VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
9613         VARIMP(I8,-1,I1,0,I8,0);
9614         VARIMP(I8,-1,UI1,1,I8,1);
9615         VARIMP(I8,-1,UI2,1,I8,1);
9616         VARIMP(I8,-1,UI4,1,I8,1);
9617         VARIMP(I8,-1,I8,1,I8,1);
9618         VARIMP(I8,-1,UI8,1,I8,1);
9619         VARIMP(I8,-1,UINT,1,I8,1);
9620         VARIMP(UI8,0,EMPTY,0,I4,-1);
9621         VARIMP(UI8,0,NULL,0,I4,-1);
9622         VARIMP(UI8,0,I2,-1,I4,-1);
9623         VARIMP(UI8,0,I4,-1,I4,-1);
9624         VARIMP(UI8,0,R4,0.0f,I4,-1);
9625         VARIMP(UI8,0,R8,-1.0,I4,-1);
9626         VARIMP(UI8,0,DATE,0,I4,-1);
9627         VARIMP(UI8,0,BSTR,true_str,I4,-1);
9628         VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
9629         VARIMP(UI8,0,I1,0,I4,-1);
9630         VARIMP(UI8,0,UI1,1,I4,-1);
9631         VARIMP(UI8,0,UI2,1,I4,-1);
9632         VARIMP(UI8,0,UI4,1,I4,-1);
9633         VARIMP(UI8,0,I8,1,I8,-1);
9634         VARIMP(UI8,0,UI8,1,I4,-1);
9635         VARIMP(UI8,0,INT,-1,I4,-1);
9636         VARIMP(UI8,0,UINT,1,I4,-1);
9637     }
9638     VARIMP(INT,-1,EMPTY,0,I4,0);
9639     VARIMP(INT,-1,NULL,0,NULL,0);
9640     VARIMP(INT,-1,I2,-1,I4,-1);
9641     VARIMP(INT,-1,I4,-1,I4,-1);
9642     VARIMP(INT,-1,R4,0.0f,I4,0);
9643     VARIMP(INT,-1,R8,-1.0,I4,-1);
9644     VARIMP(INT,-1,DATE,0,I4,0);
9645     VARIMP(INT,-1,BSTR,true_str,I4,-1);
9646     VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
9647     VARIMP(INT,-1,I1,0,I4,0);
9648     VARIMP(INT,-1,UI1,1,I4,1);
9649     VARIMP(INT,-1,UI2,1,I4,1);
9650     VARIMP(INT,-1,UI4,1,I4,1);
9651     if (has_i8)
9652     {
9653         VARIMP(INT,-1,I8,1,I8,1);
9654         VARIMP(INT,-1,UI8,1,I4,1);
9655     }
9656     VARIMP(INT,-1,INT,-1,I4,-1);
9657     VARIMP(INT,-1,UINT,1,I4,1);
9658     VARIMP(UINT,1,EMPTY,0,I4,-2);
9659     VARIMP(UINT,1,NULL,0,I4,-2);
9660     VARIMP(UINT,1,I2,-1,I4,-1);
9661     VARIMP(UINT,1,I4,-1,I4,-1);
9662     VARIMP(UINT,1,R4,0.0f,I4,-2);
9663     VARIMP(UINT,1,R8,-1.0,I4,-1);
9664     VARIMP(UINT,1,DATE,0,I4,-2);
9665     VARIMP(UINT,1,BSTR,true_str,I4,-1);
9666     VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
9667     VARIMP(UINT,1,I1,0,I4,-2);
9668     VARIMP(UINT,1,UI1,1,I4,-1);
9669     VARIMP(UINT,1,UI2,1,I4,-1);
9670     VARIMP(UINT,1,UI4,1,I4,-1);
9671     if (has_i8)
9672     {
9673         VARIMP(UINT,1,I8,1,I8,-1);
9674         VARIMP(UINT,1,UI8,1,I4,-1);
9675     }
9676     VARIMP(UINT,1,INT,-1,I4,-1);
9677     VARIMP(UINT,1,UINT,1,I4,-1);
9678
9679     /* Manually test some VT_CY, VT_DECIMAL variants */
9680     V_VT(&cy) = VT_CY;
9681     hres = VarCyFromI4(1, &V_CY(&cy));
9682     ok(hres == S_OK, "VarCyFromI4 failed!\n");
9683     V_VT(&dec) = VT_DECIMAL;
9684     hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
9685     ok(hres == S_OK, "VarDecFromR4 failed!\n");
9686     memset(&left, 0, sizeof(left));
9687     memset(&right, 0, sizeof(right));
9688     V_VT(&left) = VT_I4;
9689     V_I4(&left) = 0;
9690     V_VT(&right) = VT_I8;
9691     V_UI1(&right) = 0;
9692
9693     hres = pVarImp(&cy, &cy, &result);
9694     ok(hres == S_OK && V_VT(&result) == VT_I4,
9695         "VARIMP: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9696         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9697     ok(hres == S_OK && V_I4(&result) == -1,
9698         "VARIMP: CY value %ld, expected %d\n", V_I4(&result), -1);
9699
9700     if (has_i8)
9701     {
9702         hres = pVarImp(&cy, &right, &result);
9703         ok(hres == S_OK && V_VT(&result) == VT_I8,
9704             "VARIMP: expected coerced hres 0x%lX type VT_I8, got hres 0x%lX type %s!\n",
9705             S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9706         ok(hres == S_OK && V_I8(&result) == -2,
9707             "VARIMP: CY value %I64d, expected %d\n",
9708             V_I8(&result), -2);
9709     }
9710
9711     hres = pVarImp(&left, &cy, &result);
9712     ok(hres == S_OK && V_VT(&result) == VT_I4,
9713         "VARIMP: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9714         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9715     ok(hres == S_OK && V_I4(&result) == -1,
9716         "VARIMP: CY value %ld, expected %d\n", V_I4(&result), -1);
9717
9718     hres = pVarImp(&left, &dec, &result);
9719     ok(hres == S_OK && V_VT(&result) == VT_I4,
9720         "VARIMP: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9721         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9722     ok(hres == S_OK && V_I4(&result) == -1,
9723         "VARIMP: DECIMAL value %ld, expected %d\n", V_I4(&result), -1);
9724
9725     hres = pVarImp(&dec, &dec, &result);
9726     ok(hres == S_OK && V_VT(&result) == VT_I4,
9727         "VARIMP: expected coerced hres 0x%lX type VT_I4, got hres 0x%lX type %s!\n",
9728         S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9729     ok(hres == S_OK && V_I4(&result) == -1,
9730         "VARIMP: DECIMAL value %ld, expected %d\n", V_I4(&result), -1);
9731
9732     if (has_i8)
9733     {
9734         hres = pVarImp(&dec, &right, &result);
9735         ok(hres == S_OK && V_VT(&result) == VT_I8,
9736             "VARIMP: expected coerced hres 0x%lX type VT_I8, got hres 0x%lX type %s!\n",
9737             S_OK, hres, wine_dbgstr_vt(V_VT(&result)));
9738         ok(hres == S_OK && V_I8(&result) == -3,
9739             "VARIMP: DECIMAL value %#I64x, expected %d\n",
9740             V_I8(&result), -3);
9741     }
9742
9743     SysFreeString(false_str);
9744     SysFreeString(true_str);
9745 }
9746
9747 START_TEST(vartest)
9748 {
9749   init();
9750
9751   test_VariantInit();
9752   test_VariantClear();
9753   test_VariantCopy();
9754   test_VariantCopyInd();
9755   test_VarParseNumFromStrEn();
9756   test_VarParseNumFromStrFr();
9757   test_VarParseNumFromStrMisc();
9758   test_VarNumFromParseNum();
9759   test_VarUdateFromDate();
9760   test_VarDateFromUdate();
9761   test_SystemTimeToVariantTime();
9762   test_VariantTimeToSystemTime();
9763   test_DosDateTimeToVariantTime();
9764   test_VariantTimeToDosDateTime();
9765   test_VarAbs();
9766   test_VarNot();
9767   test_VarSub();
9768   test_VarMod();
9769   test_VarFix();
9770   test_VarInt();
9771   test_VarNeg();
9772   test_VarRound();
9773   test_VarXor();
9774   test_VarOr();
9775   test_VarPow();
9776   test_VarEqv();
9777   test_VarMul();
9778   test_VarAdd();
9779   test_VarCmp();
9780   test_VarCat();
9781   test_VarAnd();
9782   test_VarDiv();
9783   test_VarIdiv();
9784   test_VarImp();
9785 }