?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add AppDefaults app selection to control panel
[wine/gsoc-2012-control.git] / dlls / oleaut32 / tests / vartest.c
blob1ac09cd4ae3ee30df4ea2ac9e8276f2c2607d9f9
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 CONST_VTABLE
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winsock.h"
32 #include "wine/test.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 static HMODULE hOleaut32;
43
44 static HRESULT (WINAPI *pVarUdateFromDate)(DATE,ULONG,UDATE*);
45 static HRESULT (WINAPI *pVarDateFromUdate)(UDATE*,ULONG,DATE*);
46 static INT (WINAPI *pSystemTimeToVariantTime)(LPSYSTEMTIME,double*);
47 static INT (WINAPI *pVariantTimeToSystemTime)(double,LPSYSTEMTIME);
48 static INT (WINAPI *pDosDateTimeToVariantTime)(USHORT,USHORT,double*);
49 static INT (WINAPI *pVariantTimeToDosDateTime)(double,USHORT*,USHORT *);
50
51 static const WCHAR sz12[] = {'1','2','\0'};
52 /* the strings are localized */
53 static WCHAR sz12_false[32];
54 static WCHAR sz12_true[32];
55
56 /* Get a conversion function ptr, return if function not available */
57 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
58 if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }
59
60 /* Have IRecordInfo data type? */
61 static int HAVE_OLEAUT32_RECORD = 0;
62 /* Have I8/UI8 data type? */
63 static int HAVE_OLEAUT32_I8 = 0;
64 /* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
65 static int IS_ANCIENT = 0;
66
67 /* When comparing floating point values we cannot expect an exact match
68 * because the rounding errors depend on the exact algorithm.
69 */
70 #define EQ_DOUBLE(a,b) (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-14)
71 #define EQ_FLOAT(a,b) (fabs((a)-(b)) / (1.0+fabs(a)+fabs(b)) < 1e-7)
72
73 #define SKIPTESTS(a) if((a > VT_CLSID+10) && (a < VT_BSTR_BLOB-10)) continue
74
75 /* Allow our test macros to work for VT_NULL and VT_EMPTY too */
76 #define V_EMPTY(v) V_I4(v)
77 #define V_NULL(v) V_I4(v)
78
79 /* Size constraints for overflow tests */
80 #define I1_MAX 0x7f
81 #define I1_MIN ((-I1_MAX)-1)
82 #define UI1_MAX 0xff
83 #define UI1_MIN 0
84 #define I2_MAX 0x7fff
85 #define I2_MIN ((-I2_MAX)-1)
86 #define UI2_MAX 0xffff
87 #define UI2_MIN 0
88 #define I4_MAX 0x7fffffff
89 #define I4_MIN ((-I4_MAX)-1)
90 #define UI4_MAX 0xffffffff
91 #define UI4_MIN 0
92 #define I8_MAX (((LONGLONG)I4_MAX << 32) | UI4_MAX)
93 #define I8_MIN ((-I8_MAX)-1)
94 #define UI8_MAX (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
95 #define UI8_MIN 0
96 #define DATE_MAX 2958465
97 #define DATE_MIN -657434
98 #define R4_MAX FLT_MAX
99 #define R4_MIN FLT_MIN
100 #define R8_MAX DBL_MAX
101 #define R8_MIN DBL_MIN
102
103 static void init(void)
104 {
105 BSTR bstr;
106 HRESULT res;
107
108 res = VarBstrFromBool(VARIANT_TRUE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
109 ok(res == S_OK && (lstrlenW(bstr) > 0),
110 "Expected localized string for 'True'\n");
111 /* lstrcpyW / lstrcatW do not work on win95 */
112 memcpy(sz12_true, sz12, sizeof(sz12));
113 if (bstr) memcpy(&sz12_true[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
114 SysFreeString(bstr);
115
116 res = VarBstrFromBool(VARIANT_FALSE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
117 ok(res == S_OK && (lstrlenW(bstr) > 0),
118 "Expected localized string for 'False'\n");
119 memcpy(sz12_false, sz12, sizeof(sz12));
120 if (bstr) memcpy(&sz12_false[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
121 SysFreeString(bstr);
122
123 hOleaut32 = GetModuleHandle("oleaut32.dll");
124
125 /* Is a given function exported from oleaut32? */
126 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
127
128 HAVE_OLEAUT32_I8 = HAVE_FUNC(VarI8FromI1);
129 if (!HAVE_OLEAUT32_I8)
130 skip("No support for I8 and UI8 data types\n");
131
132 HAVE_OLEAUT32_RECORD = HAVE_FUNC(SafeArraySetRecordInfo);
133 IS_ANCIENT = (!HAVE_FUNC(VarI1FromI2));
134
135 #undef HAVE_FUNC
136 }
137
138 /* Functions to set a DECIMAL */
139 static void setdec(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG64 lo64)
140 {
141 S(U(*dec)).scale = scl;
142 S(U(*dec)).sign = sgn;
143 dec->Hi32 = hi32;
144 U1(*dec).Lo64 = lo64;
145 }
146
147 static void setdec64(DECIMAL* dec, BYTE scl, BYTE sgn, ULONG hi32, ULONG mid32, ULONG lo32)
148 {
149 S(U(*dec)).scale = scl;
150 S(U(*dec)).sign = sgn;
151 dec->Hi32 = hi32;
152 S1(U1(*dec)).Mid32 = mid32;
153 S1(U1(*dec)).Lo32 = lo32;
154 }
155
156 static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
157 {
158 while (*str1 && (*str1 == *str2)) { str1++; str2++; }
159 return *str1 - *str2;
160 }
161
162 /* return the string text of a given variant type */
163 static char vtstr_buffer[16][256];
164 static int vtstr_current=0;
165 static const char *vtstr(int x)
166 {
167 switch(x) {
168 #define CASE(vt) case VT_##vt: return #vt
169 CASE(EMPTY);
170 CASE(NULL);
171 CASE(I2);
172 CASE(I4);
173 CASE(R4);
174 CASE(R8);
175 CASE(CY);
176 CASE(DATE);
177 CASE(BSTR);
178 CASE(DISPATCH);
179 CASE(ERROR);
180 CASE(BOOL);
181 CASE(VARIANT);
182 CASE(UNKNOWN);
183 CASE(DECIMAL);
184 CASE(I1);
185 CASE(UI1);
186 CASE(UI2);
187 CASE(UI4);
188 CASE(I8);
189 CASE(UI8);
190 CASE(INT);
191 CASE(UINT);
192 CASE(VOID);
193 CASE(HRESULT);
194 CASE(PTR);
195 CASE(SAFEARRAY);
196 CASE(CARRAY);
197 CASE(USERDEFINED);
198 CASE(LPSTR);
199 CASE(LPWSTR);
200 CASE(RECORD);
201 CASE(INT_PTR);
202 CASE(UINT_PTR);
203 CASE(FILETIME);
204 CASE(BLOB);
205 CASE(STREAM);
206 CASE(STORAGE);
207 CASE(STREAMED_OBJECT);
208 CASE(STORED_OBJECT);
209 CASE(BLOB_OBJECT);
210 CASE(CF);
211 CASE(CLSID);
212 CASE(VERSIONED_STREAM);
213 CASE(VECTOR);
214 CASE(ARRAY);
215 CASE(BYREF);
216 CASE(RESERVED);
217 CASE(ILLEGAL);
218 #undef CASE
219
220 case 0xfff:
221 return "VT_BSTR_BLOB/VT_ILLEGALMASKED/VT_TYPEMASK";
222
223 default:
224 vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
225 sprintf(vtstr_buffer[vtstr_current], "unknown variant type %d", x);
226 return vtstr_buffer[vtstr_current++];
227 }
228 }
229
230 static const char *variantstr( const VARIANT *var )
231 {
232 vtstr_current %= sizeof(vtstr_buffer)/sizeof(*vtstr_buffer);
233 switch(V_VT(var))
234 {
235 case VT_I1:
236 sprintf( vtstr_buffer[vtstr_current], "VT_I1(%d)", V_I1(var) ); break;
237 case VT_I2:
238 sprintf( vtstr_buffer[vtstr_current], "VT_I2(%d)", V_I2(var) ); break;
239 case VT_I4:
240 sprintf( vtstr_buffer[vtstr_current], "VT_I4(%d)", V_I4(var) ); break;
241 case VT_INT:
242 sprintf( vtstr_buffer[vtstr_current], "VT_INT(%d)", V_INT(var) ); break;
243 case VT_I8:
244 sprintf( vtstr_buffer[vtstr_current], "VT_I8(%x%08x)", (UINT)(V_I8(var) >> 32), (UINT)V_I8(var) ); break;
245 case VT_UI8:
246 sprintf( vtstr_buffer[vtstr_current], "VT_UI8(%x%08x)", (UINT)(V_UI8(var) >> 32), (UINT)V_UI8(var) ); break;
247 case VT_R4:
248 sprintf( vtstr_buffer[vtstr_current], "VT_R4(%g)", V_R4(var) ); break;
249 case VT_R8:
250 sprintf( vtstr_buffer[vtstr_current], "VT_R8(%g)", V_R8(var) ); break;
251 case VT_UI1:
252 sprintf( vtstr_buffer[vtstr_current], "VT_UI1(%u)", V_UI1(var) ); break;
253 case VT_UI2:
254 sprintf( vtstr_buffer[vtstr_current], "VT_UI2(%u)", V_UI2(var) ); break;
255 case VT_UI4:
256 sprintf( vtstr_buffer[vtstr_current], "VT_UI4(%u)", V_UI4(var) ); break;
257 case VT_UINT:
258 sprintf( vtstr_buffer[vtstr_current], "VT_UINT(%d)", V_UINT(var) ); break;
259 case VT_CY:
260 sprintf( vtstr_buffer[vtstr_current], "VT_CY(%x%08x)", S(V_CY(var)).Hi, S(V_CY(var)).Lo ); break;
261 case VT_DATE:
262 sprintf( vtstr_buffer[vtstr_current], "VT_DATE(%g)", V_DATE(var) ); break;
263 default:
264 return vtstr(V_VT(var));
265 }
266 return vtstr_buffer[vtstr_current++];
267 }
268
269 static BOOL is_expected_variant( const VARIANT *result, const VARIANT *expected )
270 {
271 if (V_VT(result) != V_VT(expected)) return FALSE;
272 switch(V_VT(expected))
273 {
274 case VT_EMPTY:
275 case VT_NULL:
276 return TRUE;
277
278 #define CASE(vt) case VT_##vt: return (V_##vt(result) == V_##vt(expected))
279 CASE(BOOL);
280 CASE(I1);
281 CASE(UI1);
282 CASE(I2);
283 CASE(UI2);
284 CASE(I4);
285 CASE(UI4);
286 CASE(I8);
287 CASE(UI8);
288 CASE(INT);
289 CASE(UINT);
290 #undef CASE
291
292 case VT_DATE:
293 return EQ_FLOAT(V_DATE(result), V_DATE(expected));
294 case VT_R4:
295 return EQ_FLOAT(V_R4(result), V_R4(expected));
296 case VT_R8:
297 return EQ_FLOAT(V_R8(result), V_R8(expected));
298 case VT_CY:
299 return (V_CY(result).int64 == V_CY(expected).int64);
300 case VT_BSTR:
301 return !lstrcmpW( V_BSTR(result), V_BSTR(expected) );
302 case VT_DECIMAL:
303 return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
304 default:
305 ok(0, "unhandled variant type %s\n",vtstr(V_VT(expected)));
306 return 0;
307 }
308 }
309
310 static void test_var_call1( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT),
311 VARIANT *arg, VARIANT *expected )
312 {
313 VARIANT old_arg = *arg;
314 VARIANT result;
315 HRESULT hres;
316
317 memset( &result, 0, sizeof(result) );
318 hres = func( arg, &result );
319 ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
320 if (hres == S_OK)
321 ok_(__FILE__,line)( is_expected_variant( &result, expected ),
322 "got %s expected %s\n", variantstr(&result), variantstr(expected) );
323 ok_(__FILE__,line)( is_expected_variant( arg, &old_arg ), "Modified argument %s / %s\n",
324 variantstr(&old_arg), variantstr(arg));
325 VariantClear( &result );
326 }
327
328 static void test_var_call2( int line, HRESULT (WINAPI *func)(LPVARIANT,LPVARIANT,LPVARIANT),
329 VARIANT *left, VARIANT *right, VARIANT *expected )
330 {
331 VARIANT old_left = *left, old_right = *right;
332 VARIANT result;
333 HRESULT hres;
334
335 memset( &result, 0, sizeof(result) );
336 hres = func( left, right, &result );
337 ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
338 if (hres == S_OK)
339 ok_(__FILE__,line)( is_expected_variant( &result, expected ),
340 "got %s expected %s\n", variantstr(&result), variantstr(expected) );
341 ok_(__FILE__,line)( is_expected_variant( left, &old_left ), "Modified left argument %s / %s\n",
342 variantstr(&old_left), variantstr(left));
343 ok_(__FILE__,line)( is_expected_variant( right, &old_right ), "Modified right argument %s / %s\n",
344 variantstr(&old_right), variantstr(right));
345 VariantClear( &result );
346 }
347
348 static int strcmp_wa(const WCHAR *strw, const char *stra)
349 {
350 WCHAR buf[512];
351 MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(buf[0]));
352 return lstrcmpW(strw, buf);
353 }
354
355 #define test_bstr_var(a,b) _test_bstr_var(__LINE__,a,b)
356 static void _test_bstr_var(unsigned line, const VARIANT *v, const char *str)
357 {
358 ok_(__FILE__,line)(V_VT(v) == VT_BSTR, "unexpected vt=%d\n", V_VT(v));
359 if(V_VT(v) == VT_BSTR)
360 ok(!strcmp_wa(V_BSTR(v), str), "v=%s, expected %s\n", wine_dbgstr_w(V_BSTR(v)), str);
361 }
362
363 static void test_VariantInit(void)
364 {
365 VARIANTARG v1, v2;
366
367 /* Test that VariantInit() only sets the type */
368 memset(&v1, -1, sizeof(v1));
369 v2 = v1;
370 V_VT(&v2) = VT_EMPTY;
371 VariantInit(&v1);
372 ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
373 }
374
375 /* All possible combinations of extra V_VT() flags */
376 static const VARTYPE ExtraFlags[16] =
377 {
378 0,
379 VT_VECTOR,
380 VT_ARRAY,
381 VT_BYREF,
382 VT_RESERVED,
383 VT_VECTOR|VT_ARRAY,
384 VT_VECTOR|VT_BYREF,
385 VT_VECTOR|VT_RESERVED,
386 VT_VECTOR|VT_ARRAY|VT_BYREF,
387 VT_VECTOR|VT_ARRAY|VT_RESERVED,
388 VT_VECTOR|VT_BYREF|VT_RESERVED,
389 VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED,
390 VT_ARRAY|VT_BYREF,
391 VT_ARRAY|VT_RESERVED,
392 VT_ARRAY|VT_BYREF|VT_RESERVED,
393 VT_BYREF|VT_RESERVED,
394 };
395
396 /* Determine if a vt is valid for VariantClear() */
397 static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
398 {
399 int ret = 0;
400
401 /* Only the following flags/types are valid */
402 if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
403 vt != (VARTYPE)15 &&
404 (vt < (VARTYPE)24 || vt > (VARTYPE)31) &&
405 (!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
406 (extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
407 extraFlags == (VT_ARRAY|VT_BYREF)))
408 ret = 1; /* ok */
409
410 if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
411 ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
412 ret = 0; /* Old versions of oleaut32 */
413 return ret;
414 }
415
416 typedef struct
417 {
418 IUnknown IUnknown_iface;
419 LONG ref;
420 LONG events;
421 } test_VariantClearImpl;
422
423 static inline test_VariantClearImpl *impl_from_IUnknown(IUnknown *iface)
424 {
425 return CONTAINING_RECORD(iface, test_VariantClearImpl, IUnknown_iface);
426 }
427
428 static HRESULT WINAPI VC_QueryInterface(LPUNKNOWN iface,REFIID riid,LPVOID *ppobj)
429 {
430 test_VariantClearImpl *This = impl_from_IUnknown(iface);
431 This->events |= 0x1;
432 return E_NOINTERFACE;
433 }
434
435 static ULONG WINAPI VC_AddRef(LPUNKNOWN iface) {
436 test_VariantClearImpl *This = impl_from_IUnknown(iface);
437 This->events |= 0x2;
438 return InterlockedIncrement(&This->ref);
439 }
440
441 static ULONG WINAPI VC_Release(LPUNKNOWN iface) {
442 test_VariantClearImpl *This = impl_from_IUnknown(iface);
443 /* static class, won't be freed */
444 This->events |= 0x4;
445 return InterlockedDecrement(&This->ref);
446 }
447
448 static const IUnknownVtbl test_VariantClear_vtbl = {
449 VC_QueryInterface,
450 VC_AddRef,
451 VC_Release,
452 };
453
454 static test_VariantClearImpl test_myVariantClearImpl = {{&test_VariantClear_vtbl}, 1, 0};
455
456 static void test_VariantClear(void)
457 {
458 HRESULT hres;
459 VARIANTARG v;
460 VARIANT v2;
461 size_t i;
462 LONG i4;
463 IUnknown *punk;
464
465 /* Crashes: Native does not test input for NULL, so neither does Wine */
466 if (0)
467 VariantClear(NULL);
468
469 /* Only the type field is set, to VT_EMPTY */
470 V_VT(&v) = VT_UI4;
471 V_UI4(&v) = ~0u;
472 hres = VariantClear(&v);
473 ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
474 (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
475 "VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
476 ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
477
478 /* Test all possible V_VT values.
479 * Also demonstrates that null pointers in 'v' are not dereferenced.
480 * Individual variant tests should test VariantClear() with non-NULL values.
481 */
482 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
483 {
484 VARTYPE vt;
485
486 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
487 {
488 HRESULT hExpected = DISP_E_BADVARTYPE;
489
490 SKIPTESTS(vt);
491
492 memset(&v, 0, sizeof(v));
493 V_VT(&v) = vt | ExtraFlags[i];
494
495 hres = VariantClear(&v);
496
497 if (IsValidVariantClearVT(vt, ExtraFlags[i]))
498 hExpected = S_OK;
499
500 ok(hres == hExpected, "VariantClear: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
501 hExpected, hres, vt, ExtraFlags[i]);
502 }
503 }
504
505 /* Some BYREF tests with non-NULL ptrs */
506
507 /* VARIANT BYREF */
508 V_VT(&v2) = VT_I4;
509 V_I4(&v2) = 0x1234;
510 V_VT(&v) = VT_VARIANT | VT_BYREF;
511 V_VARIANTREF(&v) = &v2;
512
513 hres = VariantClear(&v);
514 ok(hres == S_OK, "ret %08x\n", hres);
515 ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
516 ok(V_VARIANTREF(&v) == &v2, "variant ref %p\n", V_VARIANTREF(&v2));
517 ok(V_VT(&v2) == VT_I4, "vt %04x\n", V_VT(&v2));
518 ok(V_I4(&v2) == 0x1234, "i4 %04x\n", V_I4(&v2));
519
520 /* I4 BYREF */
521 i4 = 0x4321;
522 V_VT(&v) = VT_I4 | VT_BYREF;
523 V_I4REF(&v) = &i4;
524
525 hres = VariantClear(&v);
526 ok(hres == S_OK, "ret %08x\n", hres);
527 ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
528 ok(V_I4REF(&v) == &i4, "i4 ref %p\n", V_I4REF(&v2));
529 ok(i4 == 0x4321, "i4 changed %08x\n", i4);
530
531
532 /* UNKNOWN */
533 V_VT(&v) = VT_UNKNOWN;
534 V_UNKNOWN(&v) = &test_myVariantClearImpl.IUnknown_iface;
535 test_myVariantClearImpl.events = 0;
536 hres = VariantClear(&v);
537 ok(hres == S_OK, "ret %08x\n", hres);
538 ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
539 ok(V_UNKNOWN(&v) == &test_myVariantClearImpl.IUnknown_iface, "unknown %p\n", V_UNKNOWN(&v));
540 /* Check that Release got called, but nothing else */
541 ok(test_myVariantClearImpl.events == 0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
542
543 /* UNKNOWN BYREF */
544 punk = &test_myVariantClearImpl.IUnknown_iface;
545 V_VT(&v) = VT_UNKNOWN | VT_BYREF;
546 V_UNKNOWNREF(&v) = &punk;
547 test_myVariantClearImpl.events = 0;
548 hres = VariantClear(&v);
549 ok(hres == S_OK, "ret %08x\n", hres);
550 ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
551 ok(V_UNKNOWNREF(&v) == &punk, "unknown ref %p\n", V_UNKNOWNREF(&v));
552 /* Check that nothing got called */
553 ok(test_myVariantClearImpl.events == 0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
554
555 /* DISPATCH */
556 V_VT(&v) = VT_DISPATCH;
557 V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
558 test_myVariantClearImpl.events = 0;
559 hres = VariantClear(&v);
560 ok(hres == S_OK, "ret %08x\n", hres);
561 ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
562 ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
563 /* Check that Release got called, but nothing else */
564 ok(test_myVariantClearImpl.events == 0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
565
566 /* DISPATCH BYREF */
567 punk = &test_myVariantClearImpl.IUnknown_iface;
568 V_VT(&v) = VT_DISPATCH | VT_BYREF;
569 V_DISPATCHREF(&v) = (IDispatch**)&punk;
570 test_myVariantClearImpl.events = 0;
571 hres = VariantClear(&v);
572 ok(hres == S_OK, "ret %08x\n", hres);
573 ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
574 ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
575 /* Check that nothing got called */
576 ok(test_myVariantClearImpl.events == 0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
577 }
578
579 static void test_VariantCopy(void)
580 {
581 VARIANTARG vSrc, vDst;
582 VARTYPE vt;
583 size_t i;
584 HRESULT hres, hExpected;
585
586 /* Establish that the failure/other cases are dealt with. Individual tests
587 * for each type should verify that data is copied correctly, references
588 * are updated, etc.
589 */
590
591 /* vSrc == vDst */
592 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
593 {
594 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
595 {
596 SKIPTESTS(vt);
597
598 memset(&vSrc, 0, sizeof(vSrc));
599 V_VT(&vSrc) = vt | ExtraFlags[i];
600
601 hExpected = DISP_E_BADVARTYPE;
602 /* src is allowed to be a VT_CLSID */
603 if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
604 hExpected = S_OK;
605
606 hres = VariantCopy(&vSrc, &vSrc);
607
608 ok(hres == hExpected,
609 "Copy(src==dst): expected 0x%X, got 0x%X for src==dest vt %d|0x%X\n",
610 hExpected, hres, vt, ExtraFlags[i]);
611 }
612 }
613
614 /* Test that if VariantClear() fails on dest, the function fails. This also
615 * shows that dest is in fact cleared and not just overwritten
616 */
617 memset(&vSrc, 0, sizeof(vSrc));
618 V_VT(&vSrc) = VT_UI1;
619
620 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
621 {
622 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
623 {
624 SKIPTESTS(vt);
625
626 hExpected = DISP_E_BADVARTYPE;
627
628 memset(&vDst, 0, sizeof(vDst));
629 V_VT(&vDst) = vt | ExtraFlags[i];
630
631 if (IsValidVariantClearVT(vt, ExtraFlags[i]))
632 hExpected = S_OK;
633
634 hres = VariantCopy(&vDst, &vSrc);
635
636 ok(hres == hExpected,
637 "Copy(bad dst): expected 0x%X, got 0x%X for dest vt %d|0x%X\n",
638 hExpected, hres, vt, ExtraFlags[i]);
639 if (hres == S_OK)
640 ok(V_VT(&vDst) == VT_UI1,
641 "Copy(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
642 }
643 }
644
645 /* Test that VariantClear() checks vSrc for validity before copying */
646 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
647 {
648 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
649 {
650 SKIPTESTS(vt);
651
652 hExpected = DISP_E_BADVARTYPE;
653
654 memset(&vDst, 0, sizeof(vDst));
655 V_VT(&vDst) = VT_EMPTY;
656
657 memset(&vSrc, 0, sizeof(vSrc));
658 V_VT(&vSrc) = vt | ExtraFlags[i];
659
660 /* src is allowed to be a VT_CLSID */
661 if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
662 hExpected = S_OK;
663
664 hres = VariantCopy(&vDst, &vSrc);
665
666 ok(hres == hExpected,
667 "Copy(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
668 hExpected, hres, vt, ExtraFlags[i]);
669 if (hres == S_OK)
670 {
671 ok(V_VT(&vDst) == (vt|ExtraFlags[i]),
672 "Copy(bad src): expected vt = %d, got %d\n",
673 vt | ExtraFlags[i], V_VT(&vDst));
674 VariantClear(&vDst);
675 }
676 }
677 }
678
679 /* Test that copying a NULL BSTR results in an empty BSTR */
680 memset(&vDst, 0, sizeof(vDst));
681 V_VT(&vDst) = VT_EMPTY;
682 memset(&vSrc, 0, sizeof(vSrc));
683 V_VT(&vSrc) = VT_BSTR;
684 hres = VariantCopy(&vDst, &vSrc);
685 ok(hres == S_OK, "Copy(NULL BSTR): Failed to copy a NULL BSTR\n");
686 if (hres == S_OK)
687 {
688 ok((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst),
689 "Copy(NULL BSTR): should have non-NULL result\n");
690 if ((V_VT(&vDst) == VT_BSTR) && V_BSTR(&vDst))
691 {
692 ok(*V_BSTR(&vDst) == 0, "Copy(NULL BSTR): result not empty\n");
693 }
694 VariantClear(&vDst);
695 }
696 }
697
698 /* Determine if a vt is valid for VariantCopyInd() */
699 static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
700 {
701 int ret = 0;
702
703 if ((extraFlags & VT_ARRAY) ||
704 (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
705 !(extraFlags & (VT_VECTOR|VT_RESERVED))))
706 {
707 ret = 1; /* ok */
708 }
709 return ret;
710 }
711
712 static void test_VariantCopyInd(void)
713 {
714 VARIANTARG vSrc, vDst, vRef, vRef2;
715 VARTYPE vt;
716 size_t i;
717 BYTE buffer[64];
718 HRESULT hres, hExpected;
719
720 memset(buffer, 0, sizeof(buffer));
721
722 /* vSrc == vDst */
723 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
724 {
725 if (ExtraFlags[i] & VT_ARRAY)
726 continue; /* Native crashes on NULL safearray */
727
728 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
729 {
730 SKIPTESTS(vt);
731
732 memset(&vSrc, 0, sizeof(vSrc));
733 V_VT(&vSrc) = vt | ExtraFlags[i];
734
735 hExpected = DISP_E_BADVARTYPE;
736 if (!(ExtraFlags[i] & VT_BYREF))
737 {
738 /* if src is not by-reference, acts as VariantCopy() */
739 if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
740 hExpected = S_OK;
741 }
742 else
743 {
744 if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
745 vt == VT_DISPATCH || vt == VT_RECORD)
746 continue; /* Need valid ptrs for deep copies */
747
748 V_BYREF(&vSrc) = &buffer;
749 hExpected = E_INVALIDARG;
750
751 if ((vt == VT_I8 || vt == VT_UI8) &&
752 ExtraFlags[i] == VT_BYREF)
753 {
754 if (HAVE_OLEAUT32_I8)
755 hExpected = S_OK; /* Only valid if I8 is a known type */
756 }
757 else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
758 hExpected = S_OK;
759 }
760
761 hres = VariantCopyInd(&vSrc, &vSrc);
762
763 ok(hres == hExpected,
764 "CopyInd(src==dst): expected 0x%X, got 0x%X for src==dst vt %d|0x%X\n",
765 hExpected, hres, vt, ExtraFlags[i]);
766 }
767 }
768
769 /* Bad dest */
770 memset(&vSrc, 0, sizeof(vSrc));
771 V_VT(&vSrc) = VT_UI1|VT_BYREF;
772 V_BYREF(&vSrc) = &buffer;
773
774 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
775 {
776 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
777 {
778 SKIPTESTS(vt);
779
780 memset(&vDst, 0, sizeof(vDst));
781 V_VT(&vDst) = vt | ExtraFlags[i];
782
783 hExpected = DISP_E_BADVARTYPE;
784
785 if (IsValidVariantClearVT(vt, ExtraFlags[i]))
786 hExpected = S_OK;
787
788 hres = VariantCopyInd(&vDst, &vSrc);
789
790 ok(hres == hExpected,
791 "CopyInd(bad dst): expected 0x%X, got 0x%X for dst vt %d|0x%X\n",
792 hExpected, hres, vt, ExtraFlags[i]);
793 if (hres == S_OK)
794 ok(V_VT(&vDst) == VT_UI1,
795 "CopyInd(bad dst): expected vt = VT_UI1, got %d\n", V_VT(&vDst));
796 }
797 }
798
799 /* bad src */
800 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
801 {
802 if (ExtraFlags[i] & VT_ARRAY)
803 continue; /* Native crashes on NULL safearray */
804
805 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
806 {
807 SKIPTESTS(vt);
808
809 memset(&vDst, 0, sizeof(vDst));
810 V_VT(&vDst) = VT_EMPTY;
811
812 memset(&vSrc, 0, sizeof(vSrc));
813 V_VT(&vSrc) = vt | ExtraFlags[i];
814
815 hExpected = DISP_E_BADVARTYPE;
816 if (!(ExtraFlags[i] & VT_BYREF))
817 {
818 /* if src is not by-reference, acts as VariantCopy() */
819 if (vt != VT_CLSID && IsValidVariantClearVT(vt, ExtraFlags[i]))
820 hExpected = S_OK;
821 }
822 else
823 {
824 if (vt == VT_SAFEARRAY || vt == VT_BSTR || vt == VT_UNKNOWN ||
825 vt == VT_DISPATCH || vt == VT_RECORD)
826 continue; /* Need valid ptrs for deep copies, see vartype.c */
827
828 V_BYREF(&vSrc) = &buffer;
829
830 hExpected = E_INVALIDARG;
831
832 if ((vt == VT_I8 || vt == VT_UI8) &&
833 ExtraFlags[i] == VT_BYREF)
834 {
835 if (HAVE_OLEAUT32_I8)
836 hExpected = S_OK; /* Only valid if I8 is a known type */
837 }
838 else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
839 hExpected = S_OK;
840 }
841
842 hres = VariantCopyInd(&vDst, &vSrc);
843
844 ok(hres == hExpected,
845 "CopyInd(bad src): expected 0x%X, got 0x%X for src vt %d|0x%X\n",
846 hExpected, hres, vt, ExtraFlags[i]);
847 if (hres == S_OK)
848 {
849 if (vt == VT_VARIANT && ExtraFlags[i] == VT_BYREF)
850 {
851 /* Type of vDst should be the type of the referenced variant.
852 * Since we set the buffer to all zeros, its type should be
853 * VT_EMPTY.
854 */
855 ok(V_VT(&vDst) == VT_EMPTY,
856 "CopyInd(bad src): expected dst vt = VT_EMPTY, got %d|0x%X\n",
857 V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
858 }
859 else
860 {
861 ok(V_VT(&vDst) == (vt|(ExtraFlags[i] & ~VT_BYREF)),
862 "CopyInd(bad src): expected dst vt = %d|0x%X, got %d|0x%X\n",
863 vt, ExtraFlags[i] & ~VT_BYREF,
864 V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK);
865 }
866 VariantClear(&vDst);
867 }
868 }
869 }
870
871 /* By-reference variants are dereferenced */
872 V_VT(&vRef) = VT_UI1;
873 V_UI1(&vRef) = 0x77;
874 V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
875 V_VARIANTREF(&vSrc) = &vRef;
876 VariantInit(&vDst);
877
878 hres = VariantCopyInd(&vDst, &vSrc);
879 ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
880 ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x77,
881 "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
882 V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
883
884 /* By-reference variant to a by-reference type succeeds */
885 V_VT(&vRef) = VT_UI1|VT_BYREF;
886 V_UI1REF(&vRef) = buffer; buffer[0] = 0x88;
887 V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
888 V_VARIANTREF(&vSrc) = &vRef;
889 VariantInit(&vDst);
890
891 hres = VariantCopyInd(&vDst, &vSrc);
892 ok(hres == S_OK, "VariantCopyInd failed: 0x%08x\n", hres);
893 ok(V_VT(&vDst) == VT_UI1 && V_UI1(&vDst) == 0x88,
894 "CopyInd(deref): expected dst vt = VT_UI1, val 0x77, got %d|0x%X, 0x%2X\n",
895 V_VT(&vDst) & VT_TYPEMASK, V_VT(&vDst) & ~VT_TYPEMASK, V_UI1(&vDst));
896
897 /* But a by-reference variant to a by-reference variant fails */
898 V_VT(&vRef2) = VT_UI1;
899 V_UI1(&vRef2) = 0x77;
900 V_VT(&vRef) = VT_VARIANT|VT_BYREF;
901 V_VARIANTREF(&vRef) = &vRef2;
902 V_VT(&vSrc) = VT_VARIANT|VT_BYREF;
903 V_VARIANTREF(&vSrc) = &vRef;
904 VariantInit(&vDst);
905
906 hres = VariantCopyInd(&vDst, &vSrc);
907 ok(hres == E_INVALIDARG,
908 "CopyInd(ref->ref): expected E_INVALIDARG, got 0x%08x\n", hres);
909 }
910
911 static HRESULT (WINAPI *pVarParseNumFromStr)(OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
912
913 /* Macros for converting and testing the result of VarParseNumFromStr */
914 #define FAILDIG 255
915
916 static HRESULT convert_str( const char *str, INT dig, ULONG flags,
917 NUMPARSE *np, BYTE rgb[128], LCID lcid )
918 {
919 OLECHAR buff[128];
920 MultiByteToWideChar( CP_ACP,0, str, -1, buff, sizeof(buff)/sizeof(WCHAR) );
921 memset( rgb, FAILDIG, 128 );
922 memset( np, 255, sizeof(*np) );
923 np->cDig = dig;
924 np->dwInFlags = flags;
925 return pVarParseNumFromStr( buff, lcid, LOCALE_NOUSEROVERRIDE, np, rgb);
926 }
927
928 static void expect_NumFromStr( int line, HRESULT hres, NUMPARSE *np, INT a, ULONG b, ULONG c,
929 INT d, INT e, INT f )
930 {
931 if (hres == (HRESULT)S_OK)
932 {
933 ok_(__FILE__,line)(np->cDig == a, "Expected cDig = %d, got %d\n", a, np->cDig);
934 ok_(__FILE__,line)(np->dwInFlags == b, "Expected dwInFlags = 0x%x, got 0x%x\n", b, np->dwInFlags);
935 ok_(__FILE__,line)(np->dwOutFlags == c, "Expected dwOutFlags = 0x%x, got 0x%x\n", c, np->dwOutFlags);
936 ok_(__FILE__,line)(np->cchUsed == d, "Expected cchUsed = %d, got %d\n", d, np->cchUsed);
937 ok_(__FILE__,line)(np->nBaseShift == e, "Expected nBaseShift = %d, got %d\n", e, np->nBaseShift);
938 ok_(__FILE__,line)(np->nPwr10 == f, "Expected nPwr10 = %d, got %d\n", f, np->nPwr10);
939 }
940 }
941
942 #define CONVERTN(str,dig,flags) hres = convert_str( str, dig, flags, &np, rgb, lcid )
943 #define CONVERT(str,flags) CONVERTN(str,sizeof(rgb),flags)
944 #define EXPECT(a,b,c,d,e,f) expect_NumFromStr( __LINE__, hres, &np, a, b, c, d, e, f )
945 #define EXPECTRGB(a,b) ok(rgb[a] == b, "Digit[%d], expected %d, got %d\n", a, b, rgb[a])
946 #define EXPECTFAIL ok(hres == (HRESULT)DISP_E_TYPEMISMATCH, "Call succeeded, hres = %08x\n", hres)
947 #define EXPECT2(a,b) EXPECTRGB(0,a); EXPECTRGB(1,b)
948
949 static void test_VarParseNumFromStr(void)
950 {
951 HRESULT hres;
952 /* Ensure all tests are using the same locale characters for '$', ',' etc */
953 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
954 NUMPARSE np;
955 BYTE rgb[128];
956
957 /** No flags **/
958
959 CHECKPTR(VarParseNumFromStr);
960
961 /* Consume a single digit */
962 CONVERT("7", 0);
963 EXPECT(1,0,0,1,0,0);
964 EXPECT2(7,FAILDIG);
965
966 /* cDig is not literal digits - zeros are suppressed and nPwr10 is increased */
967 CONVERT("10", 0);
968 EXPECT(1,0,0,2,0,1);
969 /* Note: Win32 writes the trailing zeros if they are within cDig's limits,
970 * but then excludes them from the returned cDig count.
971 * In our implementation we don't bother writing them at all.
972 */
973 EXPECTRGB(0, 1);
974
975 /* if cDig is too small and numbers follow, sets INEXACT */
976 CONVERTN("11",1, 0);
977 EXPECT(1,0,NUMPRS_INEXACT,2,0,1);
978 EXPECT2(1,FAILDIG);
979
980 /* Strips leading zeros */
981 CONVERT("01", 0);
982 EXPECT(1,0,0,2,0,0);
983 EXPECT2(1,FAILDIG);
984
985 /* Strips leading zeros */
986 CONVERTN("01",1, 0);
987 EXPECT(1,0,0,2,0,0);
988 EXPECT2(1,FAILDIG);
989
990
991 /* Fails on non digits */
992 CONVERT("a", 0);
993 EXPECTFAIL;
994 EXPECTRGB(0,FAILDIG);
995
996 /** NUMPRS_LEADING_WHITE/NUMPRS_TRAILING_WHITE **/
997
998 /* Without flag, fails on whitespace */
999 CONVERT(" 0", 0);
1000 EXPECTFAIL;
1001 EXPECTRGB(0,FAILDIG);
1002
1003
1004 /* With flag, consumes whitespace */
1005 CONVERT(" 0", NUMPRS_LEADING_WHITE);
1006 EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1007 EXPECT2(0,FAILDIG);
1008
1009 /* Test TAB once, then assume it acts as space for all cases */
1010 CONVERT("\t0", NUMPRS_LEADING_WHITE);
1011 EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1012 EXPECT2(0,FAILDIG);
1013
1014
1015 /* Doesn't pick up trailing whitespace without flag */
1016 CONVERT("0 ", 0);
1017 EXPECT(1,0,0,1,0,0);
1018 EXPECT2(0,FAILDIG);
1019
1020 /* With flag, consumes trailing whitespace */
1021 CONVERT("0 ", NUMPRS_TRAILING_WHITE);
1022 EXPECT(1,NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1023 EXPECT2(0,FAILDIG);
1024
1025 /* Leading flag only consumes leading */
1026 CONVERT(" 0 ", NUMPRS_LEADING_WHITE);
1027 EXPECT(1,NUMPRS_LEADING_WHITE,NUMPRS_LEADING_WHITE,2,0,0);
1028 EXPECT2(0,FAILDIG);
1029
1030 /* Both flags consumes both */
1031 CONVERT(" 0 ", NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE);
1032 EXPECT(1,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,NUMPRS_LEADING_WHITE|NUMPRS_TRAILING_WHITE,3,0,0);
1033 EXPECT2(0,FAILDIG);
1034
1035 /** NUMPRS_LEADING_PLUS/NUMPRS_TRAILING_PLUS **/
1036
1037 /* Without flag, fails on + */
1038 CONVERT("+0", 0);
1039 EXPECTFAIL;
1040 EXPECTRGB(0,FAILDIG);
1041
1042 /* With flag, consumes + */
1043 CONVERT("+0", NUMPRS_LEADING_PLUS);
1044 EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1045 EXPECT2(0,FAILDIG);
1046
1047 /* Without flag, doesn't consume trailing + */
1048 CONVERT("0+", 0);
1049 EXPECT(1,0,0,1,0,0);
1050 EXPECT2(0,FAILDIG);
1051
1052 /* With flag, consumes trailing + */
1053 CONVERT("0+", NUMPRS_TRAILING_PLUS);
1054 EXPECT(1,NUMPRS_TRAILING_PLUS,NUMPRS_TRAILING_PLUS,2,0,0);
1055 EXPECT2(0,FAILDIG);
1056
1057 /* With leading flag, doesn't consume trailing + */
1058 CONVERT("+0+", NUMPRS_LEADING_PLUS);
1059 EXPECT(1,NUMPRS_LEADING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1060 EXPECT2(0,FAILDIG);
1061
1062 /* Trailing + doesn't get consumed if we specify both (unlike whitespace) */
1063 CONVERT("+0+", NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS);
1064 EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_TRAILING_PLUS,NUMPRS_LEADING_PLUS,2,0,0);
1065 EXPECT2(0,FAILDIG);
1066
1067 /** NUMPRS_LEADING_MINUS/NUMPRS_TRAILING_MINUS **/
1068
1069 /* Without flag, fails on - */
1070 CONVERT("-0", 0);
1071 EXPECTFAIL;
1072 EXPECTRGB(0,FAILDIG);
1073
1074 /* With flag, consumes - */
1075 CONVERT("-0", NUMPRS_LEADING_MINUS);
1076 EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1077 EXPECT2(0,FAILDIG);
1078
1079 /* Without flag, doesn't consume trailing - */
1080 CONVERT("0-", 0);
1081 EXPECT(1,0,0,1,0,0);
1082 EXPECT2(0,FAILDIG);
1083
1084 /* With flag, consumes trailing - */
1085 CONVERT("0-", NUMPRS_TRAILING_MINUS);
1086 EXPECT(1,NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_TRAILING_MINUS,2,0,0);
1087 EXPECT2(0,FAILDIG);
1088
1089 /* With leading flag, doesn't consume trailing - */
1090 CONVERT("-0-", NUMPRS_LEADING_MINUS);
1091 EXPECT(1,NUMPRS_LEADING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1092 EXPECT2(0,FAILDIG);
1093
1094 /* Trailing - doesn't get consumed if we specify both (unlike whitespace) */
1095 CONVERT("-0-", NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS);
1096 EXPECT(1,NUMPRS_LEADING_MINUS|NUMPRS_TRAILING_MINUS,NUMPRS_NEG|NUMPRS_LEADING_MINUS,2,0,0);
1097 EXPECT2(0,FAILDIG);
1098
1099 /** NUMPRS_HEX_OCT **/
1100
1101 /* Could be hex, octal or decimal - With flag reads as decimal */
1102 CONVERT("0", NUMPRS_HEX_OCT);
1103 EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1104 EXPECT2(0,FAILDIG);
1105
1106 /* Doesn't recognise hex in .asm syntax */
1107 CONVERT("0h", NUMPRS_HEX_OCT);
1108 EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1109 EXPECT2(0,FAILDIG);
1110
1111 /* Doesn't fail with valid leading string but no digits */
1112 CONVERT("0x", NUMPRS_HEX_OCT);
1113 EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1114 EXPECT2(0,FAILDIG);
1115
1116 /* Doesn't recognise hex format numbers at all! */
1117 CONVERT("0x0", NUMPRS_HEX_OCT);
1118 EXPECT(1,NUMPRS_HEX_OCT,0,1,0,0);
1119 EXPECT2(0,FAILDIG);
1120
1121 /* Doesn't recognise plain hex digits either */
1122 CONVERT("FE", NUMPRS_HEX_OCT);
1123 EXPECTFAIL;
1124 EXPECTRGB(0,FAILDIG);
1125
1126 /* Octal */
1127 CONVERT("0100", NUMPRS_HEX_OCT);
1128 EXPECT(1,NUMPRS_HEX_OCT,0,4,0,2);
1129 EXPECTRGB(0,1);
1130 EXPECTRGB(1,0);
1131 EXPECTRGB(2,0);
1132 EXPECTRGB(3,FAILDIG);
1133
1134 /* VB hex */
1135 CONVERT("&HF800", NUMPRS_HEX_OCT);
1136 EXPECT(4,NUMPRS_HEX_OCT,0x40,6,4,0);
1137 EXPECTRGB(0,15);
1138 EXPECTRGB(1,8);
1139 EXPECTRGB(2,0);
1140 EXPECTRGB(3,0);
1141 EXPECTRGB(4,FAILDIG);
1142
1143 /* VB hex lower case and leading zero */
1144 CONVERT("&h0abcdef", NUMPRS_HEX_OCT);
1145 EXPECT(6,NUMPRS_HEX_OCT,0x40,9,4,0);
1146 EXPECTRGB(0,10);
1147 EXPECTRGB(1,11);
1148 EXPECTRGB(2,12);
1149 EXPECTRGB(3,13);
1150 EXPECTRGB(4,14);
1151 EXPECTRGB(5,15);
1152 EXPECTRGB(6,FAILDIG);
1153
1154 /* VB oct */
1155 CONVERT("&O300", NUMPRS_HEX_OCT);
1156 EXPECT(3,NUMPRS_HEX_OCT,0x40,5,3,0);
1157 EXPECTRGB(0,3);
1158 EXPECTRGB(1,0);
1159 EXPECTRGB(2,0);
1160 EXPECTRGB(3,FAILDIG);
1161
1162 /* VB oct lower case and leading zero */
1163 CONVERT("&o0777", NUMPRS_HEX_OCT);
1164 EXPECT(3,NUMPRS_HEX_OCT,0x40,6,3,0);
1165 EXPECTRGB(0,7);
1166 EXPECTRGB(1,7);
1167 EXPECTRGB(2,7);
1168 EXPECTRGB(3,FAILDIG);
1169
1170 /* VB oct char bigger than 7 */
1171 CONVERT("&o128", NUMPRS_HEX_OCT);
1172 /*
1173 Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
1174 EXPECTFAIL;
1175 EXPECTRGB(0,FAILDIG);
1176 */
1177 /** NUMPRS_PARENS **/
1178
1179 /* Empty parens = error */
1180 CONVERT("()", NUMPRS_PARENS);
1181 EXPECTFAIL;
1182 EXPECTRGB(0,FAILDIG);
1183
1184 /* With flag, trailing parens not consumed */
1185 CONVERT("0()", NUMPRS_PARENS);
1186 EXPECT(1,NUMPRS_PARENS,0,1,0,0);
1187 EXPECT2(0,FAILDIG);
1188
1189 /* With flag, Number in parens made negative and parens consumed */
1190 CONVERT("(0)", NUMPRS_PARENS);
1191 EXPECT(1,NUMPRS_PARENS,NUMPRS_NEG|NUMPRS_PARENS,3,0,0);
1192 EXPECT2(0,FAILDIG);
1193
1194 /** NUMPRS_THOUSANDS **/
1195
1196 /* With flag, thousands sep. not needed */
1197 CONVERT("0", NUMPRS_THOUSANDS);
1198 EXPECT(1,NUMPRS_THOUSANDS,0,1,0,0);
1199 EXPECT2(0,FAILDIG);
1200
1201 /* With flag, thousands sep. and following digits consumed */
1202 CONVERT("1,000", NUMPRS_THOUSANDS);
1203 EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1204 EXPECTRGB(0,1);
1205
1206 /* With flag and decimal point, thousands sep. but not decimals consumed */
1207 CONVERT("1,000.0", NUMPRS_THOUSANDS);
1208 EXPECT(1,NUMPRS_THOUSANDS,NUMPRS_THOUSANDS,5,0,3);
1209 EXPECTRGB(0,1);
1210
1211 /** NUMPRS_CURRENCY **/
1212
1213 /* Without flag, chokes on currency sign */
1214 CONVERT("$11", 0);
1215 EXPECTFAIL;
1216 EXPECTRGB(0,FAILDIG);
1217
1218 /* With flag, consumes currency sign */
1219 CONVERT("$11", NUMPRS_CURRENCY);
1220 EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1221 EXPECT2(1,1);
1222 EXPECTRGB(2,FAILDIG);
1223
1224 /* With flag only, doesn't consume decimal point */
1225 CONVERT("$11.1", NUMPRS_CURRENCY);
1226 EXPECT(2,NUMPRS_CURRENCY,NUMPRS_CURRENCY,3,0,0);
1227 EXPECT2(1,1);
1228 EXPECTRGB(2,FAILDIG);
1229
1230 /* With flag and decimal flag, consumes decimal point and following digits */
1231 CONVERT("$11.1", NUMPRS_CURRENCY|NUMPRS_DECIMAL);
1232 EXPECT(3,NUMPRS_CURRENCY|NUMPRS_DECIMAL,NUMPRS_CURRENCY|NUMPRS_DECIMAL,5,0,-1);
1233 EXPECT2(1,1);
1234 EXPECTRGB(2,1);
1235 EXPECTRGB(3,FAILDIG);
1236
1237 /* Thousands flag can only be used with currency */
1238 CONVERT("$1,234", NUMPRS_CURRENCY|NUMPRS_THOUSANDS);
1239 EXPECT(4,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,NUMPRS_CURRENCY|NUMPRS_THOUSANDS,6,0,0);
1240 EXPECT2(1,2);
1241 EXPECTRGB(2,3);
1242 EXPECTRGB(3,4);
1243 EXPECTRGB(4,FAILDIG);
1244
1245 /** NUMPRS_DECIMAL **/
1246
1247 /* With flag, consumes decimal point */
1248 CONVERT("1.1", NUMPRS_DECIMAL);
1249 EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1250 EXPECT2(1,1);
1251 EXPECTRGB(2,FAILDIG);
1252
1253 /* With flag, consumes decimal point. Skipping the decimal part is not an error */
1254 CONVERT("1.", NUMPRS_DECIMAL);
1255 EXPECT(1,NUMPRS_DECIMAL,NUMPRS_DECIMAL,2,0,0);
1256 EXPECT2(1,FAILDIG);
1257
1258 /* Consumes only one decimal point */
1259 CONVERT("1.1.", NUMPRS_DECIMAL);
1260 EXPECT(2,NUMPRS_DECIMAL,NUMPRS_DECIMAL,3,0,-1);
1261 EXPECT2(1,1);
1262 EXPECTRGB(2,FAILDIG);
1263
1264 /** NUMPRS_EXPONENT **/
1265
1266 /* Without flag, doesn't consume exponent */
1267 CONVERT("1e1", 0);
1268 EXPECT(1,0,0,1,0,0);
1269 EXPECT2(1,FAILDIG);
1270
1271 /* With flag, consumes exponent */
1272 CONVERT("1e1", NUMPRS_EXPONENT);
1273 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1274 EXPECT2(1,FAILDIG);
1275
1276 /* Negative exponents are accepted without flags */
1277 CONVERT("1e-1", NUMPRS_EXPONENT);
1278 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,-1);
1279 EXPECT2(1,FAILDIG);
1280
1281 /* As are positive exponents and leading exponent 0s */
1282 CONVERT("1e+01", NUMPRS_EXPONENT);
1283 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,5,0,1);
1284 EXPECT2(1,FAILDIG);
1285
1286 /* The same for zero exponents */
1287 CONVERT("1e0", NUMPRS_EXPONENT);
1288 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,0);
1289 EXPECT2(1,FAILDIG);
1290
1291 /* Sign on a zero exponent doesn't matter */
1292 CONVERT("1e+0", NUMPRS_EXPONENT);
1293 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1294 EXPECT2(1,FAILDIG);
1295
1296 CONVERT("1e-0", NUMPRS_EXPONENT);
1297 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,4,0,0);
1298 EXPECT2(1,FAILDIG);
1299
1300 /* Doesn't consume a real number exponent */
1301 CONVERT("1e1.", NUMPRS_EXPONENT);
1302 EXPECT(1,NUMPRS_EXPONENT,NUMPRS_EXPONENT,3,0,1);
1303 EXPECT2(1,FAILDIG);
1304
1305 /* Powers of 10 are calculated from the position of any decimal point */
1306 CONVERT("1.5e20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1307 EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,6,0,19);
1308 EXPECT2(1,5);
1309
1310 CONVERT("1.5e-20", NUMPRS_EXPONENT|NUMPRS_DECIMAL);
1311 EXPECT(2,NUMPRS_EXPONENT|NUMPRS_DECIMAL,NUMPRS_EXPONENT|NUMPRS_DECIMAL,7,0,-21);
1312 EXPECT2(1,5);
1313
1314 /** NUMPRS_USE_ALL **/
1315
1316 /* Flag expects all digits */
1317 CONVERT("0", NUMPRS_USE_ALL);
1318 EXPECT(1,NUMPRS_USE_ALL,0,1,0,0);
1319 EXPECT2(0,FAILDIG);
1320
1321 /* Rejects anything trailing */
1322 CONVERT("0 ", NUMPRS_USE_ALL);
1323 EXPECTFAIL;
1324 EXPECT2(0,FAILDIG);
1325
1326 /* Unless consumed by trailing flag */
1327 CONVERT("0 ", NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE);
1328 EXPECT(1,NUMPRS_USE_ALL|NUMPRS_TRAILING_WHITE,NUMPRS_TRAILING_WHITE,2,0,0);
1329 EXPECT2(0,FAILDIG);
1330
1331 /** Combinations **/
1332
1333 /* Leading whitespace and plus, doesn't consume trailing whitespace */
1334 CONVERT("+ 0 ", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1335 EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1336 EXPECT2(0,FAILDIG);
1337
1338 /* Order of whitespace and plus is unimportant */
1339 CONVERT(" +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1340 EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,3,0,0);
1341 EXPECT2(0,FAILDIG);
1342
1343 /* Leading whitespace can be repeated */
1344 CONVERT(" + 0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1345 EXPECT(1,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE,4,0,0);
1346 EXPECT2(0,FAILDIG);
1347
1348 /* But plus/minus etc. cannot */
1349 CONVERT("+ +0", NUMPRS_LEADING_PLUS|NUMPRS_LEADING_WHITE);
1350 EXPECTFAIL;
1351 EXPECTRGB(0,FAILDIG);
1352
1353 /* Inexact is not set if trailing zeros are removed */
1354 CONVERTN("10", 1, 0);
1355 EXPECT(1,0,0,2,0,1);
1356 EXPECT2(1,FAILDIG);
1357
1358 /* Make sure a leading 0 is stripped but decimals after it get read */
1359 CONVERT("-0.51", NUMPRS_STD);
1360 EXPECT(2,NUMPRS_STD,NUMPRS_NEG|NUMPRS_DECIMAL|NUMPRS_LEADING_MINUS,5,0,-2);
1361 EXPECT2(5,1);
1362
1363 /* Keep trailing zeros on whole number part of a decimal */
1364 CONVERT("10.1", NUMPRS_STD);
1365 EXPECT(3,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1366 EXPECT2(1,0);
1367 EXPECTRGB(2,1);
1368
1369 /* Zeros after decimal sign */
1370 CONVERT("0.01", NUMPRS_STD);
1371 EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-2);
1372 EXPECT2(1,FAILDIG);
1373
1374 /* Trailing zeros after decimal part */
1375 CONVERT("0.10", NUMPRS_STD);
1376 EXPECT(1,NUMPRS_STD,NUMPRS_DECIMAL,4,0,-1);
1377 EXPECT2(1,0);
1378 }
1379
1380 static HRESULT (WINAPI *pVarNumFromParseNum)(NUMPARSE*,BYTE*,ULONG,VARIANT*);
1381
1382 /* Macros for converting and testing the result of VarNumFromParseNum */
1383 #define SETRGB(indx,val) if (!indx) memset(rgb, FAILDIG, sizeof(rgb)); rgb[indx] = val
1384 #undef CONVERT
1385 #define CONVERT(a,b,c,d,e,f,bits) \
1386 np.cDig = (a); np.dwInFlags = (b); np.dwOutFlags = (c); np.cchUsed = (d); \
1387 np.nBaseShift = (e); np.nPwr10 = (f); hres = pVarNumFromParseNum(&np, rgb, bits, &vOut)
1388 static const char *szFailOverflow = "Expected overflow, hres = %08x\n";
1389 #define EXPECT_OVERFLOW ok(hres == (HRESULT)DISP_E_OVERFLOW, szFailOverflow, hres)
1390 static const char *szFailOk = "Call failed, hres = %08x\n";
1391 #define EXPECT_OK ok(hres == (HRESULT)S_OK, szFailOk, hres); \
1392 if (hres == (HRESULT)S_OK)
1393 #define EXPECT_TYPE(typ) ok(V_VT(&vOut) == typ,"Expected Type = " #typ ", got %d\n", V_VT(&vOut))
1394 #define EXPECT_I1(val) EXPECT_OK { EXPECT_TYPE(VT_I1); \
1395 ok(V_I1(&vOut) == val, "Expected i1 = %d, got %d\n", (signed char)val, V_I1(&vOut)); }
1396 #define EXPECT_UI1(val) EXPECT_OK { EXPECT_TYPE(VT_UI1); \
1397 ok(V_UI1(&vOut) == val, "Expected ui1 = %d, got %d\n", (BYTE)val, V_UI1(&vOut)); }
1398 #define EXPECT_I2(val) EXPECT_OK { EXPECT_TYPE(VT_I2); \
1399 ok(V_I2(&vOut) == val, "Expected i2 = %d, got %d\n", (SHORT)val, V_I2(&vOut)); }
1400 #define EXPECT_UI2(val) EXPECT_OK { EXPECT_TYPE(VT_UI2); \
1401 ok(V_UI2(&vOut) == val, "Expected ui2 = %d, got %d\n", (USHORT)val, V_UI2(&vOut)); }
1402 #define EXPECT_I4(val) EXPECT_OK { EXPECT_TYPE(VT_I4); \
1403 ok(V_I4(&vOut) == val, "Expected i4 = %d, got %d\n", (LONG)val, V_I4(&vOut)); }
1404 #define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
1405 ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
1406 #define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
1407 ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
1408 (LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
1409 #define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
1410 ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
1411 (DWORD)((ULONG64)val >> 32), (DWORD)(ULONG64)val, (DWORD)(V_UI8(&vOut) >> 32), (DWORD)V_UI8(&vOut)); }
1412 #define EXPECT_R4(val) EXPECT_OK { EXPECT_TYPE(VT_R4); \
1413 ok(V_R4(&vOut) == val, "Expected r4 = %f, got %f\n", val, V_R4(&vOut)); }
1414 #define EXPECT_R8(val) EXPECT_OK { EXPECT_TYPE(VT_R8); \
1415 ok(V_R8(&vOut) == val, "Expected r8 = %g, got %g\n", val, V_R8(&vOut)); }
1416 #define CY_MULTIPLIER 10000
1417 #define EXPECT_CY(val) EXPECT_OK { EXPECT_TYPE(VT_CY); \
1418 ok(V_CY(&vOut).int64 == (LONG64)(val * CY_MULTIPLIER), "Expected r8 = 0x%x%08x, got 0x%x%08x\n", \
1419 (DWORD)((LONG64)val >> 23), (DWORD)(LONG64)val, (DWORD)(V_CY(&vOut).int64 >>32), (DWORD)V_CY(&vOut).int64); }
1420 #define EXPECT_DECIMAL(valHi, valMid, valLo) EXPECT_OK { EXPECT_TYPE(VT_DECIMAL); \
1421 ok((V_DECIMAL(&vOut).Hi32 == valHi) && (S1(U1(V_DECIMAL(&vOut))).Mid32 == valMid) && \
1422 (S1(U1(V_DECIMAL(&vOut))).Lo32 == valLo), \
1423 "Expected decimal = %x/0x%x%08x, got %x/0x%x%08x\n", valHi, valMid, valLo, \
1424 V_DECIMAL(&vOut).Hi32, S1(U1(V_DECIMAL(&vOut))).Mid32, S1(U1(V_DECIMAL(&vOut))).Lo32); }
1425
1426 static void test_VarNumFromParseNum(void)
1427 {
1428 HRESULT hres;
1429 NUMPARSE np;
1430 BYTE rgb[128];
1431 VARIANT vOut;
1432
1433 CHECKPTR(VarNumFromParseNum);
1434
1435 /* Convert the number 1 to different types */
1436 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1); EXPECT_I1(1);
1437 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_UI1); EXPECT_UI1(1);
1438 /* Prefers a signed type to unsigned of the same size */
1439 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I1|VTBIT_UI1); EXPECT_I1(1);
1440 /* But takes the smaller size if possible */
1441 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_I2|VTBIT_UI1); EXPECT_UI1(1);
1442
1443 /* Try different integer sizes */
1444 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1445
1446 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, INTEGER_VTBITS); EXPECT_I1(1);
1447 /* 127 */
1448 SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 7);
1449 CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I1(127);
1450 /* 128 */
1451 SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1452 CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(128);
1453 /* 255 */
1454 SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 5);
1455 CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_UI1(255);
1456 /* 256 */
1457 SETRGB(0, 2); SETRGB(1, 5); SETRGB(2, 6);
1458 CONVERT(3,0,0,3,0,0, INTEGER_VTBITS); EXPECT_I2(256);
1459 /* 32767 */
1460 SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 7);
1461 CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_I2(32767);
1462 /* 32768 */
1463 SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1464 CONVERT(5,0,0,5,0,0, INTEGER_VTBITS); EXPECT_UI2(32768);
1465
1466 /* Assume the above pattern holds for remaining positive integers; test negative */
1467
1468 /* -128 */
1469 SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 8);
1470 CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I1(-128);
1471 /* -129 */
1472 SETRGB(0, 1); SETRGB(1, 2); SETRGB(2, 9);
1473 CONVERT(3,0,NUMPRS_NEG,3,0,0, INTEGER_VTBITS); EXPECT_I2(-129);
1474 /* -32768 */
1475 SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 8);
1476 CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I2(-32768);
1477 /* -32768 */
1478 SETRGB(0, 3); SETRGB(1, 2); SETRGB(2, 7); SETRGB(3, 6); SETRGB(4, 9);
1479 CONVERT(5,0,NUMPRS_NEG,5,0,0, INTEGER_VTBITS); EXPECT_I4(-32769);
1480
1481 /* Assume the above pattern holds for remaining negative integers */
1482
1483 /* Test hexadecimal conversions */
1484 SETRGB(0, 1); CONVERT(1,0,0,1,4,0, INTEGER_VTBITS); EXPECT_I1(0x01);
1485 /* 0x7f */
1486 SETRGB(0, 7); SETRGB(1, 0xf);
1487 CONVERT(2,0,0,2,4,0, INTEGER_VTBITS); EXPECT_I1(0x7f);
1488 SETRGB(0, 7); SETRGB(1, 0xf);
1489 CONVERT(2,0,0,2,4,0, VTBIT_DECIMAL); EXPECT_DECIMAL(0,0,0x7f);
1490 /* 0x7fff */
1491 SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1492 CONVERT(4,0,0,4,4,0, INTEGER_VTBITS); EXPECT_I2(0x7fff);
1493 /* 0x7fffffff */
1494 SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1495 SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1496 CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x7fffffffL);
1497 /* 0x7fffffffffffffff (64 bits) */
1498 SETRGB(0, 7); SETRGB(1, 0xf); SETRGB(2, 0xf); SETRGB(3, 0xf);
1499 SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
1500 SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
1501 SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
1502 if (HAVE_OLEAUT32_I8)
1503 {
1504 /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1505 truncate the number to the smallest integer size requested:
1506 CONVERT(16,0,0,16,4,0, INTEGER_VTBITS); EXPECT_I1((signed char)0xff); */
1507 CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x7fffffff,0xffffffff);
1508 }
1509
1510 /* Assume the above pattern holds for numbers without hi-bit set, test (preservation of) hi-bit */
1511 /* 0x82 */
1512 SETRGB(0, 8); SETRGB(1, 2);
1513 CONVERT(2,0,0,2,4,0, INTEGER_VTBITS);
1514 EXPECT_I1((signed char)0x82);
1515 /* 0x8002 */
1516 SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1517 CONVERT(4,0,0,4,4,0, INTEGER_VTBITS);
1518 EXPECT_I2((signed short)0x8002);
1519 /* 0x80000002 */
1520 SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1521 SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1522 CONVERT(8,0,0,8,4,0, INTEGER_VTBITS); EXPECT_I4(0x80000002);
1523 /* 0x8000000000000002 (64 bits) */
1524 SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1525 SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1526 SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1527 SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1528 if (HAVE_OLEAUT32_I8)
1529 {
1530 /* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
1531 truncate the number to the smallest integer size requested:
1532 CONVERT(16,0,0,16,4,0, INTEGER_VTBITS & ~VTBIT_I1);
1533 EXPECT_I2((signed short)0x0002); */
1534 CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1535 }
1536
1537 /* Test (preservation of) hi-bit with STRICT type requesting */
1538 /* 0x82 */
1539 SETRGB(0, 8); SETRGB(1, 2);
1540 CONVERT(2,0,0,2,4,0, VTBIT_I1);
1541 EXPECT_I1((signed char)0x82);
1542 /* 0x8002 */
1543 SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 2);
1544 CONVERT(4,0,0,4,4,0, VTBIT_I2);
1545 EXPECT_I2((signed short)0x8002);
1546 /* 0x80000002 */
1547 SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1548 SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 2);
1549 CONVERT(8,0,0,8,4,0, VTBIT_I4); EXPECT_I4(0x80000002);
1550 /* 0x8000000000000002 (64 bits) */
1551 SETRGB(0, 8); SETRGB(1, 0); SETRGB(2, 0); SETRGB(3, 0);
1552 SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
1553 SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
1554 SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
1555 if (HAVE_OLEAUT32_I8)
1556 {
1557 CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
1558 }
1559 /* Assume the above pattern holds for numbers with hi-bit set */
1560
1561 /* Negative numbers overflow if we have only unsigned outputs */
1562 /* -1 */
1563 SETRGB(0, 1); CONVERT(1,0,NUMPRS_NEG,1,0,0, VTBIT_UI1); EXPECT_OVERFLOW;
1564 /* -0.6 */
1565 SETRGB(0, 6); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_OVERFLOW;
1566
1567 /* Except that rounding is done first, so -0.5 to 0 are accepted as 0 */
1568 /* -0.5 */
1569 SETRGB(0, 5); CONVERT(1,0,NUMPRS_NEG,1,0,~0u, VTBIT_UI1); EXPECT_UI1(0);
1570
1571 /* Floating point zero is OK */
1572 /* 0.00000000E0 */
1573 SETRGB(0, 0); CONVERT(1,0,NUMPRS_DECIMAL|NUMPRS_EXPONENT,12,0,-8, VTBIT_R8);
1574 EXPECT_R8(0.0);
1575
1576 /* Float is acceptable for an integer input value */
1577 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4); EXPECT_R4(1.0f);
1578 /* As is double */
1579 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8); EXPECT_R8(1.0);
1580 /* As is currency */
1581 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY); EXPECT_CY(1);
1582
1583 /* Float is preferred over double */
1584 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R4|VTBIT_R8); EXPECT_R4(1.0f);
1585
1586 /* Double is preferred over currency */
1587 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_R8|VTBIT_CY); EXPECT_R8(1.0);
1588
1589 /* Currency is preferred over decimal */
1590 SETRGB(0, 1); CONVERT(1,0,0,1,0,0, VTBIT_CY|VTBIT_DECIMAL); EXPECT_CY(1);
1591 }
1592
1593
1594 static void test_UdateFromDate( int line, DATE dt, ULONG flags, HRESULT r, WORD d, WORD m, WORD y,
1595 WORD h, WORD mn, WORD s, WORD ms, WORD dw, WORD dy)
1596 {
1597 UDATE ud;
1598 HRESULT res;
1599
1600 memset(&ud, 0, sizeof(ud));
1601 res = pVarUdateFromDate(dt, flags, &ud);
1602 ok_(__FILE__,line)(r == res && (res != S_OK || (ud.st.wYear == y && ud.st.wMonth == m && ud.st.wDay == d &&
1603 ud.st.wHour == h && ud.st.wMinute == mn && ud.st.wSecond == s &&
1604 ud.st.wMilliseconds == ms && ud.st.wDayOfWeek == dw && ud.wDayOfYear == dy)),
1605 "%.16g expected res(%x) %d,%d,%d,%d,%d,%d,%d %d %d, got res(%x) %d,%d,%d,%d,%d,%d,%d %d %d\n",
1606 dt, r, d, m, y, h, mn, s, ms, dw, dy,
1607 res, ud.st.wDay, ud.st.wMonth, ud.st.wYear, ud.st.wHour, ud.st.wMinute,
1608 ud.st.wSecond, ud.st.wMilliseconds, ud.st.wDayOfWeek, ud.wDayOfYear );
1609 }
1610 #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)
1611
1612 static void test_VarUdateFromDate(void)
1613 {
1614 CHECKPTR(VarUdateFromDate);
1615 DT2UD(29221.0,0,S_OK,1,1,1980,0,0,0,0,2,1); /* 1 Jan 1980 */
1616 DT2UD(29222.0,0,S_OK,2,1,1980,0,0,0,0,3,2); /* 2 Jan 1980 */
1617 DT2UD(33238.0,0,S_OK,31,12,1990,0,0,0,0,1,365); /* 31 Dec 1990 */
1618 DT2UD(0.0,0,S_OK,30,12,1899,0,0,0,0,6,364); /* 30 Dec 1899 - VT_DATE 0.0 */
1619 DT2UD(-657434.0,0,S_OK,1,1,100,0,0,0,0,5,1); /* 1 Jan 100 - Min */
1620 DT2UD(-657435.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* < 1 Jan 100 => err */
1621 DT2UD(2958465.0,0,S_OK,31,12,9999,0,0,0,0,5,365); /* 31 Dec 9999 - Max */
1622 DT2UD(2958466.0,0,E_INVALIDARG,0,0,0,0,0,0,0,0,0); /* > 31 Dec 9999 => err */
1623
1624 /* VAR_VALIDDATE doesn't prevent upper and lower bounds being checked */
1625 DT2UD(-657435.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1626 DT2UD(2958466.0,VAR_VALIDDATE,E_INVALIDARG,0,0,0,0,0,0,0,0,0);
1627
1628 /* Times */
1629 DT2UD(29221.25,0,S_OK,1,1,1980,6,0,0,0,2,1); /* 6 AM */
1630 DT2UD(29221.33333333,0,S_OK,1,1,1980,8,0,0,0,2,1); /* 8 AM */
1631 DT2UD(29221.5,0,S_OK,1,1,1980,12,0,0,0,2,1); /* 12 AM */
1632 DT2UD(29221.9888884444,0,S_OK,1,1,1980,23,44,0,0,2,1); /* 11:44 PM */
1633 DT2UD(29221.7508765432,0,S_OK,1,1,1980,18,1,16,0,2,1); /* 6:18:02 PM */
1634
1635 /* Test handling of times on dates prior to the epoch */
1636 DT2UD(-5.25,0,S_OK,25,12,1899,6,0,0,0,1,359);
1637 DT2UD(-5.9999884259259,0,S_OK,25,12,1899,23,59,59,0,1,359);
1638 /* This just demonstrates the non-linear nature of values prior to the epoch */
1639 DT2UD(-4.0,0,S_OK,26,12,1899,0,0,0,0,2,360);
1640 /* Numerical oddity: for 0.0 < x < 1.0, x and -x represent the same datetime */
1641 DT2UD(-0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1642 DT2UD(0.25,0,S_OK,30,12,1899,6,0,0,0,6,364);
1643 }
1644
1645
1646 static void test_DateFromUDate( int line, WORD d, WORD m, WORD y, WORD h, WORD mn, WORD s, WORD ms,
1647 WORD dw, WORD dy, ULONG flags, HRESULT r, DATE dt )
1648 {
1649 UDATE ud;
1650 double out;
1651 HRESULT res;
1652
1653 ud.st.wYear = y;
1654 ud.st.wMonth = m;
1655 ud.st.wDay = d;
1656 ud.st.wHour = h;
1657 ud.st.wMinute = mn;
1658 ud.st.wSecond = s;
1659 ud.st.wMilliseconds = ms;
1660 ud.st.wDayOfWeek = dw;
1661 ud.wDayOfYear = dy;
1662 res = pVarDateFromUdate(&ud, flags, &out);
1663 ok_(__FILE__,line)(r == res && (r != S_OK || EQ_DOUBLE(out, dt)),
1664 "expected %x, %.16g, got %x, %.16g\n", r, dt, res, out);
1665 }
1666 #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)
1667
1668 static void test_VarDateFromUdate(void)
1669 {
1670 CHECKPTR(VarDateFromUdate);
1671 UD2T(1,1,1980,0,0,0,0,2,1,0,S_OK,29221.0); /* 1 Jan 1980 */
1672 UD2T(2,1,1980,0,0,0,0,3,2,0,S_OK,29222.0); /* 2 Jan 1980 */
1673 UD2T(2,1,1980,0,0,0,0,4,5,0,S_OK,29222.0); /* 2 Jan 1980 */
1674 UD2T(31,12,1990,0,0,0,0,0,0,0,S_OK,33238.0); /* 31 Dec 1990 */
1675 UD2T(31,12,90,0,0,0,0,0,0,0,S_OK,33238.0); /* year < 100 is 1900+year! */
1676 UD2T(30,12,1899,0,0,0,0,6,364,0,S_OK,0.0); /* 30 Dec 1899 - VT_DATE 0.0 */
1677 UD2T(1,1,100,0,0,0,0,0,0,0,S_OK,-657434.0); /* 1 Jan 100 - Min */
1678 UD2T(31,12,9999,0,0,0,0,0,0,0,S_OK,2958465.0); /* 31 Dec 9999 - Max */
1679 UD2T(1,1,10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0); /* > 31 Dec 9999 => err */
1680 UD2T(1,1,-10000,0,0,0,0,0,0,0,E_INVALIDARG,0.0);/* < -9999 => err */
1681
1682 UD2T(30,12,1899,0,0,0,0,0,0,0,S_OK,0.0); /* 30 Dec 1899 0:00:00 */
1683 UD2T(30,12,1899,0,0,0,999,0,0,0,S_OK,0.0); /* Ignore milliseconds */
1684
1685 UD2T(1,1,1980,18,1,16,0,2,1,0,S_OK,29221.75087962963); /* 6:18:02 PM */
1686 UD2T(1,300,1980,18,1,16,0,2,1,0,S_OK,38322.75087962963); /* Test fwdrolled month */
1687 UD2T(300,1,1980,18,1,16,0,2,1,0,S_OK,29520.75087962963); /* Test fwdrolled days */
1688 UD2T(0,1,1980,42,1,16,0,2,1,0,S_OK,29221.75087962963); /* Test fwdrolled hours */
1689 UD2T(1,1,1980,17,61,16,0,2,1,0,S_OK,29221.75087962963); /* Test fwdrolled minutes */
1690 UD2T(1,1,1980,18,0,76,0,2,1,0,S_OK,29221.75087962963); /* Test fwdrolled seconds */
1691 UD2T(1,-300,1980,18,1,16,0,2,1,0,S_OK,20059.75087962963); /* Test backrolled month */
1692 UD2T(-300,1,1980,18,1,16,0,2,1,0,S_OK,28920.75087962963); /* Test backrolled days */
1693 UD2T(3,1,1980,-30,1,16,0,2,1,0,S_OK,29221.75087962963); /* Test backrolled hours */
1694 UD2T(1,1,1980,20,-119,16,0,2,1,0,S_OK,29221.75087962963); /* Test backrolled minutes */
1695 UD2T(1,1,1980,18,3,-104,0,2,1,0,S_OK,29221.75087962963); /* Test backrolled seconds */
1696 UD2T(1,12001,-1020,18,1,16,0,0,0,0,S_OK,29221.75087962963); /* Test rolled year and month */
1697 UD2T(1,-23,1982,18,1,16,0,0,0,0,S_OK,29221.75087962963); /* Test backrolled month */
1698 UD2T(-59,3,1980,18,1,16,0,0,0,0,S_OK,29221.75087962963); /* Test backrolled days */
1699 UD2T(1,1,0,0,0,0,0,0,0,0,S_OK,36526); /* Test zero year */
1700 UD2T(0,0,1980,0,0,0,0,0,0,0,S_OK,29189); /* Test zero day and month */
1701 UD2T(0,1,1980,0,0,0,0,2,1,0,S_OK,29220.0); /* Test zero day = LastDayOfMonth */
1702 UD2T(-1,1,1980,18,1,16,0,0,0,0,S_OK,29219.75087962963); /* Test day -1 = LastDayOfMonth - 1 */
1703 UD2T(1,1,-1,18,1,16,0,0,0,0,S_OK,36161.75087962963); /* Test year -1 = 1999 */
1704 UD2T(1,-1,1980,18,1,16,0,0,0,0,S_OK,29160.7508796296); /* Test month -1 = 11 */
1705 UD2T(1,13,1980,0,0,0,0,2,1,0,S_OK,29587.0); /* Rolls fwd to 1/1/1981 */
1706
1707 /* Test handling of times on dates prior to the epoch */
1708 UD2T(25,12,1899,6,0,0,0,1,359,0,S_OK,-5.25);
1709 UD2T(25,12,1899,23,59,59,0,1,359,0,S_OK,-5.9999884259259);
1710 /* This just demonstrates the non-linear nature of values prior to the epoch */
1711 UD2T(26,12,1899,0,0,0,0,2,360,0,S_OK,-4.0);
1712 /* for DATE values 0.0 < x < 1.0, x and -x represent the same datetime */
1713 /* but when converting to DATE, prefer the positive versions */
1714 UD2T(30,12,1899,6,0,0,0,6,364,0,S_OK,0.25);
1715 }
1716
1717 static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1718 WORD s, WORD ms, INT r, double dt)
1719 {
1720 SYSTEMTIME st;
1721 double out;
1722 INT res;
1723
1724 st.wYear = y;
1725 st.wMonth = m;
1726 st.wDay = d;
1727 st.wHour = h;
1728 st.wMinute = mn;
1729 st.wSecond = s;
1730 st.wMilliseconds = ms;
1731 st.wDayOfWeek = 0;
1732 res = pSystemTimeToVariantTime(&st, &out);
1733 ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1734 "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1735 }
1736 #define ST2DT(d,m,y,h,mn,s,ms,r,dt) test_st2dt(__LINE__,d,m,y,h,mn,s,ms,r,dt)
1737
1738 static void test_SystemTimeToVariantTime(void)
1739 {
1740 CHECKPTR(SystemTimeToVariantTime);
1741 ST2DT(1,1,1980,0,0,0,0,TRUE,29221.0);
1742 ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
1743 ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0); /* Rolls back to 31 Dec 1899 */
1744 ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
1745 ST2DT(31,12,90,0,0,0,0,TRUE,33238.0); /* 30 <= year < 100 is 1900+year */
1746 ST2DT(1,1,30,0,0,0,0,TRUE,10959.0); /* 30 <= year < 100 is 1900+year */
1747 ST2DT(1,1,29,0,0,0,0,TRUE,47119.0); /* 0 <= year < 30 is 2000+year */
1748 ST2DT(1,1,0,0,0,0,0,TRUE,36526.0); /* 0 <= year < 30 is 2000+year */
1749 }
1750
1751 static void test_dt2st(int line, double dt, INT r, WORD d, WORD m, WORD y,
1752 WORD h, WORD mn, WORD s, WORD ms)
1753 {
1754 SYSTEMTIME st;
1755 INT res;
1756
1757 memset(&st, 0, sizeof(st));
1758 res = pVariantTimeToSystemTime(dt, &st);
1759 ok_(__FILE__,line)(r == res &&
1760 (!r || (st.wYear == y && st.wMonth == m && st.wDay == d &&
1761 st.wHour == h && st.wMinute == mn &&
1762 st.wSecond == s && st.wMilliseconds == ms)),
1763 "%.16g expected %d, %d,%d,%d,%d,%d,%d,%d, got %d, %d,%d,%d,%d,%d,%d,%d\n",
1764 dt, r, d, m, y, h, mn, s, ms, res, st.wDay, st.wMonth,
1765 st.wYear, st.wHour, st.wMinute, st.wSecond,
1766 st.wMilliseconds);
1767 }
1768 #define DT2ST(dt,r,d,m,y,h,mn,s,ms) test_dt2st(__LINE__,dt,r,d,m,y,h,mn,s,ms)
1769
1770 static void test_VariantTimeToSystemTime(void)
1771 {
1772 CHECKPTR(VariantTimeToSystemTime);
1773 DT2ST(29221.0,1,1,1,1980,0,0,0,0);
1774 DT2ST(29222.0,1,2,1,1980,0,0,0,0);
1775 }
1776
1777 #define MKDOSDATE(d,m,y) ((d & 0x1f) | ((m & 0xf) << 5) | (((y-1980) & 0x7f) << 9))
1778 #define MKDOSTIME(h,m,s) (((s>>1) & 0x1f) | ((m & 0x3f) << 5) | ((h & 0x1f) << 11))
1779
1780 static void test_dos2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
1781 WORD s, INT r, double dt)
1782 {
1783 unsigned short dosDate, dosTime;
1784 double out;
1785 INT res;
1786
1787 out = 0.0;
1788 dosDate = MKDOSDATE(d, m, y);
1789 dosTime = MKDOSTIME(h, mn, s);
1790 res = pDosDateTimeToVariantTime(dosDate, dosTime, &out);
1791 ok_(__FILE__,line)(r == res && (!r || EQ_DOUBLE(out, dt)),
1792 "expected %d, %.16g, got %d, %.16g\n", r, dt, res, out);
1793 }
1794 #define DOS2DT(d,m,y,h,mn,s,r,dt) test_dos2dt(__LINE__,d,m,y,h,mn,s,r,dt)
1795
1796 static void test_DosDateTimeToVariantTime(void)
1797 {
1798 CHECKPTR(DosDateTimeToVariantTime);
1799
1800 /* Date */
1801 DOS2DT(1,1,1980,0,0,0,1,29221.0); /* 1/1/1980 */
1802 DOS2DT(31,12,2099,0,0,0,1,73050.0); /* 31/12/2099 */
1803 /* Dates are limited to the dos date max of 31/12/2099 */
1804 DOS2DT(31,12,2100,0,0,0,0,0.0); /* 31/12/2100 */
1805 /* Days and months of 0 cause date to roll back 1 day or month */
1806 DOS2DT(0,1,1980,0,0,0,1,29220.0); /* 0 Day => 31/12/1979 */
1807 DOS2DT(1,0,1980,0,0,0,1,29190.0); /* 0 Mth => 1/12/1979 */
1808 DOS2DT(0,0,1980,0,0,0,1,29189.0); /* 0 D/M => 30/11/1979 */
1809 /* Days > days in the month cause date to roll forward 1 month */
1810 DOS2DT(29,2,1981,0,0,0,1,29646.0); /* 29/2/1981 -> 3/1/1980 */
1811 DOS2DT(30,2,1981,0,0,0,1,29647.0); /* 30/2/1981 -> 4/1/1980 */
1812 /* Takes leap years into account when rolling forward */
1813 DOS2DT(29,2,1980,0,0,0,1,29280.0); /* 2/29/1980 */
1814 /* Months > 12 cause an error */
1815 DOS2DT(2,13,1980,0,0,0,0,0.0);
1816
1817 /* Time */
1818 DOS2DT(1,1,1980,0,0,29,1,29221.00032407407); /* 1/1/1980 12:00:28 AM */
1819 DOS2DT(1,1,1980,0,0,31,1,29221.00034722222); /* 1/1/1980 12:00:30 AM */
1820 DOS2DT(1,1,1980,0,59,0,1,29221.04097222222); /* 1/1/1980 12:59:00 AM */
1821 DOS2DT(1,1,1980,0,60,0,0,0.0); /* Invalid minutes */
1822 DOS2DT(1,1,1980,0,0,60,0,0.0); /* Invalid seconds */
1823 DOS2DT(1,1,1980,23,0,0,1,29221.95833333333); /* 1/1/1980 11:00:00 PM */
1824 DOS2DT(1,1,1980,24,0,0,0,0.0); /* Invalid hours */
1825
1826 DOS2DT(1,1,1980,0,0,1,1,29221.0);
1827 DOS2DT(2,1,1980,0,0,0,1,29222.0);
1828 DOS2DT(2,1,1980,0,0,0,1,29222.0);
1829 DOS2DT(31,12,1990,0,0,0,1,33238.0);
1830 DOS2DT(31,12,90,0,0,0,1,40543.0);
1831 DOS2DT(30,12,1899,0,0,0,1,46751.0);
1832 DOS2DT(1,1,100,0,0,0,1,43831.0);
1833 DOS2DT(31,12,9999,0,0,0,1,59901.0);
1834 DOS2DT(1,1,10000,0,0,0,1,59902.0);
1835 DOS2DT(1,1,-10000,0,0,0,1,48214.0);
1836
1837 DOS2DT(30,12,1899,0,0,0,1,46751.0);
1838 DOS2DT(30,12,1899,0,0,1,1,46751.0);
1839
1840 DOS2DT(1,1,1980,18,1,16,1,29221.75087962963);
1841 DOS2DT(1,300,1980,18,1,16,1,29556.75087962963);
1842 DOS2DT(300,1,1980,18,1,16,1,29232.75087962963);
1843 DOS2DT(0,1,1980,42,1,16,1,29220.4175462963);
1844 DOS2DT(1,1,1980,17,61,16,0,0.0);
1845 DOS2DT(1,1,1980,18,0,76,1,29221.75013888889);
1846 DOS2DT(1,-300,1980,18,1,16,1,29312.75087962963);
1847 DOS2DT(-300,1,1980,18,1,16,1,29240.75087962963);
1848 DOS2DT(3,1,1980,-30,1,16,1,29223.08421296296);
1849 DOS2DT(1,1,1980,20,-119,16,1,29221.83976851852);
1850 DOS2DT(1,1,1980,18,3,-104,1,29221.75236111111);
1851 DOS2DT(1,12001,-1020,18,1,16,1,55519.75087962963);
1852 DOS2DT(1,-23,1982,18,1,16,1,30195.75087962963);
1853 DOS2DT(-59,3,1980,18,1,16,1,29285.75087962963);
1854 DOS2DT(1,1,0,0,0,0,1,54058.0);
1855 DOS2DT(0,0,1980,0,0,0,1,29189.0);
1856 DOS2DT(0,1,1980,0,0,0,1,29220.0);
1857 DOS2DT(-1,1,1980,18,1,16,1,29251.75087962963);
1858 DOS2DT(1,1,-1,18,1,16,1,53693.75087962963);
1859 DOS2DT(1,-1,1980,18,1,16,0,0);
1860 }
1861
1862 static void test_dt2dos(int line, double dt, INT r, WORD d, WORD m, WORD y,
1863 WORD h, WORD mn, WORD s)
1864 {
1865 unsigned short dosDate, dosTime, expDosDate, expDosTime;
1866 INT res;
1867
1868 dosTime = dosDate = 0;
1869 expDosDate = MKDOSDATE(d,m,y);
1870 expDosTime = MKDOSTIME(h,mn,s);
1871 res = pVariantTimeToDosDateTime(dt, &dosDate, &dosTime);
1872 ok_(__FILE__,line)(r == res && (!r || (dosTime == expDosTime && dosDate == expDosDate)),
1873 "%g: expected %d,%d(%d/%d/%d),%d(%d:%d:%d) got %d,%d(%d/%d/%d),%d(%d:%d:%d)\n",
1874 dt, r, expDosDate, expDosDate & 0x1f,
1875 (expDosDate >> 5) & 0xf, 1980 + (expDosDate >> 9),
1876 expDosTime, expDosTime >> 11, (expDosTime >> 5) & 0x3f,
1877 (expDosTime & 0x1f),
1878 res, dosDate, dosDate & 0x1f, (dosDate >> 5) & 0xf,
1879 1980 + (dosDate >> 9), dosTime, dosTime >> 11,
1880 (dosTime >> 5) & 0x3f, (dosTime & 0x1f));
1881 }
1882 #define DT2DOS(dt,r,d,m,y,h,mn,s) test_dt2dos(__LINE__,dt,r,d,m,y,h,mn,s)
1883
1884 static void test_VariantTimeToDosDateTime(void)
1885 {
1886 CHECKPTR(VariantTimeToDosDateTime);
1887
1888 /* Date */
1889 DT2DOS(29221.0,1,1,1,1980,0,0,0); /* 1/1/1980 */
1890 DT2DOS(73050.0,1,31,12,2099,0,0,0); /* 31/12/2099 */
1891 DT2DOS(29220.0,0,0,0,0,0,0,0); /* 31/12/1979 - out of range */
1892 DT2DOS(73415.0,0,0,0,0,0,0,0); /* 31/12/2100 - out of range */
1893
1894 /* Time */
1895 DT2DOS(29221.00032407407,1,1,1,1980,0,0,29); /* 1/1/1980 12:00:28 AM */
1896 DT2DOS(29221.00034722222,1,1,1,1980,0,0,31); /* 1/1/1980 12:00:30 AM */
1897 DT2DOS(29221.04097222222,1,1,1,1980,0,59,0); /* 1/1/1980 12:59:00 AM */
1898 DT2DOS(29221.95833333333,1,1,1,1980,23,0,0); /* 1/1/1980 11:00:00 PM */
1899 }
1900
1901 static HRESULT (WINAPI *pVarAbs)(LPVARIANT,LPVARIANT);
1902
1903 #define VARABS(vt,val,rvt,rval) \
1904 V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
1905 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
1906 test_var_call1( __LINE__, pVarAbs, &v, &exp )
1907
1908 static void test_VarAbs(void)
1909 {
1910 static WCHAR szNum[] = {'-','1','.','1','\0' };
1911 char buff[8];
1912 HRESULT hres;
1913 VARIANT v, vDst, exp;
1914 size_t i;
1915
1916 CHECKPTR(VarAbs);
1917
1918 /* Test all possible V_VT values.
1919 */
1920 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
1921 {
1922 VARTYPE vt;
1923
1924 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
1925 {
1926 HRESULT hExpected = DISP_E_BADVARTYPE;
1927
1928 SKIPTESTS(vt);
1929
1930 memset(&v, 0, sizeof(v));
1931 V_VT(&v) = vt | ExtraFlags[i];
1932 V_VT(&vDst) = VT_EMPTY;
1933
1934 hres = pVarAbs(&v,&vDst);
1935 if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
1936 (!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
1937 vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
1938 {
1939 hExpected = DISP_E_TYPEMISMATCH;
1940 }
1941 else if (ExtraFlags[i] || vt >= VT_CLSID || vt == VT_VARIANT)
1942 {
1943 hExpected = DISP_E_BADVARTYPE;
1944 }
1945 else if (IsValidVariantClearVT(vt, ExtraFlags[i]))
1946 hExpected = S_OK;
1947
1948 /* Native always fails on some vartypes that should be valid. don't
1949 * check that Wine does the same; these are bugs in native.
1950 */
1951 if (vt == VT_I8 || vt == VT_UI8 || vt == VT_INT || vt == VT_UINT ||
1952 vt == VT_I1 || vt == VT_UI2 || vt == VT_UI4)
1953 continue;
1954 ok(hres == hExpected, "VarAbs: expected 0x%X, got 0x%X for vt %d | 0x%X\n",
1955 hExpected, hres, vt, ExtraFlags[i]);
1956 }
1957 }
1958
1959 /* BOOL->I2, BSTR->R8, all others remain the same */
1960 VARABS(BOOL,VARIANT_TRUE,I2,-VARIANT_TRUE);
1961 VARABS(BOOL,VARIANT_FALSE,I2,VARIANT_FALSE);
1962 VARABS(EMPTY,0,I2,0);
1963 VARABS(EMPTY,1,I2,0);
1964 VARABS(NULL,0,NULL,0);
1965 VARABS(NULL,1,NULL,0);
1966 VARABS(I2,1,I2,1);
1967 VARABS(I2,-1,I2,1);
1968 VARABS(I4,1,I4,1);
1969 VARABS(I4,-1,I4,1);
1970 VARABS(UI1,1,UI1,1);
1971 VARABS(R4,1,R4,1);
1972 VARABS(R4,-1,R4,1);
1973 VARABS(R8,1,R8,1);
1974 VARABS(R8,-1,R8,1);
1975 VARABS(DATE,1,DATE,1);
1976 VARABS(DATE,-1,DATE,1);
1977 V_VT(&v) = VT_CY;
1978 V_CY(&v).int64 = -10000;
1979 memset(&vDst,0,sizeof(vDst));
1980 hres = pVarAbs(&v,&vDst);
1981 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
1982 "VarAbs(CY): expected 0x0 got 0x%X\n", hres);
1983 GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
1984 if (buff[1])
1985 {
1986 trace("Skipping VarAbs(BSTR) as decimal separator is '%s'\n", buff);
1987 return;
1988 } else {
1989 szNum[2] = buff[0];
1990 }
1991 V_VT(&v) = VT_BSTR;
1992 V_BSTR(&v) = (BSTR)szNum;
1993 memset(&vDst,0,sizeof(vDst));
1994 hres = pVarAbs(&v,&vDst);
1995 ok(hres == S_OK && V_VT(&vDst) == VT_R8 && V_R8(&vDst) == 1.1,
1996 "VarAbs: expected 0x0,%d,%g, got 0x%X,%d,%g\n", VT_R8, 1.1, hres, V_VT(&vDst), V_R8(&vDst));
1997 }
1998
1999 static HRESULT (WINAPI *pVarNot)(LPVARIANT,LPVARIANT);
2000
2001 #define VARNOT(vt,val,rvt,rval) \
2002 V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2003 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2004 test_var_call1( __LINE__, pVarNot, &v, &exp )
2005
2006 static void test_VarNot(void)
2007 {
2008 static const WCHAR szNum0[] = {'0','\0' };
2009 static const WCHAR szNum1[] = {'1','\0' };
2010 static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
2011 static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
2012 HRESULT hres;
2013 VARIANT v, exp, vDst;
2014 DECIMAL *pdec = &V_DECIMAL(&v);
2015 CY *pcy = &V_CY(&v);
2016 size_t i;
2017
2018 CHECKPTR(VarNot);
2019
2020 /* Test all possible V_VT values */
2021 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2022 {
2023 VARTYPE vt;
2024
2025 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2026 {
2027 HRESULT hExpected = DISP_E_BADVARTYPE;
2028
2029 SKIPTESTS(vt);
2030
2031 memset(&v, 0, sizeof(v));
2032 V_VT(&v) = vt | ExtraFlags[i];
2033 V_VT(&vDst) = VT_EMPTY;
2034
2035 switch (V_VT(&v))
2036 {
2037 case VT_I1: case VT_UI1: case VT_I2: case VT_UI2:
2038 case VT_INT: case VT_UINT: case VT_I4: case VT_UI4:
2039 case VT_R4: case VT_R8:
2040 case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2041 case VT_DATE: case VT_CY:
2042 hExpected = S_OK;
2043 break;
2044 case VT_I8: case VT_UI8:
2045 if (HAVE_OLEAUT32_I8)
2046 hExpected = S_OK;
2047 break;
2048 case VT_RECORD:
2049 if (HAVE_OLEAUT32_RECORD)
2050 hExpected = DISP_E_TYPEMISMATCH;
2051 break;
2052 case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
2053 hExpected = DISP_E_TYPEMISMATCH;
2054 break;
2055 default:
2056 if (IsValidVariantClearVT(vt, ExtraFlags[i]) && vt != VT_CLSID)
2057 hExpected = DISP_E_TYPEMISMATCH;
2058 break;
2059 }
2060
2061 hres = pVarNot(&v,&vDst);
2062 ok(hres == hExpected, "VarNot: expected 0x%X, got 0x%X vt %d|0x%X\n",
2063 hExpected, hres, vt, ExtraFlags[i]);
2064 }
2065 }
2066 /* Test the values returned by all cases that can succeed */
2067 VARNOT(EMPTY,0,I2,-1);
2068 VARNOT(EMPTY,1,I2,-1);
2069 VARNOT(NULL,0,NULL,0);
2070 VARNOT(NULL,1,NULL,0);
2071 VARNOT(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
2072 VARNOT(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
2073 VARNOT(I1,-1,I4,0);
2074 VARNOT(I1,0,I4,-1);
2075 VARNOT(I2,-1,I2,0);
2076 VARNOT(I2,0,I2,-1);
2077 VARNOT(I2,1,I2,-2);
2078 VARNOT(I4,1,I4,-2);
2079 VARNOT(I4,0,I4,-1);
2080 VARNOT(UI1,1,UI1,254);
2081 VARNOT(UI1,0,UI1,255);
2082 VARNOT(UI2,0,I4,-1);
2083 VARNOT(UI2,1,I4,-2);
2084 VARNOT(UI4,0,I4,-1);
2085 VARNOT(UI4,1,I4,-2);
2086 VARNOT(INT,0,I4,-1);
2087 VARNOT(INT,1,I4,-2);
2088 VARNOT(UINT,0,I4,-1);
2089 VARNOT(UINT,1,I4,-2);
2090 if (HAVE_OLEAUT32_I8)
2091 {
2092 VARNOT(I8,1,I8,-2);
2093 VARNOT(I8,0,I8,-1);
2094 VARNOT(UI8,0,I4,-1);
2095 VARNOT(UI8,1,I4,-2);
2096 }
2097 VARNOT(R4,1,I4,-2);
2098 VARNOT(R4,0,I4,-1);
2099 VARNOT(R8,1,I4,-2);
2100 VARNOT(R8,0,I4,-1);
2101 VARNOT(DATE,1,I4,-2);
2102 VARNOT(DATE,0,I4,-1);
2103 VARNOT(BSTR,(BSTR)szNum0,I4,-1);
2104 ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum0, "VarNot(0): changed input\n");
2105 VARNOT(BSTR,(BSTR)szNum1,I4,-2);
2106 ok(V_VT(&v) == VT_BSTR && V_BSTR(&v) == szNum1, "VarNot(1): changed input\n");
2107 VARNOT(BSTR, (BSTR)szTrue, BOOL, VARIANT_FALSE);
2108 VARNOT(BSTR, (BSTR)szFalse, BOOL, VARIANT_TRUE);
2109
2110 V_VT(&v) = VT_DECIMAL;
2111 S(U(*pdec)).sign = DECIMAL_NEG;
2112 S(U(*pdec)).scale = 0;
2113 pdec->Hi32 = 0;
2114 S1(U1(*pdec)).Mid32 = 0;
2115 S1(U1(*pdec)).Lo32 = 1;
2116 VARNOT(DECIMAL,*pdec,I4,0);
2117
2118 pcy->int64 = 10000;
2119 VARNOT(CY,*pcy,I4,-2);
2120
2121 pcy->int64 = 0;
2122 VARNOT(CY,*pcy,I4,-1);
2123
2124 pcy->int64 = -1;
2125 VARNOT(CY,*pcy,I4,-1);
2126 }
2127
2128 static HRESULT (WINAPI *pVarSub)(LPVARIANT,LPVARIANT,LPVARIANT);
2129
2130 #define VARSUB(vt1,val1,vt2,val2,rvt,rval) \
2131 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
2132 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2133 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2134 test_var_call2( __LINE__, pVarSub, &left, &right, &exp )
2135
2136 static void test_VarSub(void)
2137 {
2138 VARIANT left, right, exp, result, cy, dec;
2139 VARTYPE i;
2140 BSTR lbstr, rbstr;
2141 HRESULT hres, expectedhres;
2142 double r;
2143
2144 CHECKPTR(VarSub);
2145
2146 lbstr = SysAllocString(sz12);
2147 rbstr = SysAllocString(sz12);
2148
2149 VariantInit(&left);
2150 VariantInit(&right);
2151 VariantInit(&result);
2152
2153 /* Test all possible flag/vt combinations & the resulting vt type */
2154 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2155 {
2156
2157 VARTYPE leftvt, rightvt, resvt;
2158
2159 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
2160 {
2161
2162 SKIPTESTS(leftvt);
2163
2164 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
2165 {
2166
2167 SKIPTESTS(rightvt);
2168 expectedhres = S_OK;
2169
2170 memset(&left, 0, sizeof(left));
2171 memset(&right, 0, sizeof(right));
2172 V_VT(&left) = leftvt | ExtraFlags[i];
2173 if (leftvt == VT_BSTR)
2174 V_BSTR(&left) = lbstr;
2175 V_VT(&right) = rightvt | ExtraFlags[i];
2176 if (rightvt == VT_BSTR)
2177 V_BSTR(&right) = rbstr;
2178 V_VT(&result) = VT_EMPTY;
2179
2180 /* All extra flags produce errors */
2181 if (ExtraFlags[i] == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
2182 ExtraFlags[i] == (VT_VECTOR|VT_RESERVED) ||
2183 ExtraFlags[i] == (VT_VECTOR|VT_BYREF) ||
2184 ExtraFlags[i] == (VT_BYREF|VT_RESERVED) ||
2185 ExtraFlags[i] == VT_VECTOR ||
2186 ExtraFlags[i] == VT_BYREF ||
2187 ExtraFlags[i] == VT_RESERVED)
2188 {
2189 expectedhres = DISP_E_BADVARTYPE;
2190 resvt = VT_EMPTY;
2191 }
2192 else if (ExtraFlags[i] >= VT_ARRAY)
2193 {
2194 expectedhres = DISP_E_TYPEMISMATCH;
2195 resvt = VT_EMPTY;
2196 }
2197 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
2198 VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
2199 else if (!IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
2200 !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
2201 leftvt == VT_CLSID || rightvt == VT_CLSID ||
2202 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
2203 leftvt == VT_I1 || rightvt == VT_I1 ||
2204 leftvt == VT_UI2 || rightvt == VT_UI2 ||
2205 leftvt == VT_UI4 || rightvt == VT_UI4 ||
2206 leftvt == VT_UI8 || rightvt == VT_UI8 ||
2207 leftvt == VT_INT || rightvt == VT_INT ||
2208 leftvt == VT_UINT || rightvt == VT_UINT ||
2209 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
2210 leftvt == VT_RECORD || rightvt == VT_RECORD)
2211 {
2212 if (leftvt == VT_RECORD && rightvt == VT_I8)
2213 {
2214 if (HAVE_OLEAUT32_I8)
2215 expectedhres = DISP_E_TYPEMISMATCH;
2216 else
2217 expectedhres = DISP_E_BADVARTYPE;
2218 }
2219 else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
2220 expectedhres = DISP_E_TYPEMISMATCH;
2221 else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
2222 expectedhres = DISP_E_TYPEMISMATCH;
2223 else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
2224 expectedhres = DISP_E_TYPEMISMATCH;
2225 else if (leftvt == VT_RECORD && rightvt > VT_UI1)
2226 expectedhres = DISP_E_BADVARTYPE;
2227 else
2228 expectedhres = DISP_E_BADVARTYPE;
2229 resvt = VT_EMPTY;
2230 }
2231 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
2232 (leftvt == VT_DISPATCH && rightvt == VT_NULL))
2233 resvt = VT_NULL;
2234 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
2235 leftvt == VT_ERROR || rightvt == VT_ERROR)
2236 {
2237 resvt = VT_EMPTY;
2238 expectedhres = DISP_E_TYPEMISMATCH;
2239 }
2240 else if (leftvt == VT_NULL || rightvt == VT_NULL)
2241 resvt = VT_NULL;
2242 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
2243 (leftvt == VT_DATE && rightvt == VT_DATE) ||
2244 (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
2245 (leftvt == VT_BSTR && rightvt == VT_BSTR))
2246 resvt = VT_R8;
2247 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
2248 resvt = VT_DECIMAL;
2249 else if (leftvt == VT_DATE || rightvt == VT_DATE)
2250 resvt = VT_DATE;
2251 else if (leftvt == VT_CY || rightvt == VT_CY)
2252 resvt = VT_CY;
2253 else if (leftvt == VT_R8 || rightvt == VT_R8)
2254 resvt = VT_R8;
2255 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
2256 resvt = VT_R8;
2257 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
2258 if (leftvt == VT_I4 || rightvt == VT_I4 ||
2259 leftvt == VT_I8 || rightvt == VT_I8)
2260 resvt = VT_R8;
2261 else
2262 resvt = VT_R4;
2263 }
2264 else if (leftvt == VT_I8 || rightvt == VT_I8)
2265 resvt = VT_I8;
2266 else if (leftvt == VT_I4 || rightvt == VT_I4)
2267 resvt = VT_I4;
2268 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
2269 leftvt == VT_BOOL || rightvt == VT_BOOL ||
2270 (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
2271 resvt = VT_I2;
2272 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
2273 resvt = VT_UI1;
2274 else
2275 {
2276 resvt = VT_EMPTY;
2277 expectedhres = DISP_E_TYPEMISMATCH;
2278 }
2279
2280 hres = pVarSub(&left, &right, &result);
2281
2282 ok(hres == expectedhres && V_VT(&result) == resvt,
2283 "VarSub: %d|0x%X, %d|0x%X: Expected failure 0x%X, "
2284 "got 0x%X, expected vt %d got vt %d\n",
2285 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i],
2286 expectedhres, hres, resvt, V_VT(&result));
2287 }
2288 }
2289 }
2290
2291 /* Test returned values */
2292 VARSUB(I4,4,I4,2,I4,2);
2293 VARSUB(I2,4,I2,2,I2,2);
2294 VARSUB(I2,-13,I4,5,I4,-18);
2295 VARSUB(I4,-13,I4,5,I4,-18);
2296 VARSUB(I2,7,R4,0.5f,R4,6.5f);
2297 VARSUB(R4,0.5f,I4,5,R8,-4.5);
2298 VARSUB(R8,7.1,BOOL,0,R8,7.1);
2299 VARSUB(BSTR,lbstr,I2,4,R8,8);
2300 VARSUB(BSTR,lbstr,BOOL,1,R8,11);
2301 VARSUB(BSTR,lbstr,R4,0.1f,R8,11.9);
2302 VARSUB(R4,0.2f,BSTR,rbstr,R8,-11.8);
2303 VARSUB(DATE,2.25,I4,7,DATE,-4.75);
2304 VARSUB(DATE,1.25,R4,-1.7f,DATE,2.95);
2305
2306 VARSUB(UI1, UI1_MAX, UI1, UI1_MAX, UI1, 0);
2307 VARSUB(I2, I2_MAX, I2, I2_MAX, I2, 0);
2308 VARSUB(I2, I2_MIN, I2, I2_MIN, I2, 0);
2309 VARSUB(I4, I4_MAX, I4, I4_MAX, I4, 0);
2310 VARSUB(I4, I4_MIN, I4, I4_MIN, I4, 0);
2311 VARSUB(R4, R4_MAX, R4, R4_MAX, R4, 0.0f);
2312 VARSUB(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX - R4_MIN);
2313 VARSUB(R4, R4_MIN, R4, R4_MIN, R4, 0.0f);
2314 VARSUB(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX - R8_MIN);
2315 VARSUB(R8, R8_MIN, R8, R8_MIN, R8, 0.0);
2316
2317 /* Manually test BSTR + BSTR */
2318 V_VT(&left) = VT_BSTR;
2319 V_BSTR(&left) = lbstr;
2320 V_VT(&right) = VT_BSTR;
2321 V_BSTR(&right) = rbstr;
2322 hres = pVarSub(&left, &right, &result);
2323 ok(hres == S_OK && V_VT(&result) == VT_R8,
2324 "VarSub: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
2325 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0),
2326 "VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
2327
2328 /* Manually test some VT_CY and VT_DECIMAL variants */
2329 V_VT(&cy) = VT_CY;
2330 hres = VarCyFromI4(4711, &V_CY(&cy));
2331 ok(hres == S_OK, "VarCyFromI4 failed!\n");
2332 V_VT(&dec) = VT_DECIMAL;
2333 hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
2334 ok(hres == S_OK, "VarDecFromR4 failed!\n");
2335 memset(&left, 0, sizeof(left));
2336 memset(&right, 0, sizeof(right));
2337 V_VT(&left) = VT_I4;
2338 V_I4(&left) = -11;
2339 V_VT(&right) = VT_UI1;
2340 V_UI1(&right) = 9;
2341
2342 hres = pVarSub(&cy, &right, &result);
2343 ok(hres == S_OK && V_VT(&result) == VT_CY,
2344 "VarSub: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
2345 hres = VarR8FromCy(V_CY(&result), &r);
2346 ok(hres == S_OK && EQ_DOUBLE(r, 4702),
2347 "VarSub: CY value %f, expected %f\n", r, (double)4720);
2348
2349 hres = pVarSub(&left, &dec, &result);
2350 ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
2351 "VarSub: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
2352 hres = VarR8FromDec(&V_DECIMAL(&result), &r);
2353 ok(hres == S_OK && EQ_DOUBLE(r, -6.8),
2354 "VarSub: DECIMAL value %f, expected %f\n", r, (double)-15.2);
2355
2356 SysFreeString(lbstr);
2357 SysFreeString(rbstr);
2358 }
2359
2360 static HRESULT (WINAPI *pVarMod)(LPVARIANT,LPVARIANT,LPVARIANT);
2361
2362 static void test_Mod( int line, VARIANT *left, VARIANT *right, VARIANT *expected, HRESULT expres )
2363 {
2364 VARIANT result;
2365 HRESULT hres;
2366
2367 memset( &result, 0, sizeof(result) );
2368 hres = pVarMod( left, right, &result );
2369 ok_(__FILE__,line)( hres == expres, "wrong result %x/%x\n", hres, expres );
2370 if (hres == S_OK)
2371 ok_(__FILE__,line)( is_expected_variant( &result, expected ),
2372 "got %s expected %s\n", variantstr(&result), variantstr(expected) );
2373 }
2374
2375 #define VARMOD(vt1,vt2,val1,val2,rvt,rval) \
2376 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
2377 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
2378 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2379 test_var_call2( __LINE__, pVarMod, &left, &right, &exp )
2380
2381 #define VARMOD2(vt1,vt2,val1,val2,rvt,rval,hexpected) \
2382 V_VT(&left) = VT_##vt1; V_I4(&left) = val1; \
2383 V_VT(&right) = VT_##vt2; V_I4(&right) = val2; \
2384 V_VT(&exp) = VT_##rvt; V_I4(&exp) = rval; \
2385 test_Mod( __LINE__, &left, &right, &exp, hexpected )
2386
2387 static void test_VarMod(void)
2388 {
2389 VARIANT v1, v2, vDst, left, right, exp;
2390 HRESULT hres;
2391 HRESULT hexpected = 0;
2392 static const WCHAR szNum0[] = {'1','2','5','\0'};
2393 static const WCHAR szNum1[] = {'1','0','\0'};
2394 int l, r;
2395 BOOL lFound, rFound;
2396 BOOL lValid;
2397 BSTR strNum0, strNum1;
2398
2399 CHECKPTR(VarMod);
2400
2401 VARMOD(I1,BOOL,100,10,I4,0);
2402 VARMOD(I1,I1,100,10,I4,0);
2403 VARMOD(I1,UI1,100,10,I4,0);
2404 VARMOD(I1,I2,100,10,I4,0);
2405 VARMOD(I1,UI2,100,10,I4,0);
2406 VARMOD(I1,I4,100,10,I4,0);
2407 VARMOD(I1,UI4,100,10,I4,0);
2408 VARMOD(I1,R4,100,10,I4,0);
2409 VARMOD(I1,R8,100,10,I4,0);
2410
2411 VARMOD(UI1,BOOL,100,10,I2,0);
2412 VARMOD(UI1,I1,100,10,I4,0);
2413 VARMOD(UI1,UI1,100,10,UI1,0);
2414 VARMOD(UI1,I2,100,10,I2,0);
2415 VARMOD(UI1,UI2,100,10,I4,0);
2416 VARMOD(UI1,I4,100,10,I4,0);
2417 VARMOD(UI1,UI4,100,10,I4,0);
2418 VARMOD(UI1,R4,100,10,I4,0);
2419 VARMOD(UI1,R8,100,10,I4,0);
2420
2421 VARMOD(I2,BOOL,100,10,I2,0);
2422 VARMOD(I2,I1,100,10,I4,0);
2423 VARMOD(I2,UI1,100,10,I2,0);
2424 VARMOD(I2,I2,100,10,I2,0);
2425 VARMOD(I2,UI2,100,10,I4,0);
2426 VARMOD(I2,I4,100,10,I4,0);
2427 VARMOD(I2,UI4,100,10,I4,0);
2428 VARMOD(I2,R4,100,10,I4,0);
2429 VARMOD(I2,R8,100,10,I4,0);
2430
2431 VARMOD(I4,BOOL,100,10,I4,0);
2432 VARMOD(I4,I1,100,10,I4,0);
2433 VARMOD(I4,UI1,100,10,I4,0);
2434 VARMOD(I4,I2,100,10,I4,0);
2435 VARMOD(I4,UI2,100,10,I4,0);
2436 VARMOD(I4,I4,100,10,I4,0);
2437 VARMOD(I4,UI4,100,10,I4,0);
2438 VARMOD(I4,R4,100,10,I4,0);
2439 VARMOD(I4,R8,100,10,I4,0);
2440 VARMOD(UI4,BOOL,100,10,I4,0);
2441 VARMOD(UI4,I1,100,10,I4,0);
2442 VARMOD(UI4,UI1,100,10,I4,0);
2443 VARMOD(UI4,I2,100,10,I4,0);
2444 VARMOD(UI4,UI2,100,10,I4,0);
2445 VARMOD(UI4,I4,100,10,I4,0);
2446 VARMOD(UI4,UI4,100,10,I4,0);
2447 VARMOD(UI4,R4,100,10,I4,0);
2448 VARMOD(UI4,R8,100,10,I4,0);
2449 VARMOD(R4,BOOL,100,10,I4,0);
2450 VARMOD(R4,I1,100,10,I4,0);
2451 VARMOD(R4,UI1,100,10,I4,0);
2452 VARMOD(R4,I2,100,10,I4,0);
2453 VARMOD(R4,UI2,100,10,I4,0);
2454 VARMOD(R4,I4,100,10,I4,0);
2455 VARMOD(R4,UI4,100,10,I4,0);
2456 VARMOD(R4,R4,100,10,I4,0);
2457 VARMOD(R4,R8,100,10,I4,0);
2458 VARMOD(R8,BOOL,100,10,I4,0);
2459 VARMOD(R8,I1,100,10,I4,0);
2460 VARMOD(R8,UI1,100,10,I4,0);
2461 VARMOD(R8,I2,100,10,I4,0);
2462 VARMOD(R8,UI2,100,10,I4,0);
2463 VARMOD(R8,I4,100,10,I4,0);
2464 VARMOD(R8,UI4,100,10,I4,0);
2465 VARMOD(R8,R4,100,10,I4,0);
2466 VARMOD(R8,R8,100,10,I4,0);
2467
2468 VARMOD(INT,INT,100,10,I4,0);
2469 VARMOD(INT,UINT,100,10,I4,0);
2470
2471 VARMOD(BOOL,BOOL,100,10,I2,0);
2472 VARMOD(BOOL,I1,100,10,I4,0);
2473 VARMOD(BOOL,UI1,100,10,I2,0);
2474 VARMOD(BOOL,I2,100,10,I2,0);
2475 VARMOD(BOOL,UI2,100,10,I4,0);
2476 VARMOD(BOOL,I4,100,10,I4,0);
2477 VARMOD(BOOL,UI4,100,10,I4,0);
2478 VARMOD(BOOL,R4,100,10,I4,0);
2479 VARMOD(BOOL,R8,100,10,I4,0);
2480 VARMOD(BOOL,DATE,100,10,I4,0);
2481
2482 VARMOD(DATE,BOOL,100,10,I4,0);
2483 VARMOD(DATE,I1,100,10,I4,0);
2484 VARMOD(DATE,UI1,100,10,I4,0);
2485 VARMOD(DATE,I2,100,10,I4,0);
2486 VARMOD(DATE,UI2,100,10,I4,0);
2487 VARMOD(DATE,I4,100,10,I4,0);
2488 VARMOD(DATE,UI4,100,10,I4,0);
2489 VARMOD(DATE,R4,100,10,I4,0);
2490 VARMOD(DATE,R8,100,10,I4,0);
2491 VARMOD(DATE,DATE,100,10,I4,0);
2492
2493 strNum0 = SysAllocString(szNum0);
2494 strNum1 = SysAllocString(szNum1);
2495 VARMOD(BSTR,BSTR,strNum0,strNum1,I4,5);
2496 VARMOD(BSTR,I1,strNum0,10,I4,5);
2497 VARMOD(BSTR,I2,strNum0,10,I4,5);
2498 VARMOD(BSTR,I4,strNum0,10,I4,5);
2499 VARMOD(BSTR,R4,strNum0,10,I4,5);
2500 VARMOD(BSTR,R8,strNum0,10,I4,5);
2501 VARMOD(I4,BSTR,125,strNum1,I4,5);
2502
2503 if (HAVE_OLEAUT32_I8)
2504 {
2505 VARMOD(BOOL,I8,100,10,I8,0);
2506 VARMOD(I1,I8,100,10,I8,0);
2507 VARMOD(UI1,I8,100,10,I8,0);
2508 VARMOD(I2,I8,100,10,I8,0);
2509 VARMOD(I4,I8,100,10,I8,0);
2510 VARMOD(UI4,I8,100,10,I8,0);
2511 VARMOD(R4,I8,100,10,I8,0);
2512 VARMOD(R8,I8,100,10,I8,0);
2513 VARMOD(DATE,I8,100,10,I8,0);
2514
2515 VARMOD(I8,BOOL,100,10,I8,0);
2516 VARMOD(I8,I1,100,10,I8,0);
2517 VARMOD(I8,UI1,100,10,I8,0);
2518 VARMOD(I8,I2,100,10,I8,0);
2519 VARMOD(I8,UI2,100,10,I8,0);
2520 VARMOD(I8,I4,100,10,I8,0);
2521 VARMOD(I8,UI4,100,10,I8,0);
2522 VARMOD(I8,R4,100,10,I8,0);
2523 VARMOD(I8,R8,100,10,I8,0);
2524 VARMOD(I8,I8,100,10,I8,0);
2525
2526 VARMOD(BSTR,I8,strNum0,10,I8,5);
2527 }
2528
2529 /* test all combinations of types */
2530 for(l = 0; l < VT_BSTR_BLOB; l++)
2531 {
2532 SKIPTESTS(l);
2533
2534 for(r = 0; r < VT_BSTR_BLOB; r++)
2535 {
2536 SKIPTESTS(r);
2537
2538 if(l == VT_BSTR) continue;
2539 if(l == VT_DISPATCH) continue;
2540 if(r == VT_BSTR) continue;
2541 if(r == VT_DISPATCH) continue;
2542
2543 lFound = TRUE;
2544 lValid = TRUE;
2545 switch(l)
2546 {
2547 case VT_EMPTY:
2548 case VT_NULL:
2549 case VT_I1:
2550 case VT_UI1:
2551 case VT_I2:
2552 case VT_UI2:
2553 case VT_I4:
2554 case VT_I8:
2555 case VT_UI4:
2556 case VT_UI8:
2557 case VT_INT:
2558 case VT_UINT:
2559 case VT_R4:
2560 case VT_R8:
2561 case VT_BOOL:
2562 case VT_DATE:
2563 case VT_CY:
2564 case VT_DECIMAL:
2565 hexpected = S_OK;
2566 break;
2567 case VT_ERROR:
2568 case VT_VARIANT:
2569 case VT_UNKNOWN:
2570 case VT_RECORD:
2571 lValid = FALSE;
2572 break;
2573 default:
2574 lFound = FALSE;
2575 hexpected = DISP_E_BADVARTYPE;
2576 break;
2577 }
2578
2579 rFound = TRUE;
2580 switch(r)
2581 {
2582 case VT_EMPTY:
2583 case VT_NULL:
2584 case VT_I1:
2585 case VT_UI1:
2586 case VT_I2:
2587 case VT_UI2:
2588 case VT_I4:
2589 case VT_I8:
2590 case VT_UI4:
2591 case VT_UI8:
2592 case VT_INT:
2593 case VT_UINT:
2594 case VT_R4:
2595 case VT_R8:
2596 case VT_BOOL:
2597 case VT_DATE:
2598 case VT_DECIMAL:
2599 case VT_CY:
2600 hexpected = S_OK;
2601 break;
2602 case VT_ERROR:
2603 case VT_VARIANT:
2604 case VT_UNKNOWN:
2605 case VT_RECORD:
2606 break;
2607 default:
2608 rFound = FALSE;
2609 break;
2610 }
2611
2612 if(((l == VT_I8) && (r == VT_INT)) || ((l == VT_INT) && (r == VT_I8)))
2613 {
2614 hexpected = DISP_E_TYPEMISMATCH;
2615 } else if((l == VT_EMPTY) && (r == VT_NULL))
2616 {
2617 hexpected = S_OK;
2618 } else if((l == VT_NULL) && (r == VT_EMPTY))
2619 {
2620 hexpected = S_OK;
2621 } else if((l == VT_EMPTY) && (r == VT_CY))
2622 {
2623 hexpected = S_OK;
2624 } else if((l == VT_EMPTY) && (r == VT_RECORD))
2625 {
2626 hexpected = DISP_E_TYPEMISMATCH;
2627 } else if((r == VT_EMPTY) && lFound && lValid)
2628 {
2629 hexpected = DISP_E_DIVBYZERO;
2630 } else if((l == VT_ERROR) || ((r == VT_ERROR) && lFound && lValid))
2631 {
2632 hexpected = DISP_E_TYPEMISMATCH;
2633 } else if((l == VT_NULL) && (r == VT_NULL))
2634 {
2635 hexpected = S_OK;
2636 } else if((l == VT_VARIANT) || ((r == VT_VARIANT) && lFound && lValid))
2637 {
2638 hexpected = DISP_E_TYPEMISMATCH;
2639 } else if((l == VT_NULL) && (r == VT_RECORD))
2640 {
2641 hexpected = DISP_E_TYPEMISMATCH;
2642 } else if((l == VT_I8) && (r == VT_DECIMAL))
2643 {
2644 hexpected = S_OK;
2645 } else if((l == VT_DECIMAL) && (r == VT_I8))
2646 {
2647 hexpected = S_OK;
2648 } else if((l == VT_UNKNOWN) || ((r == VT_UNKNOWN) && lFound && lValid))
2649 {
2650 hexpected = DISP_E_TYPEMISMATCH;
2651 } else if((l == VT_NULL) && rFound)
2652 {
2653 hexpected = S_OK;
2654 } else if(l == VT_RECORD)
2655 {
2656 hexpected = DISP_E_TYPEMISMATCH;
2657 } else if((r == VT_RECORD) && lValid && lFound)
2658 {
2659 hexpected = DISP_E_TYPEMISMATCH;
2660 } else if((l == VT_EMPTY) && (r == VT_EMPTY))
2661 {
2662 hexpected = DISP_E_DIVBYZERO;
2663 } else if((l == VT_CY) && !rFound)
2664 {
2665 hexpected = DISP_E_BADVARTYPE;
2666 } else if(lFound && !rFound)
2667 {
2668 hexpected = DISP_E_BADVARTYPE;
2669 } else if(!lFound && rFound)
2670 {
2671 hexpected = DISP_E_BADVARTYPE;
2672 } else if((r == VT_NULL) && lFound && lValid)
2673 {
2674 hexpected = S_OK;
2675 } else if((l == VT_NULL) || (r == VT_NULL))
2676 {
2677 hexpected = DISP_E_BADVARTYPE;
2678 } else if((l == VT_VARIANT) || (r == VT_VARIANT))
2679 {
2680 hexpected = DISP_E_BADVARTYPE;
2681 } else if(lFound && !rFound)
2682 {
2683 hexpected = DISP_E_BADVARTYPE;
2684 } else if(!lFound && !rFound)
2685 {
2686 hexpected = DISP_E_BADVARTYPE;
2687 }
2688
2689 V_VT(&v1) = l;
2690 V_VT(&v2) = r;
2691
2692 if(l == VT_CY)
2693 V_CY(&v1).int64 = 1000000;
2694 else if(l == VT_R4)
2695 V_R4(&v1) = 100;
2696 else if(l == VT_R8)
2697 V_R8(&v1) = 100;
2698 else if(l == VT_UI8)
2699 V_UI8(&v1) = 100;
2700 else if(l == VT_I8)
2701 V_I8(&v1) = 100;
2702 else if(l == VT_DATE)
2703 V_DATE(&v1) = 1000;
2704 else if (l == VT_DECIMAL)
2705 {
2706 V_DECIMAL(&v1).Hi32 = 0;
2707 U1(V_DECIMAL(&v1)).Lo64 = 100;
2708 U(V_DECIMAL(&v1)).signscale = 0;
2709 }
2710 else
2711 V_I4(&v1) = 10000;
2712
2713 if(r == VT_CY)
2714 V_CY(&v2).int64 = 10000;
2715 else if(r == VT_R4)
2716 V_R4(&v2) = 100;
2717 else if(r == VT_R8)
2718 V_R8(&v2) = 100;
2719 else if(r == VT_UI8)
2720 V_UI8(&v2) = 100;
2721 else if(r == VT_I8)
2722 V_I8(&v2) = 100;
2723 else if(r == VT_DATE)
2724 V_DATE(&v2) = 1000;
2725 else if (r == VT_DECIMAL)
2726 {
2727 V_DECIMAL(&v2).Hi32 = 0;
2728 U1(V_DECIMAL(&v2)).Lo64 = 100;
2729 U(V_DECIMAL(&v2)).signscale = 0;
2730 }
2731 else
2732 V_I4(&v2) = 10000;
2733
2734 if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
2735 {
2736 hres = pVarMod(&v1,&v2,&vDst);
2737 ok(hres == hexpected,
2738 "VarMod: expected 0x%x, got 0x%X for l type of %d, r type of %d,\n", hexpected, hres, l, r);
2739 }
2740 }
2741 }
2742
2743
2744 /****************************/
2745 /* test some bad parameters */
2746 VARMOD(I4,I4,-1,-1,I4,0);
2747
2748 /* test modulus with zero */
2749 VARMOD2(I4,I4,100,0,EMPTY,0,DISP_E_DIVBYZERO);
2750
2751 VARMOD(I4,I4,0,10,I4,0); /* test 0 mod 10 */
2752
2753 /* right parameter is type empty */
2754 VARMOD2(I4,EMPTY,100,10,EMPTY,0,DISP_E_DIVBYZERO);
2755
2756 /* left parameter is type empty */
2757 VARMOD2(EMPTY,I4,100,10,I4,0,S_OK);
2758
2759 /* mod with a null left value */
2760 VARMOD2(NULL,I4,125,10,NULL,0,S_OK);
2761
2762 /* mod with a null right value */
2763 VARMOD2(I4,NULL,100,10,NULL,0,S_OK);
2764
2765 /* void left value */
2766 VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2767
2768 /* void right value */
2769 VARMOD2(I4,VOID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2770
2771 /* null left value, void right value */
2772 VARMOD2(NULL,VOID,100,10,EMPTY, 0, DISP_E_BADVARTYPE);
2773
2774 /* void left value, null right value */
2775 VARMOD2(VOID,NULL,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2776
2777 /* some currencies */
2778 V_VT(&v1) = VT_CY;
2779 V_VT(&v2) = VT_CY;
2780 V_CY(&v1).int64 = 100000;
2781 V_CY(&v2).int64 = 100000;
2782 hres = pVarMod(&v1,&v2,&vDst);
2783 ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2784 "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2785
2786 V_VT(&v1) = VT_I4;
2787 V_VT(&v2) = VT_CY;
2788 V_I4(&v1) = 100;
2789 V_CY(&v2).int64 = 100000;
2790 hres = pVarMod(&v1,&v2,&vDst);
2791 ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2792 "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2793
2794 /* some decimals */
2795 V_VT(&v1) = VT_DECIMAL;
2796 V_VT(&v2) = VT_DECIMAL;
2797 VarDecFromI4(100, &V_DECIMAL(&v1));
2798 VarDecFromI4(10, &V_DECIMAL(&v2));
2799 hres = pVarMod(&v1,&v2,&vDst);
2800 ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2801 "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2802
2803 V_VT(&v1) = VT_I4;
2804 V_VT(&v2) = VT_DECIMAL;
2805 V_I4(&v1) = 100;
2806 VarDecFromI4(10, &V_DECIMAL(&v2));
2807 hres = pVarMod(&v1,&v2,&vDst);
2808 ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == 0,
2809 "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", S_OK, VT_I4, 0, hres, V_VT(&vDst), V_I4(&vDst));
2810
2811 VARMOD2(UINT,I4,100,10,I4,0,S_OK);
2812
2813 /* test that an error results in the type of the result changing but not its value */
2814 V_VT(&v1) = VT_UNKNOWN;
2815 V_VT(&v2) = VT_EMPTY;
2816 V_I4(&v1) = 100;
2817 V_CY(&v2).int64 = 100000;
2818 V_VT(&vDst) = VT_I4;
2819 V_I4(&vDst) = 1231;
2820 hres = pVarMod(&v1,&v2,&vDst);
2821 ok(hres == DISP_E_TYPEMISMATCH && V_VT(&vDst) == VT_EMPTY && V_I4(&vDst) == 1231,
2822 "VarMod: expected 0x%x,%d,%d, got 0x%X,%d,%d\n", DISP_E_TYPEMISMATCH, VT_EMPTY, 1231, hres, V_VT(&vDst), V_I4(&vDst));
2823
2824
2825 /* test some invalid types */
2826 /*TODO: not testing VT_DISPATCH */
2827 if (HAVE_OLEAUT32_I8)
2828 {
2829 VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2830 }
2831 VARMOD2(ERROR,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2832 VARMOD2(VARIANT,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2833 VARMOD2(UNKNOWN,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2834 VARMOD2(VOID,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2835 VARMOD2(HRESULT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2836 VARMOD2(PTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2837 VARMOD2(SAFEARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2838 VARMOD2(CARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2839 VARMOD2(USERDEFINED,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2840 VARMOD2(LPSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2841 VARMOD2(LPWSTR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2842 VARMOD2(RECORD,I4,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
2843 VARMOD2(FILETIME,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2844 VARMOD2(BLOB,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2845 VARMOD2(STREAM,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2846 VARMOD2(STORAGE,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2847 VARMOD2(STREAMED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2848 VARMOD2(STORED_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2849 VARMOD2(BLOB_OBJECT,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2850 VARMOD2(CF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2851 VARMOD2(CLSID,CLSID,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2852 VARMOD2(VECTOR,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2853 VARMOD2(ARRAY,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2854 VARMOD2(BYREF,I4,100,10,EMPTY,0,DISP_E_BADVARTYPE);
2855
2856 /* test some more invalid types */
2857 V_VT(&v1) = 456;
2858 V_VT(&v2) = 234;
2859 V_I4(&v1) = 100;
2860 V_I4(&v2)= 10;
2861 hres = pVarMod(&v1,&v2,&vDst);
2862 ok(hres == DISP_E_BADVARTYPE && V_VT(&vDst) == VT_EMPTY,
2863 "VarMod: expected 0x%x,%d, got 0x%X,%d\n", DISP_E_BADVARTYPE, VT_EMPTY, hres, V_VT(&vDst));
2864
2865 SysFreeString(strNum0);
2866 SysFreeString(strNum1);
2867 }
2868
2869 static HRESULT (WINAPI *pVarFix)(LPVARIANT,LPVARIANT);
2870
2871 #define VARFIX(vt,val,rvt,rval) \
2872 V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2873 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2874 test_var_call1( __LINE__, pVarFix, &v, &exp )
2875
2876 static void test_VarFix(void)
2877 {
2878 static const WCHAR szNumMinus1[] = {'-','1','\0' };
2879 HRESULT hres;
2880 VARIANT v, exp, vDst;
2881 DECIMAL *pdec = &V_DECIMAL(&v);
2882 CY *pcy = &V_CY(&v);
2883 size_t i;
2884
2885 CHECKPTR(VarFix);
2886
2887 /* Test all possible V_VT values */
2888 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
2889 {
2890 VARTYPE vt;
2891
2892 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
2893 {
2894 HRESULT bFail = TRUE;
2895
2896 SKIPTESTS(vt);
2897
2898 memset(&v, 0, sizeof(v));
2899 V_VT(&v) = vt | ExtraFlags[i];
2900 V_VT(&vDst) = VT_EMPTY;
2901
2902 switch (V_VT(&v))
2903 {
2904 case VT_UI1: case VT_I2: case VT_I4: case VT_R4: case VT_R8:
2905 case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
2906 case VT_DATE: case VT_CY:
2907 bFail = FALSE;
2908 break;
2909 case VT_I8:
2910 if (HAVE_OLEAUT32_I8)
2911 bFail = FALSE;
2912 break;
2913 }
2914
2915 hres = pVarFix(&v,&vDst);
2916 if (bFail)
2917 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
2918 "VarFix: expected failure, got 0x%X vt %d|0x%X\n",
2919 hres, vt, ExtraFlags[i]);
2920 else
2921 ok(hres == S_OK, "VarFix: expected S_OK, got 0x%X vt %d|0x%X\n",
2922 hres, vt, ExtraFlags[i]);
2923 }
2924 }
2925
2926 VARFIX(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
2927 VARFIX(BOOL,VARIANT_FALSE,I2,0);
2928 VARFIX(BOOL,1,I2,1);
2929 VARFIX(UI1,1,UI1,1);
2930 VARFIX(I2,-1,I2,-1);
2931 VARFIX(I4,-1,I4,-1);
2932 if (HAVE_OLEAUT32_I8)
2933 {
2934 VARFIX(I8,-1,I8,-1);
2935 }
2936 VARFIX(R4,1.4f,R4,1);
2937 VARFIX(R4,1.5f,R4,1);
2938 VARFIX(R4,1.6f,R4,1);
2939 VARFIX(R4,-1.4f,R4,-1);
2940 VARFIX(R4,-1.5f,R4,-1);
2941 VARFIX(R4,-1.6f,R4,-1);
2942 /* DATE & R8 round as for R4 */
2943 VARFIX(DATE,-1,DATE,-1);
2944 VARFIX(R8,-1,R8,-1);
2945 VARFIX(BSTR,(BSTR)szNumMinus1,R8,-1);
2946
2947 V_VT(&v) = VT_EMPTY;
2948 hres = pVarFix(&v,&vDst);
2949 ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
2950 "VarFix: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
2951 hres, V_VT(&vDst), V_I2(&vDst));
2952
2953 V_VT(&v) = VT_NULL;
2954 hres = pVarFix(&v,&vDst);
2955 ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
2956 "VarFix: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
2957
2958 V_VT(&v) = VT_DECIMAL;
2959 S(U(*pdec)).sign = DECIMAL_NEG;
2960 S(U(*pdec)).scale = 0;
2961 pdec->Hi32 = 0;
2962 S1(U1(*pdec)).Mid32 = 0;
2963 S1(U1(*pdec)).Lo32 = 1;
2964 hres = pVarFix(&v,&vDst);
2965 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
2966 "VarFix: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
2967 hres, V_VT(&vDst));
2968
2969 /* FIXME: Test some fractional decimals when VarDecFix is implemented */
2970
2971 V_VT(&v) = VT_CY;
2972 pcy->int64 = -10000;
2973 hres = pVarFix(&v,&vDst);
2974 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2975 "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2976
2977 V_VT(&v) = VT_CY;
2978 pcy->int64 = -16000;
2979 hres = pVarFix(&v,&vDst);
2980 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
2981 "VarFix: VT_CY wrong, hres=0x%X\n", hres);
2982 }
2983
2984 static HRESULT (WINAPI *pVarInt)(LPVARIANT,LPVARIANT);
2985
2986 #define VARINT(vt,val,rvt,rval) \
2987 V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
2988 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
2989 test_var_call1( __LINE__, pVarInt, &v, &exp )
2990
2991 static void test_VarInt(void)
2992 {
2993 static const WCHAR szNumMinus1[] = {'-','1','\0' };
2994 HRESULT hres;
2995 VARIANT v, exp, vDst;
2996 DECIMAL *pdec = &V_DECIMAL(&v);
2997 CY *pcy = &V_CY(&v);
2998 size_t i;
2999
3000 CHECKPTR(VarInt);
3001
3002 /* Test all possible V_VT values */
3003 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3004 {
3005 VARTYPE vt;
3006
3007 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3008 {
3009 HRESULT bFail = TRUE;
3010
3011 SKIPTESTS(vt);
3012
3013 memset(&v, 0, sizeof(v));
3014 V_VT(&v) = vt | ExtraFlags[i];
3015 V_VT(&vDst) = VT_EMPTY;
3016
3017 switch (V_VT(&v))
3018 {
3019 case VT_UI1: case VT_I2: case VT_I4: case VT_R4: case VT_R8:
3020 case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3021 case VT_DATE: case VT_CY:
3022 bFail = FALSE;
3023 break;
3024 case VT_I8:
3025 if (HAVE_OLEAUT32_I8)
3026 bFail = FALSE;
3027 break;
3028 }
3029
3030 hres = pVarInt(&v,&vDst);
3031 if (bFail)
3032 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3033 "VarInt: expected failure, got 0x%X vt %d|0x%X\n",
3034 hres, vt, ExtraFlags[i]);
3035 else
3036 ok(hres == S_OK, "VarInt: expected S_OK, got 0x%X vt %d|0x%X\n",
3037 hres, vt, ExtraFlags[i]);
3038 }
3039 }
3040
3041 VARINT(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE);
3042 VARINT(BOOL,VARIANT_FALSE,I2,0);
3043 VARINT(BOOL,1,I2,1);
3044 VARINT(UI1,1,UI1,1);
3045 VARINT(I2,-1,I2,-1);
3046 VARINT(I4,-1,I4,-1);
3047 if (HAVE_OLEAUT32_I8)
3048 {
3049 VARINT(I8,-1,I8,-1);
3050 }
3051 VARINT(R4,1.4f,R4,1);
3052 VARINT(R4,1.5f,R4,1);
3053 VARINT(R4,1.6f,R4,1);
3054 VARINT(R4,-1.4f,R4,-2); /* Note these 3 are different from VarFix */
3055 VARINT(R4,-1.5f,R4,-2);
3056 VARINT(R4,-1.6f,R4,-2);
3057 /* DATE & R8 round as for R4 */
3058 VARINT(DATE,-1,DATE,-1);
3059 VARINT(R8,-1,R8,-1);
3060 VARINT(BSTR,(BSTR)szNumMinus1,R8,-1);
3061
3062 V_VT(&v) = VT_EMPTY;
3063 hres = pVarInt(&v,&vDst);
3064 ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3065 "VarInt: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3066 hres, V_VT(&vDst), V_I2(&vDst));
3067
3068 V_VT(&v) = VT_NULL;
3069 hres = pVarInt(&v,&vDst);
3070 ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3071 "VarInt: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3072
3073 V_VT(&v) = VT_DECIMAL;
3074 S(U(*pdec)).sign = DECIMAL_NEG;
3075 S(U(*pdec)).scale = 0;
3076 pdec->Hi32 = 0;
3077 S1(U1(*pdec)).Mid32 = 0;
3078 S1(U1(*pdec)).Lo32 = 1;
3079 hres = pVarInt(&v,&vDst);
3080 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && !memcmp(&V_DECIMAL(&v), &V_DECIMAL(&vDst), sizeof(DECIMAL)),
3081 "VarInt: expected 0x0,%d,identical, got 0x%X,%d\n", VT_DECIMAL,
3082 hres, V_VT(&vDst));
3083
3084 /* FIXME: Test some fractional decimals when VarDecInt is implemented */
3085
3086 V_VT(&v) = VT_CY;
3087 pcy->int64 = -10000;
3088 hres = pVarInt(&v,&vDst);
3089 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -10000,
3090 "VarInt: VT_CY wrong, hres=0x%X\n", hres);
3091
3092 V_VT(&v) = VT_CY;
3093 pcy->int64 = -11000;
3094 hres = pVarInt(&v,&vDst);
3095 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == -20000,
3096 "VarInt: VT_CY wrong, hres=0x%X 0x%x%08x\n",
3097 hres, (DWORD)(V_CY(&vDst).int64 >> 32), (DWORD)V_CY(&vDst).int64);
3098 }
3099
3100 static HRESULT (WINAPI *pVarNeg)(LPVARIANT,LPVARIANT);
3101
3102 #define VARNEG(vt,val,rvt,rval) \
3103 V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
3104 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3105 test_var_call1( __LINE__, pVarNeg, &v, &exp )
3106
3107 static void test_VarNeg(void)
3108 {
3109 static const WCHAR szNumMinus1[] = {'-','1','\0' };
3110 static const WCHAR szNum1[] = {'1','\0' };
3111 HRESULT hres;
3112 VARIANT v, exp, vDst;
3113 DECIMAL *pdec = &V_DECIMAL(&v);
3114 CY *pcy = &V_CY(&v);
3115 size_t i;
3116
3117 CHECKPTR(VarNeg);
3118
3119 /* Test all possible V_VT values. But don't test the exact return values
3120 * except for success/failure, since M$ made a hash of them in the
3121 * native version. This at least ensures (as with all tests here) that
3122 * we will notice if/when new vtypes/flags are added in native.
3123 */
3124 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3125 {
3126 VARTYPE vt;
3127
3128 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
3129 {
3130 HRESULT bFail = TRUE;
3131
3132 SKIPTESTS(vt);
3133
3134 memset(&v, 0, sizeof(v));
3135 V_VT(&v) = vt | ExtraFlags[i];
3136 V_VT(&vDst) = VT_EMPTY;
3137
3138 switch (V_VT(&v))
3139 {
3140 case VT_UI1: case VT_I2: case VT_I4:
3141 case VT_R4: case VT_R8:
3142 case VT_DECIMAL: case VT_BOOL: case VT_NULL: case VT_EMPTY:
3143 case VT_DATE: case VT_CY:
3144 bFail = FALSE;
3145 break;
3146 case VT_I8:
3147 if (HAVE_OLEAUT32_I8)
3148 bFail = FALSE;
3149 }
3150
3151 hres = pVarNeg(&v,&vDst);
3152 if (bFail)
3153 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3154 "VarNeg: expected failure, got 0x%X vt %d|0x%X\n",
3155 hres, vt, ExtraFlags[i]);
3156 else
3157 ok(hres == S_OK, "VarNeg: expected S_OK, got 0x%X vt %d|0x%X\n",
3158 hres, vt, ExtraFlags[i]);
3159 }
3160 }
3161
3162 VARNEG(BOOL,VARIANT_TRUE,I2,1);
3163 VARNEG(BOOL,VARIANT_FALSE,I2,0);
3164 VARNEG(BOOL,1,I2,-1);
3165 VARNEG(UI1,1,I2,-1);
3166 VARNEG(UI1,254,I2,-254);
3167 VARNEG(I2,-32768,I4,32768);
3168 VARNEG(I2,-1,I2,1);
3169 VARNEG(I2,1,I2,-1);
3170 VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
3171 VARNEG(I4,-1,I4,1);
3172 VARNEG(I4,1,I4,-1);
3173 if (HAVE_OLEAUT32_I8)
3174 {
3175 VARNEG(I8,1,I8,-1);
3176 VARNEG(I8,-1,I8,1);
3177 }
3178 VARNEG(R4,1,R4,-1);
3179 VARNEG(R4,-1,R4,1);
3180 VARNEG(DATE,1,DATE,-1);
3181 VARNEG(DATE,-1,DATE,1);
3182 VARNEG(R8,1,R8,-1);
3183 VARNEG(R8,-1,R8,1);
3184 VARNEG(BSTR,(BSTR)szNumMinus1,R8,1);
3185 VARNEG(BSTR,(BSTR)szNum1,R8,-1);
3186
3187 V_VT(&v) = VT_EMPTY;
3188 hres = pVarNeg(&v,&vDst);
3189 ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3190 "VarNeg: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3191 hres, V_VT(&vDst), V_I2(&vDst));
3192
3193 V_VT(&v) = VT_NULL;
3194 hres = pVarNeg(&v,&vDst);
3195 ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3196 "VarNeg: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3197
3198 V_VT(&v) = VT_DECIMAL;
3199 S(U(*pdec)).sign = DECIMAL_NEG;
3200 S(U(*pdec)).scale = 0;
3201 pdec->Hi32 = 0;
3202 S1(U1(*pdec)).Mid32 = 0;
3203 S1(U1(*pdec)).Lo32 = 1;
3204 hres = pVarNeg(&v,&vDst);
3205 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3206 S(U(V_DECIMAL(&vDst))).sign == 0,
3207 "VarNeg: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3208 hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3209
3210 S(U(*pdec)).sign = 0;
3211 hres = pVarNeg(&v,&vDst);
3212 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3213 S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3214 "VarNeg: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3215 hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3216
3217 V_VT(&v) = VT_CY;
3218 pcy->int64 = -10000;
3219 hres = pVarNeg(&v,&vDst);
3220 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3221 "VarNeg: VT_CY wrong, hres=0x%X\n", hres);
3222 }
3223
3224 static HRESULT (WINAPI *pVarRound)(LPVARIANT,int,LPVARIANT);
3225
3226 static void test_Round( int line, VARIANT *arg, int deci, VARIANT *expected )
3227 {
3228 VARIANT result;
3229 HRESULT hres;
3230
3231 memset( &result, 0, sizeof(result) );
3232 hres = pVarRound( arg, deci, &result );
3233 ok_(__FILE__,line)( hres == S_OK, "wrong result %x\n", hres );
3234 if (hres == S_OK)
3235 ok_(__FILE__,line)( is_expected_variant( &result, expected ),
3236 "got %s expected %s\n", variantstr(&result), variantstr(expected) );
3237 }
3238 #define VARROUND(vt,val,deci,rvt,rval) \
3239 V_VT(&v) = VT_##vt; V_##vt(&v) = val; \
3240 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3241 test_Round( __LINE__, &v, deci, &exp )
3242
3243 static void test_VarRound(void)
3244 {
3245 static WCHAR szNumMin[] = {'-','1','.','4','4','9','\0' };
3246 static WCHAR szNum[] = {'1','.','4','5','1','\0' };
3247 HRESULT hres;
3248 VARIANT v, exp, vDst;
3249 CY *pcy = &V_CY(&v);
3250 char buff[8];
3251
3252 CHECKPTR(VarRound);
3253
3254 /* first check valid integer types */
3255 VARROUND(BOOL,VARIANT_TRUE,0,I2,-1);
3256 VARROUND(BOOL,VARIANT_FALSE,0,I2,0);
3257 VARROUND(BOOL,1,0,I2,1);
3258 VARROUND(UI1,1,0,UI1,1);
3259 VARROUND(UI1,254,0,UI1,254);
3260 VARROUND(I2,-32768,0,I2,-32768);
3261 VARROUND(I2,-1,0,I2,-1);
3262 VARROUND(I2,1,0,I2,1);
3263 VARROUND(I4,-((int)(~0u >> 1)) - 1,0,I4,-((int)(~0u >> 1)) - 1);
3264 VARROUND(I4,-1,0,I4,-1);
3265 VARROUND(I4,1,0,I4,1);
3266
3267
3268 /* MSDN states that rounding of R4/R8 is dependent on the underlying
3269 * bit pattern of the number and so is architecture dependent. In this
3270 * case Wine returns .2 (which is more correct) and Native returns .3
3271 */
3272
3273 VARROUND(R4,1.0f,0,R4,1.0f);
3274 VARROUND(R4,-1.0f,0,R4,-1.0f);
3275 VARROUND(R8,1.0,0,R8,1.0);
3276 VARROUND(R8,-1.0,0,R8,-1.0);
3277
3278 /* floating point numbers aren't exactly equal and we can't just
3279 * compare the first few digits. */
3280 VARROUND(DATE,1.451,1,DATE,1.5);
3281 VARROUND(DATE,-1.449,1,DATE,-1.4);
3282
3283 /* replace the decimal separator */
3284 GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));
3285 if (!buff[1]) {
3286 szNumMin[2] = buff[0];
3287 szNum[1] = buff[0];
3288 VARROUND(BSTR,(BSTR)szNumMin,1,R8,-1.40);
3289 VARROUND(BSTR,(BSTR)szNum,1,R8,1.50);
3290 } else {
3291 skip("Skipping VarRound(BSTR) as decimal separator is '%s'\n", buff);
3292 }
3293
3294 VARROUND(R4,1.23456f,0,R4,1.0f);
3295 VARROUND(R4,1.23456f,1,R4,1.2f);
3296 VARROUND(R4,1.23456f,2,R4,1.23f);
3297 VARROUND(R4,1.23456f,3,R4,1.235f);
3298 VARROUND(R4,1.23456f,4,R4,1.2346f);
3299 VARROUND(R4,-1.23456f,0,R4,-1.0f);
3300 VARROUND(R4,-1.23456f,1,R4,-1.2f);
3301 VARROUND(R4,-1.23456f,2,R4,-1.23f);
3302 VARROUND(R4,-1.23456f,3,R4,-1.235f);
3303 VARROUND(R4,-1.23456f,4,R4,-1.2346f);
3304
3305 VARROUND(R8,1.23456,0,R8,1.0);
3306 VARROUND(R8,1.23456,1,R8,1.2);
3307 VARROUND(R8,1.23456,2,R8,1.23);
3308 VARROUND(R8,1.23456,3,R8,1.235);
3309 VARROUND(R8,1.23456,4,R8,1.2346);
3310 VARROUND(R8,-1.23456,0,R8,-1.0);
3311 VARROUND(R8,-1.23456,1,R8,-1.2);
3312 VARROUND(R8,-1.23456,2,R8,-1.23);
3313 VARROUND(R8,-1.23456,3,R8,-1.235);
3314 VARROUND(R8,-1.23456,4,R8,-1.2346);
3315
3316 V_VT(&v) = VT_EMPTY;
3317 hres = pVarRound(&v,0,&vDst);
3318 ok(hres == S_OK && V_VT(&vDst) == VT_I2 && V_I2(&vDst) == 0,
3319 "VarRound: expected 0x0,%d,0 got 0x%X,%d,%d\n", VT_EMPTY,
3320 hres, V_VT(&vDst), V_I2(&vDst));
3321
3322 V_VT(&v) = VT_NULL;
3323 hres = pVarRound(&v,0,&vDst);
3324 ok(hres == S_OK && V_VT(&vDst) == VT_NULL,
3325 "VarRound: expected 0x0,%d got 0x%X,%d\n", VT_NULL, hres, V_VT(&vDst));
3326
3327 /* not yet implemented so no use testing yet
3328 todo_wine {
3329 DECIMAL *pdec = &V_DECIMAL(&v);
3330 V_VT(&v) = VT_DECIMAL;
3331 S(U(*pdec)).sign = DECIMAL_NEG;
3332 S(U(*pdec)).scale = 0;
3333 pdec->Hi32 = 0;
3334 S1(U1(*pdec)).Mid32 = 0;
3335 S1(U1(*pdec)).Lo32 = 1;
3336 hres = pVarRound(&v,0,&vDst);
3337 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3338 S(U(V_DECIMAL(&vDst))).sign == 0,
3339 "VarRound: expected 0x0,%d,0x00, got 0x%X,%d,%02x\n", VT_DECIMAL,
3340 hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3341
3342 S(U(*pdec)).sign = 0;
3343 hres = pVarRound(&v,0,&vDst);
3344 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL &&
3345 S(U(V_DECIMAL(&vDst))).sign == DECIMAL_NEG,
3346 "VarRound: expected 0x0,%d,0x7f, got 0x%X,%d,%02x\n", VT_DECIMAL,
3347 hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign);
3348 }
3349 */
3350
3351 V_VT(&v) = VT_CY;
3352 pcy->int64 = 10000;
3353 hres = pVarRound(&v,0,&vDst);
3354 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == 10000,
3355 "VarRound: VT_CY wrong, hres=0x%X\n", hres);
3356
3357 }
3358
3359 static HRESULT (WINAPI *pVarXor)(LPVARIANT,LPVARIANT,LPVARIANT);
3360
3361 #define VARXOR(vt1,val1,vt2,val2,rvt,rval) \
3362 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3363 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
3364 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3365 test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3366
3367 #define VARXORCY(vt1,val1,val2,rvt,rval) \
3368 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
3369 V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
3370 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
3371 test_var_call2( __LINE__, pVarXor, &left, &right, &exp )
3372
3373 static void test_VarXor(void)
3374 {
3375 static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
3376 static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
3377 VARIANT left, right, exp, result;
3378 BSTR lbstr, rbstr;
3379 VARTYPE i;
3380 HRESULT hres;
3381
3382 CHECKPTR(VarXor);
3383
3384 /* Test all possible flag/vt combinations & the resulting vt type */
3385 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
3386 {
3387 VARTYPE leftvt, rightvt, resvt;
3388
3389 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
3390 {
3391
3392 SKIPTESTS(leftvt);
3393
3394 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
3395 {
3396 BOOL bFail = FALSE;
3397
3398 SKIPTESTS(rightvt);
3399
3400 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
3401 leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3402 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
3403 continue;
3404
3405 memset(&left, 0, sizeof(left));
3406 memset(&right, 0, sizeof(right));
3407 V_VT(&left) = leftvt | ExtraFlags[i];
3408 V_VT(&right) = rightvt | ExtraFlags[i];
3409 V_VT(&result) = VT_EMPTY;
3410 resvt = VT_I4;
3411
3412 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
3413 !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
3414 !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
3415 leftvt == VT_CLSID || rightvt == VT_CLSID ||
3416 leftvt == VT_RECORD || rightvt == VT_RECORD ||
3417 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3418 leftvt == VT_ERROR || rightvt == VT_ERROR)
3419 {
3420 bFail = TRUE;
3421 }
3422 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3423 {
3424 if (leftvt == rightvt ||
3425 leftvt == VT_I2 || rightvt == VT_I2 ||
3426 leftvt == VT_UI1 || rightvt == VT_UI1 ||
3427 leftvt == VT_BOOL || rightvt == VT_BOOL)
3428 resvt = VT_I2;
3429 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3430 resvt = VT_NULL;
3431 else if (leftvt == VT_I8 || rightvt == VT_I8)
3432 resvt = VT_I8;
3433 }
3434 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3435 {
3436 resvt = VT_NULL;
3437 }
3438 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3439 {
3440 if (leftvt == rightvt)
3441 resvt = VT_UI1;
3442 else if (leftvt == rightvt ||
3443 leftvt == VT_I2 || rightvt == VT_I2 ||
3444 leftvt == VT_BOOL || rightvt == VT_BOOL)
3445 {
3446 resvt = VT_I2;
3447 }
3448 else if (leftvt == VT_I8 || rightvt == VT_I8)
3449 resvt = VT_I8;
3450 }
3451 else if (leftvt == VT_I2 || rightvt == VT_I2)
3452 {
3453 if (leftvt == rightvt ||
3454 leftvt == VT_BOOL || rightvt == VT_BOOL)
3455 resvt = VT_I2;
3456 else if (leftvt == VT_I8 || rightvt == VT_I8)
3457 resvt = VT_I8;
3458 }
3459 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
3460 {
3461 resvt = VT_BOOL;
3462 }
3463 else if (leftvt == VT_I8 || rightvt == VT_I8)
3464 {
3465 if (leftvt == VT_INT || rightvt == VT_INT)
3466 bFail = TRUE;
3467 else
3468 resvt = VT_I8;
3469 }
3470 hres = pVarXor(&left, &right, &result);
3471 if (bFail)
3472 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
3473 "VarXor: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
3474 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
3475 V_VT(&result));
3476 else
3477 ok(hres == S_OK && V_VT(&result) == resvt,
3478 "VarXor: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
3479 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
3480 V_VT(&result));
3481 }
3482 }
3483 }
3484
3485 /* Test returned values
3486 * FIXME: Test VT_DECIMAL/VT_DISPATCH
3487 */
3488 VARXOR(EMPTY,0,EMPTY,0,I2,0);
3489 VARXOR(EMPTY,1,EMPTY,0,I2,0);
3490 VARXOR(EMPTY,0,NULL,0,NULL,0);
3491 VARXOR(EMPTY,0,I1,0,I4,0);
3492 VARXOR(EMPTY,0,I1,1,I4,1);
3493 VARXOR(EMPTY,0,UI1,0,I2,0);
3494 VARXOR(EMPTY,0,UI1,1,I2,1);
3495 VARXOR(EMPTY,0,I2,0,I2,0);
3496 VARXOR(EMPTY,0,I2,1,I2,1);
3497 VARXOR(EMPTY,0,UI2,0,I4,0);
3498 VARXOR(EMPTY,0,UI2,1,I4,1);
3499 VARXOR(EMPTY,0,I4,0,I4,0);
3500 VARXOR(EMPTY,0,I4,1,I4,1);
3501 VARXOR(EMPTY,0,UI4,0,I4,0);
3502 VARXOR(EMPTY,0,UI4,1,I4,1);
3503 if (HAVE_OLEAUT32_I8)
3504 {
3505 VARXOR(EMPTY,0,I8,0,I8,0);
3506 VARXOR(EMPTY,0,I8,1,I8,1);
3507 VARXOR(EMPTY,0,UI8,0,I4,0);
3508 VARXOR(EMPTY,0,UI8,1,I4,1);
3509 }
3510 VARXOR(EMPTY,0,INT,0,I4,0);
3511 VARXOR(EMPTY,0,INT,1,I4,1);
3512 VARXOR(EMPTY,0,UINT,0,I4,0);
3513 VARXOR(EMPTY,0,UINT,1,I4,1);
3514 VARXOR(EMPTY,0,BOOL,0,I2,0);
3515 VARXOR(EMPTY,0,BOOL,1,I2,1);
3516 VARXOR(EMPTY,0,R4,0,I4,0);
3517 VARXOR(EMPTY,0,R4,1,I4,1);
3518 VARXOR(EMPTY,0,R8,0,I4,0);
3519 VARXOR(EMPTY,0,R8,1,I4,1);
3520 rbstr = SysAllocString(szFalse);
3521 VARXOR(EMPTY,0,BSTR,rbstr,I2,0);
3522 SysFreeString(rbstr);
3523 rbstr = SysAllocString(szTrue);
3524 VARXOR(EMPTY,0,BSTR,rbstr,I2,-1);
3525 VARXORCY(EMPTY,0,10000,I4,1);
3526 SysFreeString(rbstr);
3527
3528 /* NULL OR 0 = NULL. NULL OR n = n */
3529 VARXOR(NULL,0,NULL,0,NULL,0);
3530 VARXOR(NULL,1,NULL,0,NULL,0);
3531 VARXOR(NULL,0,I1,0,NULL,0);
3532 VARXOR(NULL,0,I1,1,NULL,0);
3533 VARXOR(NULL,0,UI1,0,NULL,0);
3534 VARXOR(NULL,0,UI1,1,NULL,0);
3535 VARXOR(NULL,0,I2,0,NULL,0);
3536 VARXOR(NULL,0,I2,1,NULL,0);
3537 VARXOR(NULL,0,UI2,0,NULL,0);
3538 VARXOR(NULL,0,UI2,1,NULL,0);
3539 VARXOR(NULL,0,I4,0,NULL,0);
3540 VARXOR(NULL,0,I4,1,NULL,0);
3541 VARXOR(NULL,0,UI4,0,NULL,0);
3542 VARXOR(NULL,0,UI4,1,NULL,0);
3543 if (HAVE_OLEAUT32_I8)
3544 {
3545 VARXOR(NULL,0,I8,0,NULL,0);
3546 VARXOR(NULL,0,I8,1,NULL,0);
3547 VARXOR(NULL,0,UI8,0,NULL,0);
3548 VARXOR(NULL,0,UI8,1,NULL,0);
3549 }
3550 VARXOR(NULL,0,INT,0,NULL,0);
3551 VARXOR(NULL,0,INT,1,NULL,0);
3552 VARXOR(NULL,0,UINT,0,NULL,0);
3553 VARXOR(NULL,0,UINT,1,NULL,0);
3554 VARXOR(NULL,0,BOOL,0,NULL,0);
3555 VARXOR(NULL,0,BOOL,1,NULL,0);
3556 VARXOR(NULL,0,R4,0,NULL,0);
3557 VARXOR(NULL,0,R4,1,NULL,0);
3558 VARXOR(NULL,0,R8,0,NULL,0);
3559 VARXOR(NULL,0,R8,1,NULL,0);
3560 rbstr = SysAllocString(szFalse);
3561 VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3562 SysFreeString(rbstr);
3563 rbstr = SysAllocString(szTrue);
3564 VARXOR(NULL,0,BSTR,rbstr,NULL,0);
3565 SysFreeString(rbstr);
3566 VARXORCY(NULL,0,10000,NULL,0);
3567 VARXORCY(NULL,0,0,NULL,0);
3568
3569 VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
3570 VARXOR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
3571 VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
3572 VARXOR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
3573 /* Assume x,y & y,x are the same from now on to reduce the number of tests */
3574 VARXOR(BOOL,VARIANT_TRUE,I1,-1,I4,0);
3575 VARXOR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
3576 VARXOR(BOOL,VARIANT_FALSE,I1,0,I4,0);
3577 VARXOR(BOOL,VARIANT_TRUE,UI1,255,I2,-256);
3578 VARXOR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
3579 VARXOR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
3580 VARXOR(BOOL,VARIANT_TRUE,I2,-1,I2,0);
3581 VARXOR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
3582 VARXOR(BOOL,VARIANT_FALSE,I2,0,I2,0);
3583 VARXOR(BOOL,VARIANT_TRUE,UI2,65535,I4,-65536);
3584 VARXOR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
3585 VARXOR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
3586 VARXOR(BOOL,VARIANT_TRUE,I4,-1,I4,0);
3587 VARXOR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
3588 VARXOR(BOOL,VARIANT_FALSE,I4,0,I4,0);
3589 VARXOR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,0);
3590 VARXOR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
3591 VARXOR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
3592 VARXOR(BOOL,VARIANT_TRUE,R4,-1,I4,0);
3593 VARXOR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
3594 VARXOR(BOOL,VARIANT_FALSE,R4,0,I4,0);
3595 VARXOR(BOOL,VARIANT_TRUE,R8,-1,I4,0);
3596 VARXOR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
3597 VARXOR(BOOL,VARIANT_FALSE,R8,0,I4,0);
3598 VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
3599 VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
3600 VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
3601 if (HAVE_OLEAUT32_I8)
3602 {
3603 VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
3604 VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
3605 VARXOR(BOOL,VARIANT_FALSE,I8,0,I8,0);
3606 /* This returns DISP_E_OVERFLOW which indicates that a conversion
3607 * to I4 is performed.
3608 */
3609 /* VARXOR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
3610 VARXOR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
3611 VARXOR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
3612 }
3613 VARXOR(BOOL,VARIANT_TRUE,INT,-1,I4,0);
3614 VARXOR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
3615 VARXOR(BOOL,VARIANT_FALSE,INT,0,I4,0);
3616 VARXOR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,0);
3617 VARXOR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
3618 VARXOR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
3619 rbstr = SysAllocString(szFalse);
3620 VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3621 VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3622 SysFreeString(rbstr);
3623 rbstr = SysAllocString(szTrue);
3624 VARXOR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
3625 VARXOR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_FALSE);
3626 SysFreeString(rbstr);
3627 VARXORCY(BOOL,VARIANT_TRUE,10000,I4,-2);
3628 VARXORCY(BOOL,VARIANT_TRUE,0,I4,-1);
3629 VARXORCY(BOOL,VARIANT_FALSE,0,I4,0);
3630
3631 VARXOR(I1,-1,I1,-1,I4,0);
3632 VARXOR(I1,-1,I1,0,I4,-1);
3633 VARXOR(I1,0,I1,0,I4,0);
3634 VARXOR(I1,-1,UI1,255,I4,-256);
3635 VARXOR(I1,-1,UI1,0,I4,-1);
3636 VARXOR(I1,0,UI1,0,I4,0);
3637 VARXOR(I1,-1,I2,-1,I4,0);
3638 VARXOR(I1,-1,I2,0,I4,-1);
3639 VARXOR(I1,0,I2,0,I4,0);
3640 VARXOR(I1,-1,UI2,65535,I4,-65536);
3641 VARXOR(I1,-1,UI2,0,I4,-1);
3642 VARXOR(I1,0,UI2,0,I4,0);
3643 VARXOR(I1,-1,I4,-1,I4,0);
3644 VARXOR(I1,-1,I4,0,I4,-1);
3645 VARXOR(I1,0,I4,0,I4,0);
3646 VARXOR(I1,-1,UI4,0xffffffff,I4,0);
3647 VARXOR(I1,-1,UI4,0,I4,-1);
3648 VARXOR(I1,0,UI4,0,I4,0);
3649 VARXOR(I1,-1,R4,-1,I4,0);
3650 VARXOR(I1,-1,R4,0,I4,-1);
3651 VARXOR(I1,0,R4,0,I4,0);
3652 VARXOR(I1,-1,R8,-1,I4,0);
3653 VARXOR(I1,-1,R8,0,I4,-1);
3654 VARXOR(I1,0,R8,0,I4,0);
3655 VARXOR(I1,-1,DATE,-1,I4,0);
3656 VARXOR(I1,-1,DATE,0,I4,-1);
3657 VARXOR(I1,0,DATE,0,I4,0);
3658 if (HAVE_OLEAUT32_I8)
3659 {
3660 VARXOR(I1,-1,I8,-1,I8,0);
3661 VARXOR(I1,-1,I8,0,I8,-1);
3662 VARXOR(I1,0,I8,0,I8,0);
3663 VARXOR(I1,-1,UI8,0,I4,-1);
3664 VARXOR(I1,0,UI8,0,I4,0);
3665 }
3666 VARXOR(I1,-1,INT,-1,I4,0);
3667 VARXOR(I1,-1,INT,0,I4,-1);
3668 VARXOR(I1,0,INT,0,I4,0);
3669 VARXOR(I1,-1,UINT,0xffffffff,I4,0);
3670 VARXOR(I1,-1,UINT,0,I4,-1);
3671 VARXOR(I1,0,UINT,0,I4,0);
3672 rbstr = SysAllocString(szFalse);
3673 VARXOR(I1,0,BSTR,rbstr,I4,0);
3674 VARXOR(I1,-1,BSTR,rbstr,I4,-1);
3675 SysFreeString(rbstr);
3676 rbstr = SysAllocString(szTrue);
3677 VARXOR(I1,0,BSTR,rbstr,I4,-1);
3678 VARXOR(I1,-1,BSTR,rbstr,I4,0);
3679 SysFreeString(rbstr);
3680 VARXORCY(I1,-1,10000,I4,-2);
3681 VARXORCY(I1,-1,0,I4,-1);
3682 VARXORCY(I1,0,0,I4,0);
3683
3684 VARXOR(UI1,255,UI1,255,UI1,0);
3685 VARXOR(UI1,255,UI1,0,UI1,255);
3686 VARXOR(UI1,0,UI1,0,UI1,0);
3687 VARXOR(UI1,255,I2,-1,I2,-256);
3688 VARXOR(UI1,255,I2,0,I2,255);
3689 VARXOR(UI1,0,I2,0,I2,0);
3690 VARXOR(UI1,255,UI2,65535,I4,65280);
3691 VARXOR(UI1,255,UI2,0,I4,255);
3692 VARXOR(UI1,0,UI2,0,I4,0);
3693 VARXOR(UI1,255,I4,-1,I4,-256);
3694 VARXOR(UI1,255,I4,0,I4,255);
3695 VARXOR(UI1,0,I4,0,I4,0);
3696 VARXOR(UI1,255,UI4,0xffffffff,I4,-256);
3697 VARXOR(UI1,255,UI4,0,I4,255);
3698 VARXOR(UI1,0,UI4,0,I4,0);
3699 VARXOR(UI1,255,R4,-1,I4,-256);
3700 VARXOR(UI1,255,R4,0,I4,255);
3701 VARXOR(UI1,0,R4,0,I4,0);
3702 VARXOR(UI1,255,R8,-1,I4,-256);
3703 VARXOR(UI1,255,R8,0,I4,255);
3704 VARXOR(UI1,0,R8,0,I4,0);
3705 VARXOR(UI1,255,DATE,-1,I4,-256);
3706 VARXOR(UI1,255,DATE,0,I4,255);
3707 VARXOR(UI1,0,DATE,0,I4,0);
3708 if (HAVE_OLEAUT32_I8)
3709 {
3710 VARXOR(UI1,255,I8,-1,I8,-256);
3711 VARXOR(UI1,255,I8,0,I8,255);
3712 VARXOR(UI1,0,I8,0,I8,0);
3713 VARXOR(UI1,255,UI8,0,I4,255);
3714 VARXOR(UI1,0,UI8,0,I4,0);
3715 }
3716 VARXOR(UI1,255,INT,-1,I4,-256);
3717 VARXOR(UI1,255,INT,0,I4,255);
3718 VARXOR(UI1,0,INT,0,I4,0);
3719 VARXOR(UI1,255,UINT,0xffffffff,I4,-256);
3720 VARXOR(UI1,255,UINT,0,I4,255);
3721 VARXOR(UI1,0,UINT,0,I4,0);
3722 rbstr = SysAllocString(szFalse);
3723 VARXOR(UI1,0,BSTR,rbstr,I2,0);
3724 VARXOR(UI1,255,BSTR,rbstr,I2,255);
3725 SysFreeString(rbstr);
3726 rbstr = SysAllocString(szTrue);
3727 VARXOR(UI1,0,BSTR,rbstr,I2,-1);
3728 VARXOR(UI1,255,BSTR,rbstr,I2,-256);
3729 SysFreeString(rbstr);
3730 VARXORCY(UI1,255,10000,I4,254);
3731 VARXORCY(UI1,255,0,I4,255);
3732 VARXORCY(UI1,0,0,I4,0);
3733
3734 VARXOR(I2,-1,I2,-1,I2,0);
3735 VARXOR(I2,-1,I2,0,I2,-1);
3736 VARXOR(I2,0,I2,0,I2,0);
3737 VARXOR(I2,-1,UI2,65535,I4,-65536);
3738 VARXOR(I2,-1,UI2,0,I4,-1);
3739 VARXOR(I2,0,UI2,0,I4,0);
3740 VARXOR(I2,-1,I4,-1,I4,0);
3741 VARXOR(I2,-1,I4,0,I4,-1);
3742 VARXOR(I2,0,I4,0,I4,0);
3743 VARXOR(I2,-1,UI4,0xffffffff,I4,0);
3744 VARXOR(I2,-1,UI4,0,I4,-1);
3745 VARXOR(I2,0,UI4,0,I4,0);
3746 VARXOR(I2,-1,R4,-1,I4,0);
3747 VARXOR(I2,-1,R4,0,I4,-1);
3748 VARXOR(I2,0,R4,0,I4,0);
3749 VARXOR(I2,-1,R8,-1,I4,0);
3750 VARXOR(I2,-1,R8,0,I4,-1);
3751 VARXOR(I2,0,R8,0,I4,0);
3752 VARXOR(I2,-1,DATE,-1,I4,0);
3753 VARXOR(I2,-1,DATE,0,I4,-1);
3754 VARXOR(I2,0,DATE,0,I4,0);
3755 if (HAVE_OLEAUT32_I8)
3756 {
3757 VARXOR(I2,-1,I8,-1,I8,0);
3758 VARXOR(I2,-1,I8,0,I8,-1);
3759 VARXOR(I2,0,I8,0,I8,0);
3760 VARXOR(I2,-1,UI8,0,I4,-1);
3761 VARXOR(I2,0,UI8,0,I4,0);
3762 }
3763 VARXOR(I2,-1,INT,-1,I4,0);
3764 VARXOR(I2,-1,INT,0,I4,-1);
3765 VARXOR(I2,0,INT,0,I4,0);
3766 VARXOR(I2,-1,UINT,0xffffffff,I4,0);
3767 VARXOR(I2,-1,UINT,0,I4,-1);
3768 VARXOR(I2,0,UINT,0,I4,0);
3769 rbstr = SysAllocString(szFalse);
3770 VARXOR(I2,0,BSTR,rbstr,I2,0);
3771 VARXOR(I2,-1,BSTR,rbstr,I2,-1);
3772 SysFreeString(rbstr);
3773 rbstr = SysAllocString(szTrue);
3774 VARXOR(I2,0,BSTR,rbstr,I2,-1);
3775 VARXOR(I2,-1,BSTR,rbstr,I2,0);
3776 SysFreeString(rbstr);
3777 VARXORCY(I2,-1,10000,I4,-2);
3778 VARXORCY(I2,-1,0,I4,-1);
3779 VARXORCY(I2,0,0,I4,0);
3780
3781 VARXOR(UI2,65535,UI2,65535,I4,0);
3782 VARXOR(UI2,65535,UI2,0,I4,65535);
3783 VARXOR(UI2,0,UI2,0,I4,0);
3784 VARXOR(UI2,65535,I4,-1,I4,-65536);
3785 VARXOR(UI2,65535,I4,0,I4,65535);
3786 VARXOR(UI2,0,I4,0,I4,0);
3787 VARXOR(UI2,65535,UI4,0xffffffff,I4,-65536);
3788 VARXOR(UI2,65535,UI4,0,I4,65535);
3789 VARXOR(UI2,0,UI4,0,I4,0);
3790 VARXOR(UI2,65535,R4,-1,I4,-65536);
3791 VARXOR(UI2,65535,R4,0,I4,65535);
3792 VARXOR(UI2,0,R4,0,I4,0);
3793 VARXOR(UI2,65535,R8,-1,I4,-65536);
3794 VARXOR(UI2,65535,R8,0,I4,65535);
3795 VARXOR(UI2,0,R8,0,I4,0);
3796 VARXOR(UI2,65535,DATE,-1,I4,-65536);
3797 VARXOR(UI2,65535,DATE,0,I4,65535);
3798 VARXOR(UI2,0,DATE,0,I4,0);
3799 if (HAVE_OLEAUT32_I8)
3800 {
3801 VARXOR(UI2,65535,I8,-1,I8,-65536);
3802 VARXOR(UI2,65535,I8,0,I8,65535);
3803 VARXOR(UI2,0,I8,0,I8,0);
3804 VARXOR(UI2,65535,UI8,0,I4,65535);
3805 VARXOR(UI2,0,UI8,0,I4,0);
3806 }
3807 VARXOR(UI2,65535,INT,-1,I4,-65536);
3808 VARXOR(UI2,65535,INT,0,I4,65535);
3809 VARXOR(UI2,0,INT,0,I4,0);
3810 VARXOR(UI2,65535,UINT,0xffffffff,I4,-65536);
3811 VARXOR(UI2,65535,UINT,0,I4,65535);
3812 VARXOR(UI2,0,UINT,0,I4,0);
3813 rbstr = SysAllocString(szFalse);
3814 VARXOR(UI2,0,BSTR,rbstr,I4,0);
3815 VARXOR(UI2,65535,BSTR,rbstr,I4,65535);
3816 SysFreeString(rbstr);
3817 rbstr = SysAllocString(szTrue);
3818 VARXOR(UI2,0,BSTR,rbstr,I4,-1);
3819 VARXOR(UI2,65535,BSTR,rbstr,I4,-65536);
3820 SysFreeString(rbstr);
3821 VARXORCY(UI2,65535,10000,I4,65534);
3822 VARXORCY(UI2,65535,0,I4,65535);
3823 VARXORCY(UI2,0,0,I4,0);
3824
3825 VARXOR(I4,-1,I4,-1,I4,0);
3826 VARXOR(I4,-1,I4,0,I4,-1);
3827 VARXOR(I4,0,I4,0,I4,0);
3828 VARXOR(I4,-1,UI4,0xffffffff,I4,0);
3829 VARXOR(I4,-1,UI4,0,I4,-1);
3830 VARXOR(I4,0,UI4,0,I4,0);
3831 VARXOR(I4,-1,R4,-1,I4,0);
3832 VARXOR(I4,-1,R4,0,I4,-1);
3833 VARXOR(I4,0,R4,0,I4,0);
3834 VARXOR(I4,-1,R8,-1,I4,0);
3835 VARXOR(I4,-1,R8,0,I4,-1);
3836 VARXOR(I4,0,R8,0,I4,0);
3837 VARXOR(I4,-1,DATE,-1,I4,0);
3838 VARXOR(I4,-1,DATE,0,I4,-1);
3839 VARXOR(I4,0,DATE,0,I4,0);
3840 if (HAVE_OLEAUT32_I8)
3841 {
3842 VARXOR(I4,-1,I8,-1,I8,0);
3843 VARXOR(I4,-1,I8,0,I8,-1);
3844 VARXOR(I4,0,I8,0,I8,0);
3845 VARXOR(I4,-1,UI8,0,I4,-1);
3846 VARXOR(I4,0,UI8,0,I4,0);
3847 }
3848 VARXOR(I4,-1,INT,-1,I4,0);
3849 VARXOR(I4,-1,INT,0,I4,-1);
3850 VARXOR(I4,0,INT,0,I4,0);
3851 VARXOR(I4,-1,UINT,0xffffffff,I4,0);
3852 VARXOR(I4,-1,UINT,0,I4,-1);
3853 VARXOR(I4,0,UINT,0,I4,0);
3854 rbstr = SysAllocString(szFalse);
3855 VARXOR(I4,0,BSTR,rbstr,I4,0);
3856 VARXOR(I4,-1,BSTR,rbstr,I4,-1);
3857 SysFreeString(rbstr);
3858 rbstr = SysAllocString(szTrue);
3859 VARXOR(I4,0,BSTR,rbstr,I4,-1);
3860 VARXOR(I4,-1,BSTR,rbstr,I4,0);
3861 SysFreeString(rbstr);
3862 VARXORCY(I4,-1,10000,I4,-2);
3863 VARXORCY(I4,-1,0,I4,-1);
3864 VARXORCY(I4,0,0,I4,0);
3865
3866 VARXOR(UI4,0xffffffff,UI4,0xffffffff,I4,0);
3867 VARXOR(UI4,0xffffffff,UI4,0,I4,-1);
3868 VARXOR(UI4,0,UI4,0,I4,0);
3869 VARXOR(UI4,0xffffffff,R4,-1,I4,0);
3870 VARXOR(UI4,0xffffffff,R4,0,I4,-1);
3871 VARXOR(UI4,0,R4,0,I4,0);
3872 VARXOR(UI4,0xffffffff,R8,-1,I4,0);
3873 VARXOR(UI4,0xffffffff,R8,0,I4,-1);
3874 VARXOR(UI4,0,R8,0,I4,0);
3875 VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
3876 VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
3877 VARXOR(UI4,0,DATE,0,I4,0);
3878 if (HAVE_OLEAUT32_I8)
3879 {
3880 VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
3881 VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
3882 VARXOR(UI4,0,I8,0,I8,0);
3883 VARXOR(UI4,0xffffffff,UI8,0,I4,-1);
3884 VARXOR(UI4,0,UI8,0,I4,0);
3885 }
3886 VARXOR(UI4,0xffffffff,INT,-1,I4,0);
3887 VARXOR(UI4,0xffffffff,INT,0,I4,-1);
3888 VARXOR(UI4,0,INT,0,I4,0);
3889 VARXOR(UI4,0xffffffff,UINT,0xffffffff,I4,0);
3890 VARXOR(UI4,0xffffffff,UINT,0,I4,-1);
3891 VARXOR(UI4,0,UINT,0,I4,0);
3892 rbstr = SysAllocString(szFalse);
3893 VARXOR(UI4,0,BSTR,rbstr,I4,0);
3894 VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
3895 SysFreeString(rbstr);
3896 rbstr = SysAllocString(szTrue);
3897 VARXOR(UI4,0,BSTR,rbstr,I4,-1);
3898 VARXOR(UI4,0xffffffff,BSTR,rbstr,I4,0);
3899 SysFreeString(rbstr);
3900 VARXORCY(UI4,0xffffffff,10000,I4,-2);
3901 VARXORCY(UI4,0xffffffff,0,I4,-1);
3902 VARXORCY(UI4,0,0,I4,0);
3903
3904 VARXOR(R4,-1,R4,-1,I4,0);
3905 VARXOR(R4,-1,R4,0,I4,-1);
3906 VARXOR(R4,0,R4,0,I4,0);
3907 VARXOR(R4,-1,R8,-1,I4,0);
3908 VARXOR(R4,-1,R8,0,I4,-1);
3909 VARXOR(R4,0,R8,0,I4,0);
3910 VARXOR(R4,-1,DATE,-1,I4,0);
3911 VARXOR(R4,-1,DATE,0,I4,-1);
3912 VARXOR(R4,0,DATE,0,I4,0);
3913 if (HAVE_OLEAUT32_I8)
3914 {
3915 VARXOR(R4,-1,I8,-1,I8,0);
3916 VARXOR(R4,-1,I8,0,I8,-1);
3917 VARXOR(R4,0,I8,0,I8,0);
3918 VARXOR(R4,-1,UI8,0,I4,-1);
3919 VARXOR(R4,0,UI8,0,I4,0);
3920 }
3921 VARXOR(R4,-1,INT,-1,I4,0);
3922 VARXOR(R4,-1,INT,0,I4,-1);
3923 VARXOR(R4,0,INT,0,I4,0);
3924 VARXOR(R4,-1,UINT,0xffffffff,I4,0);
3925 VARXOR(R4,-1,UINT,0,I4,-1);
3926 VARXOR(R4,0,UINT,0,I4,0);
3927 rbstr = SysAllocString(szFalse);
3928 VARXOR(R4,0,BSTR,rbstr,I4,0);
3929 VARXOR(R4,-1,BSTR,rbstr,I4,-1);
3930 SysFreeString(rbstr);
3931 rbstr = SysAllocString(szTrue);
3932 VARXOR(R4,0,BSTR,rbstr,I4,-1);
3933 VARXOR(R4,-1,BSTR,rbstr,I4,0);
3934 SysFreeString(rbstr);
3935 VARXORCY(R4,-1,10000,I4,-2);
3936 VARXORCY(R4,-1,0,I4,-1);
3937 VARXORCY(R4,0,0,I4,0);
3938
3939 VARXOR(R8,-1,R8,-1,I4,0);
3940 VARXOR(R8,-1,R8,0,I4,-1);
3941 VARXOR(R8,0,R8,0,I4,0);
3942 VARXOR(R8,-1,DATE,-1,I4,0);
3943 VARXOR(R8,-1,DATE,0,I4,-1);
3944 VARXOR(R8,0,DATE,0,I4,0);
3945 if (HAVE_OLEAUT32_I8)
3946 {
3947 VARXOR(R8,-1,I8,-1,I8,0);
3948 VARXOR(R8,-1,I8,0,I8,-1);
3949 VARXOR(R8,0,I8,0,I8,0);
3950 VARXOR(R8,-1,UI8,0,I4,-1);
3951 VARXOR(R8,0,UI8,0,I4,0);
3952 }
3953 VARXOR(R8,-1,INT,-1,I4,0);
3954 VARXOR(R8,-1,INT,0,I4,-1);
3955 VARXOR(R8,0,INT,0,I4,0);
3956 VARXOR(R8,-1,UINT,0xffffffff,I4,0);
3957 VARXOR(R8,-1,UINT,0,I4,-1);
3958 VARXOR(R8,0,UINT,0,I4,0);
3959 rbstr = SysAllocString(szFalse);
3960 VARXOR(R8,0,BSTR,rbstr,I4,0);
3961 VARXOR(R8,-1,BSTR,rbstr,I4,-1);
3962 SysFreeString(rbstr);
3963 rbstr = SysAllocString(szTrue);
3964 VARXOR(R8,0,BSTR,rbstr,I4,-1);
3965 VARXOR(R8,-1,BSTR,rbstr,I4,0);
3966 SysFreeString(rbstr);
3967 VARXORCY(R8,-1,10000,I4,-2);
3968 VARXORCY(R8,-1,0,I4,-1);
3969 VARXORCY(R8,0,0,I4,0);
3970
3971 VARXOR(DATE,-1,DATE,-1,I4,0);
3972 VARXOR(DATE,-1,DATE,0,I4,-1);
3973 VARXOR(DATE,0,DATE,0,I4,0);
3974 if (HAVE_OLEAUT32_I8)
3975 {
3976 VARXOR(DATE,-1,I8,-1,I8,0);
3977 VARXOR(DATE,-1,I8,0,I8,-1);
3978 VARXOR(DATE,0,I8,0,I8,0);
3979 VARXOR(DATE,-1,UI8,0,I4,-1);
3980 VARXOR(DATE,0,UI8,0,I4,0);
3981 }
3982 VARXOR(DATE,-1,INT,-1,I4,0);
3983 VARXOR(DATE,-1,INT,0,I4,-1);
3984 VARXOR(DATE,0,INT,0,I4,0);
3985 VARXOR(DATE,-1,UINT,0xffffffff,I4,0);
3986 VARXOR(DATE,-1,UINT,0,I4,-1);
3987 VARXOR(DATE,0,UINT,0,I4,0);
3988 rbstr = SysAllocString(szFalse);
3989 VARXOR(DATE,0,BSTR,rbstr,I4,0);
3990 VARXOR(DATE,-1,BSTR,rbstr,I4,-1);
3991 SysFreeString(rbstr);
3992 rbstr = SysAllocString(szTrue);
3993 VARXOR(DATE,0,BSTR,rbstr,I4,-1);
3994 VARXOR(DATE,-1,BSTR,rbstr,I4,0);
3995 SysFreeString(rbstr);
3996 VARXORCY(DATE,-1,10000,I4,-2);
3997 VARXORCY(DATE,-1,0,I4,-1);
3998 VARXORCY(DATE,0,0,I4,0);
3999
4000 if (HAVE_OLEAUT32_I8)
4001 {
4002 VARXOR(I8,-1,I8,-1,I8,0);
4003 VARXOR(I8,-1,I8,0,I8,-1);
4004 VARXOR(I8,0,I8,0,I8,0);
4005 VARXOR(I8,-1,UI8,0,I8,-1);
4006 VARXOR(I8,0,UI8,0,I8,0);
4007 VARXOR(I8,-1,UINT,0,I8,-1);
4008 VARXOR(I8,0,UINT,0,I8,0);
4009 rbstr = SysAllocString(szFalse);
4010 VARXOR(I8,0,BSTR,rbstr,I8,0);
4011 VARXOR(I8,-1,BSTR,rbstr,I8,-1);
4012 SysFreeString(rbstr);
4013 rbstr = SysAllocString(szTrue);
4014 VARXOR(I8,0,BSTR,rbstr,I8,-1);
4015 VARXOR(I8,-1,BSTR,rbstr,I8,0);
4016 SysFreeString(rbstr);
4017 VARXORCY(I8,-1,10000,I8,-2);
4018 VARXORCY(I8,-1,0,I8,-1);
4019 VARXORCY(I8,0,0,I8,0);
4020
4021 VARXOR(UI8,0xffff,UI8,0xffff,I4,0);
4022 VARXOR(UI8,0xffff,UI8,0,I4,0xffff);
4023 VARXOR(UI8,0,UI8,0,I4,0);
4024 VARXOR(UI8,0xffff,INT,-1,I4,-65536);
4025 VARXOR(UI8,0xffff,INT,0,I4,0xffff);
4026 VARXOR(UI8,0,INT,0,I4,0);
4027 VARXOR(UI8,0xffff,UINT,0xffff,I4,0);
4028 VARXOR(UI8,0xffff,UINT,0,I4,0xffff);
4029 VARXOR(UI8,0,UINT,0,I4,0);
4030 rbstr = SysAllocString(szFalse);
4031 VARXOR(UI8,0,BSTR,rbstr,I4,0);
4032 VARXOR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4033 SysFreeString(rbstr);
4034 rbstr = SysAllocString(szTrue);
4035 VARXOR(UI8,0,BSTR,rbstr,I4,-1);
4036 VARXOR(UI8,0xffff,BSTR,rbstr,I4,-65536);
4037 SysFreeString(rbstr);
4038 VARXORCY(UI8,0xffff,10000,I4,65534);
4039 VARXORCY(UI8,0xffff,0,I4,0xffff);
4040 VARXORCY(UI8,0,0,I4,0);
4041 }
4042
4043 VARXOR(INT,-1,INT,-1,I4,0);
4044 VARXOR(INT,-1,INT,0,I4,-1);
4045 VARXOR(INT,0,INT,0,I4,0);
4046 VARXOR(INT,-1,UINT,0xffff,I4,-65536);
4047 VARXOR(INT,-1,UINT,0,I4,-1);
4048 VARXOR(INT,0,UINT,0,I4,0);
4049 rbstr = SysAllocString(szFalse);
4050 VARXOR(INT,0,BSTR,rbstr,I4,0);
4051 VARXOR(INT,-1,BSTR,rbstr,I4,-1);
4052 SysFreeString(rbstr);
4053 rbstr = SysAllocString(szTrue);
4054 VARXOR(INT,0,BSTR,rbstr,I4,-1);
4055 VARXOR(INT,-1,BSTR,rbstr,I4,0);
4056 SysFreeString(rbstr);
4057 VARXORCY(INT,-1,10000,I4,-2);
4058 VARXORCY(INT,-1,0,I4,-1);
4059 VARXORCY(INT,0,0,I4,0);
4060
4061 VARXOR(UINT,0xffff,UINT,0xffff,I4,0);
4062 VARXOR(UINT,0xffff,UINT,0,I4,0xffff);
4063 VARXOR(UINT,0,UINT,0,I4,0);
4064 rbstr = SysAllocString(szFalse);
4065 VARXOR(UINT,0,BSTR,rbstr,I4,0);
4066 VARXOR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4067 SysFreeString(rbstr);
4068 rbstr = SysAllocString(szTrue);
4069 VARXOR(UINT,0,BSTR,rbstr,I4,-1);
4070 VARXOR(UINT,0xffff,BSTR,rbstr,I4,-65536);
4071 SysFreeString(rbstr);
4072 VARXORCY(UINT,0xffff,10000,I4,65534);
4073 VARXORCY(UINT,0xffff,0,I4,0xffff);
4074 VARXORCY(UINT,0,0,I4,0);
4075
4076 lbstr = SysAllocString(szFalse);
4077 rbstr = SysAllocString(szFalse);
4078 VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4079 SysFreeString(rbstr);
4080 rbstr = SysAllocString(szTrue);
4081 VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4082 SysFreeString(lbstr);
4083 lbstr = SysAllocString(szTrue);
4084 VARXOR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_FALSE);
4085 VARXORCY(BSTR,lbstr,10000,I4,-2);
4086 SysFreeString(lbstr);
4087 lbstr = SysAllocString(szFalse);
4088 VARXORCY(BSTR,lbstr,10000,I4,1);
4089 SysFreeString(lbstr);
4090 SysFreeString(rbstr);
4091 }
4092
4093 static HRESULT (WINAPI *pVarOr)(LPVARIANT,LPVARIANT,LPVARIANT);
4094
4095 #define VAROR(vt1,val1,vt2,val2,rvt,rval) \
4096 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4097 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4098 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4099 test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4100
4101 #define VARORCY(vt1,val1,val2,rvt,rval) \
4102 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4103 V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
4104 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4105 test_var_call2( __LINE__, pVarOr, &left, &right, &exp )
4106
4107 static void test_VarOr(void)
4108 {
4109 static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
4110 static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
4111 VARIANT left, right, exp, result;
4112 BSTR lbstr, rbstr;
4113 VARTYPE i;
4114 HRESULT hres;
4115
4116 CHECKPTR(VarOr);
4117
4118 /* Test all possible flag/vt combinations & the resulting vt type */
4119 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4120 {
4121 VARTYPE leftvt, rightvt, resvt;
4122
4123 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4124 {
4125
4126 SKIPTESTS(leftvt);
4127
4128 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4129 {
4130 BOOL bFail = FALSE;
4131
4132 SKIPTESTS(rightvt);
4133
4134 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4135 leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4136 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4137 continue;
4138
4139 memset(&left, 0, sizeof(left));
4140 memset(&right, 0, sizeof(right));
4141 V_VT(&left) = leftvt | ExtraFlags[i];
4142 V_VT(&right) = rightvt | ExtraFlags[i];
4143 V_VT(&result) = VT_EMPTY;
4144 resvt = VT_I4;
4145
4146 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4147 !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4148 !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4149 leftvt == VT_CLSID || rightvt == VT_CLSID ||
4150 leftvt == VT_RECORD || rightvt == VT_RECORD ||
4151 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4152 leftvt == VT_ERROR || rightvt == VT_ERROR)
4153 {
4154 bFail = TRUE;
4155 }
4156 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4157 {
4158 if (leftvt == rightvt ||
4159 leftvt == VT_I2 || rightvt == VT_I2 ||
4160 leftvt == VT_UI1 || rightvt == VT_UI1 ||
4161 leftvt == VT_BOOL || rightvt == VT_BOOL)
4162 resvt = VT_I2;
4163 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4164 resvt = VT_NULL;
4165 else if (leftvt == VT_I8 || rightvt == VT_I8)
4166 resvt = VT_I8;
4167 }
4168 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4169 {
4170 resvt = VT_NULL;
4171 }
4172 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4173 {
4174 if (leftvt == rightvt)
4175 resvt = VT_UI1;
4176 else if (leftvt == rightvt ||
4177 leftvt == VT_I2 || rightvt == VT_I2 ||
4178 leftvt == VT_BOOL || rightvt == VT_BOOL)
4179 {
4180 resvt = VT_I2;
4181 }
4182 else if (leftvt == VT_I8 || rightvt == VT_I8)
4183 resvt = VT_I8;
4184 }
4185 else if (leftvt == VT_I2 || rightvt == VT_I2)
4186 {
4187 if (leftvt == rightvt ||
4188 leftvt == VT_BOOL || rightvt == VT_BOOL)
4189 resvt = VT_I2;
4190 else if (leftvt == VT_I8 || rightvt == VT_I8)
4191 resvt = VT_I8;
4192 }
4193 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4194 {
4195 resvt = VT_BOOL;
4196 }
4197 else if (leftvt == VT_I8 || rightvt == VT_I8)
4198 {
4199 if (leftvt == VT_INT || rightvt == VT_INT)
4200 bFail = TRUE;
4201 else
4202 resvt = VT_I8;
4203 }
4204 hres = pVarOr(&left, &right, &result);
4205 if (bFail)
4206 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4207 "VarOr: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4208 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4209 V_VT(&result));
4210 else
4211 ok(hres == S_OK && V_VT(&result) == resvt,
4212 "VarOr: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4213 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4214 V_VT(&result));
4215 }
4216 }
4217 }
4218
4219 /* Test returned values. Since we know the returned type is correct
4220 * and that we handle all combinations of invalid types, just check
4221 * that good type combinations produce the desired value.
4222 * FIXME: Test VT_DECIMAL/VT_DISPATCH
4223 */
4224 VAROR(EMPTY,0,EMPTY,0,I2,0);
4225 VAROR(EMPTY,1,EMPTY,0,I2,0);
4226 VAROR(EMPTY,0,NULL,0,NULL,0);
4227 VAROR(EMPTY,0,I1,0,I4,0);
4228 VAROR(EMPTY,0,I1,1,I4,1);
4229 VAROR(EMPTY,0,UI1,0,I2,0);
4230 VAROR(EMPTY,0,UI1,1,I2,1);
4231 VAROR(EMPTY,0,I2,0,I2,0);
4232 VAROR(EMPTY,0,I2,1,I2,1);
4233 VAROR(EMPTY,0,UI2,0,I4,0);
4234 VAROR(EMPTY,0,UI2,1,I4,1);
4235 VAROR(EMPTY,0,I4,0,I4,0);
4236 VAROR(EMPTY,0,I4,1,I4,1);
4237 VAROR(EMPTY,0,UI4,0,I4,0);
4238 VAROR(EMPTY,0,UI4,1,I4,1);
4239 if (HAVE_OLEAUT32_I8)
4240 {
4241 VAROR(EMPTY,0,I8,0,I8,0);
4242 VAROR(EMPTY,0,I8,1,I8,1);
4243 VAROR(EMPTY,0,UI8,0,I4,0);
4244 VAROR(EMPTY,0,UI8,1,I4,1);
4245 }
4246 VAROR(EMPTY,0,INT,0,I4,0);
4247 VAROR(EMPTY,0,INT,1,I4,1);
4248 VAROR(EMPTY,0,UINT,0,I4,0);
4249 VAROR(EMPTY,0,UINT,1,I4,1);
4250 VAROR(EMPTY,0,BOOL,0,I2,0);
4251 VAROR(EMPTY,0,BOOL,1,I2,1);
4252 VAROR(EMPTY,0,R4,0,I4,0);
4253 VAROR(EMPTY,0,R4,1,I4,1);
4254 VAROR(EMPTY,0,R8,0,I4,0);
4255 VAROR(EMPTY,0,R8,1,I4,1);
4256 rbstr = SysAllocString(szFalse);
4257 VAROR(EMPTY,0,BSTR,rbstr,I2,0);
4258 SysFreeString(rbstr);
4259 rbstr = SysAllocString(szTrue);
4260 VAROR(EMPTY,0,BSTR,rbstr,I2,-1);
4261 SysFreeString(rbstr);
4262 VARORCY(EMPTY,0,10000,I4,1);
4263
4264 /* NULL OR 0 = NULL. NULL OR n = n */
4265 VAROR(NULL,0,NULL,0,NULL,0);
4266 VAROR(NULL,1,NULL,0,NULL,0);
4267 VAROR(NULL,0,I1,0,NULL,0);
4268 VAROR(NULL,0,I1,1,I4,1);
4269 VAROR(NULL,0,UI1,0,NULL,0);
4270 VAROR(NULL,0,UI1,1,UI1,1);
4271 VAROR(NULL,0,I2,0,NULL,0);
4272 VAROR(NULL,0,I2,1,I2,1);
4273 VAROR(NULL,0,UI2,0,NULL,0);
4274 VAROR(NULL,0,UI2,1,I4,1);
4275 VAROR(NULL,0,I4,0,NULL,0);
4276 VAROR(NULL,0,I4,1,I4,1);
4277 VAROR(NULL,0,UI4,0,NULL,0);
4278 VAROR(NULL,0,UI4,1,I4,1);
4279 if (HAVE_OLEAUT32_I8)
4280 {
4281 VAROR(NULL,0,I8,0,NULL,0);
4282 VAROR(NULL,0,I8,1,I8,1);
4283 VAROR(NULL,0,UI8,0,NULL,0);
4284 VAROR(NULL,0,UI8,1,I4,1);
4285 }
4286 VAROR(NULL,0,INT,0,NULL,0);
4287 VAROR(NULL,0,INT,1,I4,1);
4288 VAROR(NULL,0,UINT,0,NULL,0);
4289 VAROR(NULL,0,UINT,1,I4,1);
4290 VAROR(NULL,0,BOOL,0,NULL,0);
4291 VAROR(NULL,0,BOOL,1,BOOL,1);
4292 VAROR(NULL,0,R4,0,NULL,0);
4293 VAROR(NULL,0,R4,1,I4,1);
4294 VAROR(NULL,0,R8,0,NULL,0);
4295 VAROR(NULL,0,R8,1,I4,1);
4296 rbstr = SysAllocString(szFalse);
4297 VAROR(NULL,0,BSTR,rbstr,NULL,0);
4298 SysFreeString(rbstr);
4299 rbstr = SysAllocString(szTrue);
4300 VAROR(NULL,0,BSTR,rbstr,BOOL,VARIANT_TRUE);
4301 SysFreeString(rbstr);
4302 VARORCY(NULL,0,10000,I4,1);
4303 VARORCY(NULL,0,0,NULL,0);
4304
4305 VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4306 VAROR(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE);
4307 VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4308 VAROR(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
4309 /* Assume x,y & y,x are the same from now on to reduce the number of tests */
4310 VAROR(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
4311 VAROR(BOOL,VARIANT_TRUE,I1,0,I4,-1);
4312 VAROR(BOOL,VARIANT_FALSE,I1,0,I4,0);
4313 VAROR(BOOL,VARIANT_TRUE,UI1,255,I2,-1);
4314 VAROR(BOOL,VARIANT_TRUE,UI1,0,I2,-1);
4315 VAROR(BOOL,VARIANT_FALSE,UI1,0,I2,0);
4316 VAROR(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
4317 VAROR(BOOL,VARIANT_TRUE,I2,0,I2,-1);
4318 VAROR(BOOL,VARIANT_FALSE,I2,0,I2,0);
4319 VAROR(BOOL,VARIANT_TRUE,UI2,65535,I4,-1);
4320 VAROR(BOOL,VARIANT_TRUE,UI2,0,I4,-1);
4321 VAROR(BOOL,VARIANT_FALSE,UI2,0,I4,0);
4322 VAROR(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
4323 VAROR(BOOL,VARIANT_TRUE,I4,0,I4,-1);
4324 VAROR(BOOL,VARIANT_FALSE,I4,0,I4,0);
4325 VAROR(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
4326 VAROR(BOOL,VARIANT_TRUE,UI4,0,I4,-1);
4327 VAROR(BOOL,VARIANT_FALSE,UI4,0,I4,0);
4328 VAROR(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
4329 VAROR(BOOL,VARIANT_TRUE,R4,0,I4,-1);
4330 VAROR(BOOL,VARIANT_FALSE,R4,0,I4,0);
4331 VAROR(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
4332 VAROR(BOOL,VARIANT_TRUE,R8,0,I4,-1);
4333 VAROR(BOOL,VARIANT_FALSE,R8,0,I4,0);
4334 VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
4335 VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
4336 VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
4337 if (HAVE_OLEAUT32_I8)
4338 {
4339 VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
4340 VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
4341 VAROR(BOOL,VARIANT_FALSE,I8,0,I8,0);
4342 /* This returns DISP_E_OVERFLOW which indicates that a conversion
4343 * to I4 is performed.
4344 */
4345 /* VAROR(BOOL,VARIANT_TRUE,UI8,-1,I4,-1); */
4346 VAROR(BOOL,VARIANT_TRUE,UI8,0,I4,-1);
4347 VAROR(BOOL,VARIANT_FALSE,UI8,0,I4,0);
4348 }
4349 VAROR(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
4350 VAROR(BOOL,VARIANT_TRUE,INT,0,I4,-1);
4351 VAROR(BOOL,VARIANT_FALSE,INT,0,I4,0);
4352 VAROR(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
4353 VAROR(BOOL,VARIANT_TRUE,UINT,0,I4,-1);
4354 VAROR(BOOL,VARIANT_FALSE,UINT,0,I4,0);
4355 rbstr = SysAllocString(szFalse);
4356 VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_FALSE);
4357 VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4358 SysFreeString(rbstr);
4359 rbstr = SysAllocString(szTrue);
4360 VAROR(BOOL,VARIANT_FALSE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4361 VAROR(BOOL,VARIANT_TRUE,BSTR,rbstr,BOOL,VARIANT_TRUE);
4362 SysFreeString(rbstr);
4363 VARORCY(BOOL,VARIANT_TRUE,10000,I4,-1);
4364 VARORCY(BOOL,VARIANT_TRUE,0,I4,-1);
4365 VARORCY(BOOL,VARIANT_FALSE,0,I4,0);
4366
4367 VAROR(I1,-1,I1,-1,I4,-1);
4368 VAROR(I1,-1,I1,0,I4,-1);
4369 VAROR(I1,0,I1,0,I4,0);
4370 VAROR(I1,-1,UI1,255,I4,-1);
4371 VAROR(I1,-1,UI1,0,I4,-1);
4372 VAROR(I1,0,UI1,0,I4,0);
4373 VAROR(I1,-1,I2,-1,I4,-1);
4374 VAROR(I1,-1,I2,0,I4,-1);
4375 VAROR(I1,0,I2,0,I4,0);
4376 VAROR(I1,-1,UI2,65535,I4,-1);
4377 VAROR(I1,-1,UI2,0,I4,-1);
4378 VAROR(I1,0,UI2,0,I4,0);
4379 VAROR(I1,-1,I4,-1,I4,-1);
4380 VAROR(I1,-1,I4,0,I4,-1);
4381 VAROR(I1,0,I4,0,I4,0);
4382 VAROR(I1,-1,UI4,0xffffffff,I4,-1);
4383 VAROR(I1,-1,UI4,0,I4,-1);
4384 VAROR(I1,0,UI4,0,I4,0);
4385 VAROR(I1,-1,R4,-1,I4,-1);
4386 VAROR(I1,-1,R4,0,I4,-1);
4387 VAROR(I1,0,R4,0,I4,0);
4388 VAROR(I1,-1,R8,-1,I4,-1);
4389 VAROR(I1,-1,R8,0,I4,-1);
4390 VAROR(I1,0,R8,0,I4,0);
4391 VAROR(I1,-1,DATE,-1,I4,-1);
4392 VAROR(I1,-1,DATE,0,I4,-1);
4393 VAROR(I1,0,DATE,0,I4,0);
4394 if (HAVE_OLEAUT32_I8)
4395 {
4396 VAROR(I1,-1,I8,-1,I8,-1);
4397 VAROR(I1,-1,I8,0,I8,-1);
4398 VAROR(I1,0,I8,0,I8,0);
4399 VAROR(I1,-1,UI8,0,I4,-1);
4400 VAROR(I1,0,UI8,0,I4,0);
4401 }
4402 VAROR(I1,-1,INT,-1,I4,-1);
4403 VAROR(I1,-1,INT,0,I4,-1);
4404 VAROR(I1,0,INT,0,I4,0);
4405 VAROR(I1,-1,UINT,0xffffffff,I4,-1);
4406 VAROR(I1,-1,UINT,0,I4,-1);
4407 VAROR(I1,0,UINT,0,I4,0);
4408 rbstr = SysAllocString(szFalse);
4409 VAROR(I1,0,BSTR,rbstr,I4,0);
4410 VAROR(I1,-1,BSTR,rbstr,I4,-1);
4411 SysFreeString(rbstr);
4412 rbstr = SysAllocString(szTrue);
4413 VAROR(I1,0,BSTR,rbstr,I4,-1);
4414 VAROR(I1,-1,BSTR,rbstr,I4,-1);
4415 SysFreeString(rbstr);
4416 VARORCY(I1,-1,10000,I4,-1);
4417 VARORCY(I1,-1,0,I4,-1);
4418 VARORCY(I1,0,0,I4,0);
4419
4420 VAROR(UI1,255,UI1,255,UI1,255);
4421 VAROR(UI1,255,UI1,0,UI1,255);
4422 VAROR(UI1,0,UI1,0,UI1,0);
4423 VAROR(UI1,255,I2,-1,I2,-1);
4424 VAROR(UI1,255,I2,0,I2,255);
4425 VAROR(UI1,0,I2,0,I2,0);
4426 VAROR(UI1,255,UI2,65535,I4,65535);
4427 VAROR(UI1,255,UI2,0,I4,255);
4428 VAROR(UI1,0,UI2,0,I4,0);
4429 VAROR(UI1,255,I4,-1,I4,-1);
4430 VAROR(UI1,255,I4,0,I4,255);
4431 VAROR(UI1,0,I4,0,I4,0);
4432 VAROR(UI1,255,UI4,0xffffffff,I4,-1);
4433 VAROR(UI1,255,UI4,0,I4,255);
4434 VAROR(UI1,0,UI4,0,I4,0);
4435 VAROR(UI1,255,R4,-1,I4,-1);
4436 VAROR(UI1,255,R4,0,I4,255);
4437 VAROR(UI1,0,R4,0,I4,0);
4438 VAROR(UI1,255,R8,-1,I4,-1);
4439 VAROR(UI1,255,R8,0,I4,255);
4440 VAROR(UI1,0,R8,0,I4,0);
4441 VAROR(UI1,255,DATE,-1,I4,-1);
4442 VAROR(UI1,255,DATE,0,I4,255);
4443 VAROR(UI1,0,DATE,0,I4,0);
4444 if (HAVE_OLEAUT32_I8)
4445 {
4446 VAROR(UI1,255,I8,-1,I8,-1);
4447 VAROR(UI1,255,I8,0,I8,255);
4448 VAROR(UI1,0,I8,0,I8,0);
4449 VAROR(UI1,255,UI8,0,I4,255);
4450 VAROR(UI1,0,UI8,0,I4,0);
4451 }
4452 VAROR(UI1,255,INT,-1,I4,-1);
4453 VAROR(UI1,255,INT,0,I4,255);
4454 VAROR(UI1,0,INT,0,I4,0);
4455 VAROR(UI1,255,UINT,0xffffffff,I4,-1);
4456 VAROR(UI1,255,UINT,0,I4,255);
4457 VAROR(UI1,0,UINT,0,I4,0);
4458 rbstr = SysAllocString(szFalse);
4459 VAROR(UI1,0,BSTR,rbstr,I2,0);
4460 VAROR(UI1,255,BSTR,rbstr,I2,255);
4461 SysFreeString(rbstr);
4462 rbstr = SysAllocString(szTrue);
4463 VAROR(UI1,0,BSTR,rbstr,I2,-1);
4464 VAROR(UI1,255,BSTR,rbstr,I2,-1);
4465 SysFreeString(rbstr);
4466 VARORCY(UI1,255,10000,I4,255);
4467 VARORCY(UI1,255,0,I4,255);
4468 VARORCY(UI1,0,0,I4,0);
4469
4470 VAROR(I2,-1,I2,-1,I2,-1);
4471 VAROR(I2,-1,I2,0,I2,-1);
4472 VAROR(I2,0,I2,0,I2,0);
4473 VAROR(I2,-1,UI2,65535,I4,-1);
4474 VAROR(I2,-1,UI2,0,I4,-1);
4475 VAROR(I2,0,UI2,0,I4,0);
4476 VAROR(I2,-1,I4,-1,I4,-1);
4477 VAROR(I2,-1,I4,0,I4,-1);
4478 VAROR(I2,0,I4,0,I4,0);
4479 VAROR(I2,-1,UI4,0xffffffff,I4,-1);
4480 VAROR(I2,-1,UI4,0,I4,-1);
4481 VAROR(I2,0,UI4,0,I4,0);
4482 VAROR(I2,-1,R4,-1,I4,-1);
4483 VAROR(I2,-1,R4,0,I4,-1);
4484 VAROR(I2,0,R4,0,I4,0);
4485 VAROR(I2,-1,R8,-1,I4,-1);
4486 VAROR(I2,-1,R8,0,I4,-1);
4487 VAROR(I2,0,R8,0,I4,0);
4488 VAROR(I2,-1,DATE,-1,I4,-1);
4489 VAROR(I2,-1,DATE,0,I4,-1);
4490 VAROR(I2,0,DATE,0,I4,0);
4491 if (HAVE_OLEAUT32_I8)
4492 {
4493 VAROR(I2,-1,I8,-1,I8,-1);
4494 VAROR(I2,-1,I8,0,I8,-1);
4495 VAROR(I2,0,I8,0,I8,0);
4496 VAROR(I2,-1,UI8,0,I4,-1);
4497 VAROR(I2,0,UI8,0,I4,0);
4498 }
4499 VAROR(I2,-1,INT,-1,I4,-1);
4500 VAROR(I2,-1,INT,0,I4,-1);
4501 VAROR(I2,0,INT,0,I4,0);
4502 VAROR(I2,-1,UINT,0xffffffff,I4,-1);
4503 VAROR(I2,-1,UINT,0,I4,-1);
4504 VAROR(I2,0,UINT,0,I4,0);
4505 rbstr = SysAllocString(szFalse);
4506 VAROR(I2,0,BSTR,rbstr,I2,0);
4507 VAROR(I2,-1,BSTR,rbstr,I2,-1);
4508 SysFreeString(rbstr);
4509 rbstr = SysAllocString(szTrue);
4510 VAROR(I2,0,BSTR,rbstr,I2,-1);
4511 VAROR(I2,-1,BSTR,rbstr,I2,-1);
4512 SysFreeString(rbstr);
4513 VARORCY(I2,-1,10000,I4,-1);
4514 VARORCY(I2,-1,0,I4,-1);
4515 VARORCY(I2,0,0,I4,0);
4516
4517 VAROR(UI2,65535,UI2,65535,I4,65535);
4518 VAROR(UI2,65535,UI2,0,I4,65535);
4519 VAROR(UI2,0,UI2,0,I4,0);
4520 VAROR(UI2,65535,I4,-1,I4,-1);
4521 VAROR(UI2,65535,I4,0,I4,65535);
4522 VAROR(UI2,0,I4,0,I4,0);
4523 VAROR(UI2,65535,UI4,0xffffffff,I4,-1);
4524 VAROR(UI2,65535,UI4,0,I4,65535);
4525 VAROR(UI2,0,UI4,0,I4,0);
4526 VAROR(UI2,65535,R4,-1,I4,-1);
4527 VAROR(UI2,65535,R4,0,I4,65535);
4528 VAROR(UI2,0,R4,0,I4,0);
4529 VAROR(UI2,65535,R8,-1,I4,-1);
4530 VAROR(UI2,65535,R8,0,I4,65535);
4531 VAROR(UI2,0,R8,0,I4,0);
4532 VAROR(UI2,65535,DATE,-1,I4,-1);
4533 VAROR(UI2,65535,DATE,0,I4,65535);
4534 VAROR(UI2,0,DATE,0,I4,0);
4535 if (HAVE_OLEAUT32_I8)
4536 {
4537 VAROR(UI2,65535,I8,-1,I8,-1);
4538 VAROR(UI2,65535,I8,0,I8,65535);
4539 VAROR(UI2,0,I8,0,I8,0);
4540 VAROR(UI2,65535,UI8,0,I4,65535);
4541 VAROR(UI2,0,UI8,0,I4,0);
4542 }
4543 VAROR(UI2,65535,INT,-1,I4,-1);
4544 VAROR(UI2,65535,INT,0,I4,65535);
4545 VAROR(UI2,0,INT,0,I4,0);
4546 VAROR(UI2,65535,UINT,0xffffffff,I4,-1);
4547 VAROR(UI2,65535,UINT,0,I4,65535);
4548 VAROR(UI2,0,UINT,0,I4,0);
4549 rbstr = SysAllocString(szFalse);
4550 VAROR(UI2,0,BSTR,rbstr,I4,0);
4551 VAROR(UI2,65535,BSTR,rbstr,I4,65535);
4552 SysFreeString(rbstr);
4553 rbstr = SysAllocString(szTrue);
4554 VAROR(UI2,0,BSTR,rbstr,I4,-1);
4555 VAROR(UI2,65535,BSTR,rbstr,I4,-1);
4556 SysFreeString(rbstr);
4557 VARORCY(UI2,65535,10000,I4,65535);
4558 VARORCY(UI2,65535,0,I4,65535);
4559 VARORCY(UI2,0,0,I4,0);
4560
4561 VAROR(I4,-1,I4,-1,I4,-1);
4562 VAROR(I4,-1,I4,0,I4,-1);
4563 VAROR(I4,0,I4,0,I4,0);
4564 VAROR(I4,-1,UI4,0xffffffff,I4,-1);
4565 VAROR(I4,-1,UI4,0,I4,-1);
4566 VAROR(I4,0,UI4,0,I4,0);
4567 VAROR(I4,-1,R4,-1,I4,-1);
4568 VAROR(I4,-1,R4,0,I4,-1);
4569 VAROR(I4,0,R4,0,I4,0);
4570 VAROR(I4,-1,R8,-1,I4,-1);
4571 VAROR(I4,-1,R8,0,I4,-1);
4572 VAROR(I4,0,R8,0,I4,0);
4573 VAROR(I4,-1,DATE,-1,I4,-1);
4574 VAROR(I4,-1,DATE,0,I4,-1);
4575 VAROR(I4,0,DATE,0,I4,0);
4576 if (HAVE_OLEAUT32_I8)
4577 {
4578 VAROR(I4,-1,I8,-1,I8,-1);
4579 VAROR(I4,-1,I8,0,I8,-1);
4580 VAROR(I4,0,I8,0,I8,0);
4581 VAROR(I4,-1,UI8,0,I4,-1);
4582 VAROR(I4,0,UI8,0,I4,0);
4583 }
4584 VAROR(I4,-1,INT,-1,I4,-1);
4585 VAROR(I4,-1,INT,0,I4,-1);
4586 VAROR(I4,0,INT,0,I4,0);
4587 VAROR(I4,-1,UINT,0xffffffff,I4,-1);
4588 VAROR(I4,-1,UINT,0,I4,-1);
4589 VAROR(I4,0,UINT,0,I4,0);
4590 rbstr = SysAllocString(szFalse);
4591 VAROR(I4,0,BSTR,rbstr,I4,0);
4592 VAROR(I4,-1,BSTR,rbstr,I4,-1);
4593 SysFreeString(rbstr);
4594 rbstr = SysAllocString(szTrue);
4595 VAROR(I4,0,BSTR,rbstr,I4,-1);
4596 VAROR(I4,-1,BSTR,rbstr,I4,-1);
4597 SysFreeString(rbstr);
4598 VARORCY(I4,-1,10000,I4,-1);
4599 VARORCY(I4,-1,0,I4,-1);
4600 VARORCY(I4,0,0,I4,0);
4601
4602 VAROR(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
4603 VAROR(UI4,0xffffffff,UI4,0,I4,-1);
4604 VAROR(UI4,0,UI4,0,I4,0);
4605 VAROR(UI4,0xffffffff,R4,-1,I4,-1);
4606 VAROR(UI4,0xffffffff,R4,0,I4,-1);
4607 VAROR(UI4,0,R4,0,I4,0);
4608 VAROR(UI4,0xffffffff,R8,-1,I4,-1);
4609 VAROR(UI4,0xffffffff,R8,0,I4,-1);
4610 VAROR(UI4,0,R8,0,I4,0);
4611 VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
4612 VAROR(UI4,0xffffffff,DATE,0,I4,-1);
4613 VAROR(UI4,0,DATE,0,I4,0);
4614 if (HAVE_OLEAUT32_I8)
4615 {
4616 VAROR(UI4,0xffffffff,I8,-1,I8,-1);
4617 VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
4618 VAROR(UI4,0,I8,0,I8,0);
4619 VAROR(UI4,0xffffffff,UI8,0,I4,-1);
4620 VAROR(UI4,0,UI8,0,I4,0);
4621 }
4622 VAROR(UI4,0xffffffff,INT,-1,I4,-1);
4623 VAROR(UI4,0xffffffff,INT,0,I4,-1);
4624 VAROR(UI4,0,INT,0,I4,0);
4625 VAROR(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
4626 VAROR(UI4,0xffffffff,UINT,0,I4,-1);
4627 VAROR(UI4,0,UINT,0,I4,0);
4628 rbstr = SysAllocString(szFalse);
4629 VAROR(UI4,0,BSTR,rbstr,I4,0);
4630 VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4631 SysFreeString(rbstr);
4632 rbstr = SysAllocString(szTrue);
4633 VAROR(UI4,0,BSTR,rbstr,I4,-1);
4634 VAROR(UI4,0xffffffff,BSTR,rbstr,I4,-1);
4635 SysFreeString(rbstr);
4636 VARORCY(UI4,0xffffffff,10000,I4,-1);
4637 VARORCY(UI4,0xffffffff,0,I4,-1);
4638 VARORCY(UI4,0,0,I4,0);
4639
4640 VAROR(R4,-1,R4,-1,I4,-1);
4641 VAROR(R4,-1,R4,0,I4,-1);
4642 VAROR(R4,0,R4,0,I4,0);
4643 VAROR(R4,-1,R8,-1,I4,-1);
4644 VAROR(R4,-1,R8,0,I4,-1);
4645 VAROR(R4,0,R8,0,I4,0);
4646 VAROR(R4,-1,DATE,-1,I4,-1);
4647 VAROR(R4,-1,DATE,0,I4,-1);
4648 VAROR(R4,0,DATE,0,I4,0);
4649 if (HAVE_OLEAUT32_I8)
4650 {
4651 VAROR(R4,-1,I8,-1,I8,-1);
4652 VAROR(R4,-1,I8,0,I8,-1);
4653 VAROR(R4,0,I8,0,I8,0);
4654 VAROR(R4,-1,UI8,0,I4,-1);
4655 VAROR(R4,0,UI8,0,I4,0);
4656 }
4657 VAROR(R4,-1,INT,-1,I4,-1);
4658 VAROR(R4,-1,INT,0,I4,-1);
4659 VAROR(R4,0,INT,0,I4,0);
4660 VAROR(R4,-1,UINT,0xffffffff,I4,-1);
4661 VAROR(R4,-1,UINT,0,I4,-1);
4662 VAROR(R4,0,UINT,0,I4,0);
4663 rbstr = SysAllocString(szFalse);
4664 VAROR(R4,0,BSTR,rbstr,I4,0);
4665 VAROR(R4,-1,BSTR,rbstr,I4,-1);
4666 SysFreeString(rbstr);
4667 rbstr = SysAllocString(szTrue);
4668 VAROR(R4,0,BSTR,rbstr,I4,-1);
4669 VAROR(R4,-1,BSTR,rbstr,I4,-1);
4670 SysFreeString(rbstr);
4671 VARORCY(R4,-1,10000,I4,-1);
4672 VARORCY(R4,-1,0,I4,-1);
4673 VARORCY(R4,0,0,I4,0);
4674
4675 VAROR(R8,-1,R8,-1,I4,-1);
4676 VAROR(R8,-1,R8,0,I4,-1);
4677 VAROR(R8,0,R8,0,I4,0);
4678 VAROR(R8,-1,DATE,-1,I4,-1);
4679 VAROR(R8,-1,DATE,0,I4,-1);
4680 VAROR(R8,0,DATE,0,I4,0);
4681 if (HAVE_OLEAUT32_I8)
4682 {
4683 VAROR(R8,-1,I8,-1,I8,-1);
4684 VAROR(R8,-1,I8,0,I8,-1);
4685 VAROR(R8,0,I8,0,I8,0);
4686 VAROR(R8,-1,UI8,0,I4,-1);
4687 VAROR(R8,0,UI8,0,I4,0);
4688 }
4689 VAROR(R8,-1,INT,-1,I4,-1);
4690 VAROR(R8,-1,INT,0,I4,-1);
4691 VAROR(R8,0,INT,0,I4,0);
4692 VAROR(R8,-1,UINT,0xffffffff,I4,-1);
4693 VAROR(R8,-1,UINT,0,I4,-1);
4694 VAROR(R8,0,UINT,0,I4,0);
4695 rbstr = SysAllocString(szFalse);
4696 VAROR(R8,0,BSTR,rbstr,I4,0);
4697 VAROR(R8,-1,BSTR,rbstr,I4,-1);
4698 SysFreeString(rbstr);
4699 rbstr = SysAllocString(szTrue);
4700 VAROR(R8,0,BSTR,rbstr,I4,-1);
4701 VAROR(R8,-1,BSTR,rbstr,I4,-1);
4702 SysFreeString(rbstr);
4703 VARORCY(R8,-1,10000,I4,-1);
4704 VARORCY(R8,-1,0,I4,-1);
4705 VARORCY(R8,0,0,I4,0);
4706
4707 VAROR(DATE,-1,DATE,-1,I4,-1);
4708 VAROR(DATE,-1,DATE,0,I4,-1);
4709 VAROR(DATE,0,DATE,0,I4,0);
4710 if (HAVE_OLEAUT32_I8)
4711 {
4712 VAROR(DATE,-1,I8,-1,I8,-1);
4713 VAROR(DATE,-1,I8,0,I8,-1);
4714 VAROR(DATE,0,I8,0,I8,0);
4715 VAROR(DATE,-1,UI8,0,I4,-1);
4716 VAROR(DATE,0,UI8,0,I4,0);
4717 }
4718 VAROR(DATE,-1,INT,-1,I4,-1);
4719 VAROR(DATE,-1,INT,0,I4,-1);
4720 VAROR(DATE,0,INT,0,I4,0);
4721 VAROR(DATE,-1,UINT,0xffffffff,I4,-1);
4722 VAROR(DATE,-1,UINT,0,I4,-1);
4723 VAROR(DATE,0,UINT,0,I4,0);
4724 rbstr = SysAllocString(szFalse);
4725 VAROR(DATE,0,BSTR,rbstr,I4,0);
4726 VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4727 SysFreeString(rbstr);
4728 rbstr = SysAllocString(szTrue);
4729 VAROR(DATE,0,BSTR,rbstr,I4,-1);
4730 VAROR(DATE,-1,BSTR,rbstr,I4,-1);
4731 SysFreeString(rbstr);
4732 VARORCY(DATE,-1,10000,I4,-1);
4733 VARORCY(DATE,-1,0,I4,-1);
4734 VARORCY(DATE,0,0,I4,0);
4735
4736 if (HAVE_OLEAUT32_I8)
4737 {
4738 VAROR(I8,-1,I8,-1,I8,-1);
4739 VAROR(I8,-1,I8,0,I8,-1);
4740 VAROR(I8,0,I8,0,I8,0);
4741 VAROR(I8,-1,UI8,0,I8,-1);
4742 VAROR(I8,0,UI8,0,I8,0);
4743 /* These overflow under native and Wine
4744 VAROR(I8,-1,INT,-1,I4,-1);
4745 VAROR(I8,-1,INT,0,I4,-1);
4746 VAROR(I8,0,INT,0,I4,0); */
4747 VAROR(I8,-1,UINT,0xffffffff,I8,-1);
4748 VAROR(I8,-1,UINT,0,I8,-1);
4749 VAROR(I8,0,UINT,0,I8,0);
4750 rbstr = SysAllocString(szFalse);
4751 VAROR(I8,0,BSTR,rbstr,I8,0);
4752 VAROR(I8,-1,BSTR,rbstr,I8,-1);
4753 SysFreeString(rbstr);
4754 rbstr = SysAllocString(szTrue);
4755 VAROR(I8,0,BSTR,rbstr,I8,-1);
4756 VAROR(I8,-1,BSTR,rbstr,I8,-1);
4757 SysFreeString(rbstr);
4758 VARORCY(I8,-1,10000,I8,-1);
4759 VARORCY(I8,-1,0,I8,-1);
4760 VARORCY(I8,0,0,I8,0);
4761
4762 VAROR(UI8,0xffff,UI8,0xffff,I4,0xffff);
4763 VAROR(UI8,0xffff,UI8,0,I4,0xffff);
4764 VAROR(UI8,0,UI8,0,I4,0);
4765 VAROR(UI8,0xffff,INT,-1,I4,-1);
4766 VAROR(UI8,0xffff,INT,0,I4,0xffff);
4767 VAROR(UI8,0,INT,0,I4,0);
4768 VAROR(UI8,0xffff,UINT,0xffff,I4,0xffff);
4769 VAROR(UI8,0xffff,UINT,0,I4,0xffff);
4770 VAROR(UI8,0,UINT,0,I4,0);
4771 rbstr = SysAllocString(szFalse);
4772 VAROR(UI8,0,BSTR,rbstr,I4,0);
4773 VAROR(UI8,0xffff,BSTR,rbstr,I4,0xffff);
4774 SysFreeString(rbstr);
4775 rbstr = SysAllocString(szTrue);
4776 VAROR(UI8,0,BSTR,rbstr,I4,-1);
4777 VAROR(UI8,0xffff,BSTR,rbstr,I4,-1);
4778 SysFreeString(rbstr);
4779 VARORCY(UI8,0xffff,10000,I4,0xffff);
4780 VARORCY(UI8,0xffff,0,I4,0xffff);
4781 VARORCY(UI8,0,0,I4,0);
4782 }
4783
4784 VAROR(INT,-1,INT,-1,I4,-1);
4785 VAROR(INT,-1,INT,0,I4,-1);
4786 VAROR(INT,0,INT,0,I4,0);
4787 VAROR(INT,-1,UINT,0xffff,I4,-1);
4788 VAROR(INT,-1,UINT,0,I4,-1);
4789 VAROR(INT,0,UINT,0,I4,0);
4790 rbstr = SysAllocString(szFalse);
4791 VAROR(INT,0,BSTR,rbstr,I4,0);
4792 VAROR(INT,-1,BSTR,rbstr,I4,-1);
4793 SysFreeString(rbstr);
4794 rbstr = SysAllocString(szTrue);
4795 VAROR(INT,0,BSTR,rbstr,I4,-1);
4796 VAROR(INT,-1,BSTR,rbstr,I4,-1);
4797 SysFreeString(rbstr);
4798 VARORCY(INT,-1,10000,I4,-1);
4799 VARORCY(INT,-1,0,I4,-1);
4800 VARORCY(INT,0,0,I4,0);
4801
4802 VAROR(UINT,0xffff,UINT,0xffff,I4,0xffff);
4803 VAROR(UINT,0xffff,UINT,0,I4,0xffff);
4804 VAROR(UINT,0,UINT,0,I4,0);
4805 rbstr = SysAllocString(szFalse);
4806 VAROR(UINT,0,BSTR,rbstr,I4,0);
4807 VAROR(UINT,0xffff,BSTR,rbstr,I4,0xffff);
4808 SysFreeString(rbstr);
4809 rbstr = SysAllocString(szTrue);
4810 VAROR(UINT,0,BSTR,rbstr,I4,-1);
4811 VAROR(UINT,0xffff,BSTR,rbstr,I4,-1);
4812 SysFreeString(rbstr);
4813 VARORCY(UINT,0xffff,10000,I4,0xffff);
4814 VARORCY(UINT,0xffff,0,I4,0xffff);
4815 VARORCY(UINT,0,0,I4,0);
4816
4817 lbstr = SysAllocString(szFalse);
4818 rbstr = SysAllocString(szFalse);
4819 VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,0);
4820 SysFreeString(rbstr);
4821 rbstr = SysAllocString(szTrue);
4822 VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4823 SysFreeString(lbstr);
4824 lbstr = SysAllocString(szTrue);
4825 VAROR(BSTR,lbstr,BSTR,rbstr,BOOL,VARIANT_TRUE);
4826 VARORCY(BSTR,lbstr,10000,I4,-1);
4827 SysFreeString(lbstr);
4828 lbstr = SysAllocString(szFalse);
4829 VARORCY(BSTR,lbstr,10000,I4,1);
4830 SysFreeString(lbstr);
4831 SysFreeString(rbstr);
4832 }
4833
4834 static HRESULT (WINAPI *pVarEqv)(LPVARIANT,LPVARIANT,LPVARIANT);
4835
4836 #define VAREQV(vt1,val1,vt2,val2,rvt,rval) \
4837 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4838 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4839 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4840 test_var_call2( __LINE__, pVarEqv, &left, &right, &exp )
4841
4842 static void test_VarEqv(void)
4843 {
4844 VARIANT left, right, exp, result;
4845 VARTYPE i;
4846 HRESULT hres;
4847
4848 CHECKPTR(VarEqv);
4849
4850 /* Test all possible flag/vt combinations & the resulting vt type */
4851 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4852 {
4853 VARTYPE leftvt, rightvt, resvt;
4854
4855 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
4856 {
4857 SKIPTESTS(leftvt);
4858
4859 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
4860 {
4861 BOOL bFail = FALSE;
4862
4863 SKIPTESTS(rightvt);
4864
4865 if (leftvt == VT_BSTR || rightvt == VT_BSTR ||
4866 leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
4867 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
4868 continue;
4869
4870 memset(&left, 0, sizeof(left));
4871 memset(&right, 0, sizeof(right));
4872 V_VT(&left) = leftvt | ExtraFlags[i];
4873 V_VT(&right) = rightvt | ExtraFlags[i];
4874 V_VT(&result) = VT_EMPTY;
4875 resvt = VT_I4;
4876
4877 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
4878 !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
4879 !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
4880 leftvt == VT_CLSID || rightvt == VT_CLSID ||
4881 leftvt == VT_RECORD || rightvt == VT_RECORD ||
4882 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
4883 leftvt == VT_ERROR || rightvt == VT_ERROR)
4884 {
4885 bFail = TRUE;
4886 }
4887 if (leftvt == VT_EMPTY || rightvt == VT_EMPTY)
4888 {
4889 if (leftvt == rightvt ||
4890 leftvt == VT_I2 || rightvt == VT_I2 ||
4891 leftvt == VT_UI1 || rightvt == VT_UI1 ||
4892 leftvt == VT_BOOL || rightvt == VT_BOOL)
4893 resvt = VT_I2;
4894 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4895 resvt = VT_NULL;
4896 else if (leftvt == VT_I8 || rightvt == VT_I8)
4897 resvt = VT_I8;
4898 }
4899 else if (leftvt == VT_NULL || rightvt == VT_NULL)
4900 {
4901 resvt = VT_NULL;
4902 }
4903 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
4904 {
4905 if (leftvt == rightvt)
4906 resvt = VT_UI1;
4907 else if (leftvt == rightvt ||
4908 leftvt == VT_I2 || rightvt == VT_I2 ||
4909 leftvt == VT_BOOL || rightvt == VT_BOOL)
4910 {
4911 resvt = VT_I2;
4912 }
4913 else if (leftvt == VT_I8 || rightvt == VT_I8)
4914 resvt = VT_I8;
4915 }
4916 else if (leftvt == VT_I2 || rightvt == VT_I2)
4917 {
4918 if (leftvt == rightvt ||
4919 leftvt == VT_BOOL || rightvt == VT_BOOL)
4920 resvt = VT_I2;
4921 else if (leftvt == VT_I8 || rightvt == VT_I8)
4922 resvt = VT_I8;
4923 }
4924 else if (leftvt == VT_BOOL && rightvt == VT_BOOL)
4925 {
4926 resvt = VT_BOOL;
4927 }
4928 else if (leftvt == VT_I8 || rightvt == VT_I8)
4929 {
4930 if (leftvt == VT_INT || rightvt == VT_INT)
4931 bFail = TRUE;
4932 else
4933 resvt = VT_I8;
4934 }
4935 hres = pVarEqv(&left, &right, &result);
4936 if (bFail)
4937 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
4938 "VarEqv: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
4939 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
4940 V_VT(&result));
4941 else
4942 ok(hres == S_OK && V_VT(&result) == resvt,
4943 "VarEqv: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
4944 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
4945 V_VT(&result));
4946 }
4947 }
4948 }
4949
4950 /* Test returned values */
4951 VAREQV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
4952 VAREQV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
4953 VAREQV(BOOL,TRUE,BOOL,TRUE,BOOL,VARIANT_TRUE);
4954 VAREQV(BOOL,FALSE,BOOL,FALSE,BOOL,VARIANT_TRUE);
4955 VAREQV(BOOL,TRUE,BOOL,FALSE,BOOL,-2);
4956 VAREQV(BOOL,FALSE,BOOL,TRUE,BOOL,-2);
4957 VAREQV(BOOL,6,BOOL,7,BOOL,-2);
4958 VAREQV(BOOL,6,BOOL,6,BOOL,VARIANT_TRUE);
4959 VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_TRUE,I2,VARIANT_TRUE);
4960 VAREQV(BOOL,VARIANT_TRUE,I2,VARIANT_FALSE,I2,VARIANT_FALSE);
4961 VAREQV(BOOL,6,I2,7,I2,-2);
4962 VAREQV(UI1,1,UI1,1,UI1,255);
4963 VAREQV(UI1,1,UI1,0,UI1,254);
4964 VAREQV(UI1,0,UI1,1,UI1,254);
4965 if (HAVE_OLEAUT32_I8)
4966 {
4967 VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
4968 VAREQV(UI4,5,I8,19,I8,-23);
4969 VAREQV(UI4,VARIANT_FALSE,UI8,VARIANT_FALSE,I4,-1);
4970 }
4971 }
4972
4973 static HRESULT (WINAPI *pVarMul)(LPVARIANT,LPVARIANT,LPVARIANT);
4974
4975 #define VARMUL(vt1,val1,vt2,val2,rvt,rval) \
4976 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
4977 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
4978 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
4979 test_var_call2( __LINE__, pVarMul, &left, &right, &exp )
4980
4981 static void test_VarMul(void)
4982 {
4983 VARIANT left, right, exp, result, cy, dec;
4984 VARTYPE i;
4985 BSTR lbstr, rbstr;
4986 HRESULT hres;
4987 double r;
4988
4989 CHECKPTR(VarMul);
4990
4991 lbstr = SysAllocString(sz12);
4992 rbstr = SysAllocString(sz12);
4993
4994 /* Test all possible flag/vt combinations & the resulting vt type */
4995 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
4996 {
4997 VARTYPE leftvt, rightvt, resvt;
4998
4999 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5000 {
5001
5002 SKIPTESTS(leftvt);
5003
5004 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5005 {
5006 BOOL bFail = FALSE;
5007
5008 SKIPTESTS(rightvt);
5009
5010 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5011 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN)
5012 continue;
5013
5014 memset(&left, 0, sizeof(left));
5015 memset(&right, 0, sizeof(right));
5016 V_VT(&left) = leftvt | ExtraFlags[i];
5017 if (leftvt == VT_BSTR)
5018 V_BSTR(&left) = lbstr;
5019 V_VT(&right) = rightvt | ExtraFlags[i];
5020 if (rightvt == VT_BSTR)
5021 V_BSTR(&right) = rbstr;
5022 V_VT(&result) = VT_EMPTY;
5023 resvt = VT_UNKNOWN;
5024
5025 /* Don't ask me why but native VarMul cannot handle:
5026 VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5027 Tested with DCOM98, Win2k, WinXP */
5028 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5029 !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5030 !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5031 leftvt == VT_CLSID || rightvt == VT_CLSID ||
5032 leftvt == VT_RECORD || rightvt == VT_RECORD ||
5033 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5034 leftvt == VT_ERROR || rightvt == VT_ERROR ||
5035 leftvt == VT_I1 || rightvt == VT_I1 ||
5036 leftvt == VT_UI2 || rightvt == VT_UI2 ||
5037 leftvt == VT_UI4 || rightvt == VT_UI4 ||
5038 leftvt == VT_UI8 || rightvt == VT_UI8 ||
5039 leftvt == VT_INT || rightvt == VT_INT ||
5040 leftvt == VT_UINT || rightvt == VT_UINT) {
5041 bFail = TRUE;
5042 }
5043
5044 if (leftvt == VT_NULL || rightvt == VT_NULL)
5045 resvt = VT_NULL;
5046 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5047 resvt = VT_DECIMAL;
5048 else if (leftvt == VT_R8 || rightvt == VT_R8 ||
5049 leftvt == VT_BSTR || rightvt == VT_BSTR ||
5050 leftvt == VT_DATE || rightvt == VT_DATE)
5051 resvt = VT_R8;
5052 else if (leftvt == VT_R4 || rightvt == VT_R4) {
5053 if (leftvt == VT_I4 || rightvt == VT_I4 ||
5054 leftvt == VT_I8 || rightvt == VT_I8 ||
5055 leftvt == VT_CY || rightvt == VT_CY)
5056 resvt = VT_R8;
5057 else
5058 resvt = VT_R4;
5059 } else if (leftvt == VT_CY || rightvt == VT_CY)
5060 resvt = VT_CY;
5061 else if (leftvt == VT_I8 || rightvt == VT_I8)
5062 resvt = VT_I8;
5063 else if (leftvt == VT_I4 || rightvt == VT_I4)
5064 resvt = VT_I4;
5065 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5066 leftvt == VT_BOOL || rightvt == VT_BOOL ||
5067 (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5068 resvt = VT_I2;
5069 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5070 resvt = VT_UI1;
5071
5072 hres = pVarMul(&left, &right, &result);
5073 if (bFail) {
5074 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5075 "VarMul: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5076 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5077 V_VT(&result));
5078 } else {
5079 ok(hres == S_OK && V_VT(&result) == resvt,
5080 "VarMul: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5081 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5082 V_VT(&result));
5083 }
5084 }
5085 }
5086 }
5087
5088 /* Test returned values */
5089 VARMUL(I4,4,I4,2,I4,8);
5090 VARMUL(I2,4,I2,2,I2,8);
5091 VARMUL(I2,-13,I4,5,I4,-65);
5092 VARMUL(I4,-13,I4,5,I4,-65);
5093 VARMUL(I2,7,R4,0.5f,R4,3.5f);
5094 VARMUL(R4,0.5f,I4,5,R8,2.5);
5095 VARMUL(R8,7.1,BOOL,0,R8,0);
5096 VARMUL(BSTR,lbstr,I2,4,R8,48);
5097 VARMUL(BSTR,lbstr,BOOL,1,R8,12);
5098 VARMUL(BSTR,lbstr,R4,0.1f,R8,1.2);
5099 VARMUL(BSTR,lbstr,BSTR,rbstr,R8,144);
5100 VARMUL(R4,0.2f,BSTR,rbstr,R8,2.4);
5101 VARMUL(DATE,2.25,I4,7,R8,15.75);
5102
5103 VARMUL(UI1, UI1_MAX, UI1, UI1_MAX, I4, UI1_MAX * UI1_MAX);
5104 VARMUL(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX * I2_MAX);
5105 VARMUL(I2, I2_MAX, I2, I2_MIN, I4, I2_MAX * I2_MIN);
5106 VARMUL(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN * I2_MIN);
5107 VARMUL(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX * I4_MAX);
5108 VARMUL(I4, I4_MAX, I4, I4_MIN, R8, (double)I4_MAX * I4_MIN);
5109 VARMUL(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN * I4_MIN);
5110 VARMUL(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX * R4_MAX);
5111 VARMUL(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX * R4_MIN);
5112 VARMUL(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN * R4_MIN);
5113 VARMUL(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX * R8_MIN);
5114 VARMUL(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN * R8_MIN);
5115
5116 /* Manuly test some VT_CY and VT_DECIMAL variants */
5117 V_VT(&cy) = VT_CY;
5118 hres = VarCyFromI4(4711, &V_CY(&cy));
5119 ok(hres == S_OK, "VarCyFromI4 failed!\n");
5120 V_VT(&dec) = VT_DECIMAL;
5121 hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5122 ok(hres == S_OK, "VarDecFromR4 failed!\n");
5123 memset(&left, 0, sizeof(left));
5124 memset(&right, 0, sizeof(right));
5125 V_VT(&left) = VT_I4;
5126 V_I4(&left) = -11;
5127 V_VT(&right) = VT_UI1;
5128 V_UI1(&right) = 9;
5129
5130 hres = pVarMul(&cy, &right, &result);
5131 ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5132 hres = VarR8FromCy(V_CY(&result), &r);
5133 ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
5134
5135 hres = pVarMul(&left, &dec, &result);
5136 ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5137 hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5138 ok(hres == S_OK && EQ_DOUBLE(r, 46.2), "VarMul: DECIMAL value %f, expected %f\n", r, (double)46.2);
5139
5140 SysFreeString(lbstr);
5141 SysFreeString(rbstr);
5142 }
5143
5144 static HRESULT (WINAPI *pVarAdd)(LPVARIANT,LPVARIANT,LPVARIANT);
5145
5146 #define VARADD(vt1,val1,vt2,val2,rvt,rval) \
5147 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
5148 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5149 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
5150 test_var_call2( __LINE__, pVarAdd, &left, &right, &exp )
5151
5152 static void test_VarAdd(void)
5153 {
5154 VARIANT left, right, exp, result, cy, dec;
5155 VARTYPE i;
5156 BSTR lbstr, rbstr;
5157 HRESULT hres;
5158 double r;
5159
5160 CHECKPTR(VarAdd);
5161
5162 lbstr = SysAllocString(sz12);
5163 rbstr = SysAllocString(sz12);
5164
5165 /* Test all possible flag/vt combinations & the resulting vt type */
5166 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); 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_UNKNOWN || rightvt == VT_UNKNOWN)
5182 continue;
5183
5184 memset(&left, 0, sizeof(left));
5185 memset(&right, 0, sizeof(right));
5186 V_VT(&left) = leftvt | ExtraFlags[i];
5187 if (leftvt == VT_BSTR)
5188 V_BSTR(&left) = lbstr;
5189 V_VT(&right) = rightvt | ExtraFlags[i];
5190 if (rightvt == VT_BSTR)
5191 V_BSTR(&right) = rbstr;
5192 V_VT(&result) = VT_EMPTY;
5193 resvt = VT_ERROR;
5194
5195 /* Don't ask me why but native VarAdd cannot handle:
5196 VT_I1, VT_UI2, VT_UI4, VT_INT, VT_UINT and VT_UI8.
5197 Tested with DCOM98, Win2k, WinXP */
5198 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
5199 !IsValidVariantClearVT(leftvt, ExtraFlags[i]) ||
5200 !IsValidVariantClearVT(rightvt, ExtraFlags[i]) ||
5201 leftvt == VT_CLSID || rightvt == VT_CLSID ||
5202 leftvt == VT_RECORD || rightvt == VT_RECORD ||
5203 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
5204 leftvt == VT_ERROR || rightvt == VT_ERROR ||
5205 leftvt == VT_I1 || rightvt == VT_I1 ||
5206 leftvt == VT_UI2 || rightvt == VT_UI2 ||
5207 leftvt == VT_UI4 || rightvt == VT_UI4 ||
5208 leftvt == VT_UI8 || rightvt == VT_UI8 ||
5209 leftvt == VT_INT || rightvt == VT_INT ||
5210 leftvt == VT_UINT || rightvt == VT_UINT) {
5211 bFail = TRUE;
5212 }
5213
5214 if (leftvt == VT_NULL || rightvt == VT_NULL)
5215 resvt = VT_NULL;
5216 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH)
5217 bFail = TRUE;
5218 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5219 resvt = VT_DECIMAL;
5220 else if (leftvt == VT_DATE || rightvt == VT_DATE)
5221 resvt = VT_DATE;
5222 else if (leftvt == VT_CY || rightvt == VT_CY)
5223 resvt = VT_CY;
5224 else if (leftvt == VT_R8 || rightvt == VT_R8)
5225 resvt = VT_R8;
5226 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) {
5227 if ((leftvt == VT_BSTR && rightvt == VT_BSTR) ||
5228 leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5229 resvt = VT_BSTR;
5230 else
5231 resvt = VT_R8;
5232 } else if (leftvt == VT_R4 || rightvt == VT_R4) {
5233 if (leftvt == VT_I4 || rightvt == VT_I4 ||
5234 leftvt == VT_I8 || rightvt == VT_I8)
5235 resvt = VT_R8;
5236 else
5237 resvt = VT_R4;
5238 }
5239 else if (leftvt == VT_I8 || rightvt == VT_I8)
5240 resvt = VT_I8;
5241 else if (leftvt == VT_I4 || rightvt == VT_I4)
5242 resvt = VT_I4;
5243 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5244 leftvt == VT_BOOL || rightvt == VT_BOOL ||
5245 (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
5246 resvt = VT_I2;
5247 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5248 resvt = VT_UI1;
5249
5250 hres = pVarAdd(&left, &right, &result);
5251 if (bFail) {
5252 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
5253 "VarAdd: %d|0x%X, %d|0x%X: Expected failure, got 0x%X vt %d\n",
5254 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres,
5255 V_VT(&result));
5256 } else {
5257 ok(hres == S_OK && V_VT(&result) == resvt,
5258 "VarAdd: %d|0x%X, %d|0x%X: expected S_OK, vt %d, got 0x%X vt %d\n",
5259 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], resvt, hres,
5260 V_VT(&result));
5261 }
5262 /* Note, we don't clear left/right deliberately here */
5263 VariantClear(&result);
5264 }
5265 }
5266 }
5267
5268 /* Test returned values */
5269 VARADD(I4,4,I4,2,I4,6);
5270 VARADD(I2,4,I2,2,I2,6);
5271 VARADD(I2,-13,I4,5,I4,-8);
5272 VARADD(I4,-13,I4,5,I4,-8);
5273 VARADD(I2,7,R4,0.5f,R4,7.5f);
5274 VARADD(R4,0.5f,I4,5,R8,5.5);
5275 VARADD(R8,7.1,BOOL,0,R8,7.1);
5276 VARADD(BSTR,lbstr,I2,4,R8,16);
5277 VARADD(BSTR,lbstr,BOOL,1,R8,13);
5278 VARADD(BSTR,lbstr,R4,0.1f,R8,12.1);
5279 VARADD(R4,0.2f,BSTR,rbstr,R8,12.2);
5280 VARADD(DATE,2.25,I4,7,DATE,9.25);
5281 VARADD(DATE,1.25,R4,-1.7f,DATE,-0.45);
5282
5283 VARADD(UI1, UI1_MAX, UI1, UI1_MAX, I2, UI1_MAX + UI1_MAX);
5284 VARADD(I2, I2_MAX, I2, I2_MAX, I4, I2_MAX + I2_MAX);
5285 VARADD(I2, I2_MAX, I2, I2_MIN, I2, I2_MAX + I2_MIN);
5286 VARADD(I2, I2_MIN, I2, I2_MIN, I4, I2_MIN + I2_MIN);
5287 VARADD(I4, I4_MAX, I4, I4_MIN, I4, I4_MAX + I4_MIN);
5288 VARADD(I4, I4_MAX, I4, I4_MAX, R8, (double)I4_MAX + I4_MAX);
5289 VARADD(I4, I4_MIN, I4, I4_MIN, R8, (double)I4_MIN + I4_MIN);
5290 VARADD(R4, R4_MAX, R4, R4_MAX, R8, (double)R4_MAX + R4_MAX);
5291 VARADD(R4, R4_MAX, R4, R4_MIN, R4, R4_MAX + R4_MIN);
5292 VARADD(R4, R4_MIN, R4, R4_MIN, R4, R4_MIN + R4_MIN);
5293 VARADD(R8, R8_MAX, R8, R8_MIN, R8, R8_MAX + R8_MIN);
5294 VARADD(R8, R8_MIN, R8, R8_MIN, R8, R8_MIN + R8_MIN);
5295
5296 /* Manually test BSTR + BSTR */
5297 V_VT(&left) = VT_BSTR;
5298 V_BSTR(&left) = lbstr;
5299 V_VT(&right) = VT_BSTR;
5300 V_BSTR(&right) = rbstr;
5301 hres = pVarAdd(&left, &right, &result);
5302 ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
5303 hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
5304 ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
5305 VariantClear(&result);
5306
5307 /* Manuly test some VT_CY and VT_DECIMAL variants */
5308 V_VT(&cy) = VT_CY;
5309 hres = VarCyFromI4(4711, &V_CY(&cy));
5310 ok(hres == S_OK, "VarCyFromI4 failed!\n");
5311 V_VT(&dec) = VT_DECIMAL;
5312 hres = VarDecFromR8(-4.2, &V_DECIMAL(&dec));
5313 ok(hres == S_OK, "VarDecFromR4 failed!\n");
5314 memset(&left, 0, sizeof(left));
5315 memset(&right, 0, sizeof(right));
5316 V_VT(&left) = VT_I4;
5317 V_I4(&left) = -11;
5318 V_VT(&right) = VT_UI1;
5319 V_UI1(&right) = 9;
5320
5321 hres = pVarAdd(&cy, &right, &result);
5322 ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
5323 hres = VarR8FromCy(V_CY(&result), &r);
5324 ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
5325
5326 hres = pVarAdd(&left, &dec, &result);
5327 ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
5328 hres = VarR8FromDec(&V_DECIMAL(&result), &r);
5329 ok(hres == S_OK && EQ_DOUBLE(r, -15.2), "VarAdd: DECIMAL value %f, expected %f\n", r, (double)-15.2);
5330 VariantClear(&result);
5331
5332 SysFreeString(lbstr);
5333 SysFreeString(rbstr);
5334 }
5335
5336 static HRESULT (WINAPI *pVarCmp)(LPVARIANT,LPVARIANT,LCID,ULONG);
5337 static HRESULT (WINAPI *pVarCat)(LPVARIANT,LPVARIANT,LPVARIANT);
5338
5339 static void test_VarCat(void)
5340 {
5341 LCID lcid;
5342 VARIANT left, right, result, expected, expected_broken;
5343 static const WCHAR sz34[] = {'3','4','\0'};
5344 static const WCHAR sz1234[] = {'1','2','3','4','\0'};
5345 static const WCHAR date_sz12[] = {'9','/','3','0','/','1','9','8','0','1','2','\0'};
5346 static const WCHAR date_sz12_broken[] = {'9','/','3','0','/','8','0','1','2','\0'};
5347 static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
5348 static const WCHAR sz12_date_broken[] = {'1','2','9','/','3','0','/','8','0','\0'};
5349 static const WCHAR sz_empty[] = {'\0'};
5350 TCHAR orig_date_format[128];
5351 VARTYPE leftvt, rightvt, resultvt;
5352 HRESULT hres;
5353 HRESULT expected_error_num;
5354
5355 CHECKPTR(VarCat);
5356
5357 /* Set date format for testing */
5358 lcid = LOCALE_USER_DEFAULT;
5359 GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
5360 SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
5361
5362 VariantInit(&left);
5363 VariantInit(&right);
5364 VariantInit(&result);
5365 VariantInit(&expected);
5366
5367 /* Check expected types for all combinations */
5368 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5369 {
5370
5371 SKIPTESTS(leftvt);
5372
5373 /* Check if we need/have support for I8 and/or UI8 */
5374 if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5375 continue;
5376
5377 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5378 {
5379
5380 SKIPTESTS(rightvt);
5381 expected_error_num = S_OK;
5382 resultvt = VT_EMPTY;
5383
5384 if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
5385 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
5386 leftvt == VT_RECORD || rightvt == VT_RECORD ||
5387 leftvt == 15 || rightvt == 15 /* Undefined type */)
5388 continue;
5389
5390 /* Check if we need/have support for I8 and/or UI8 */
5391 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5392 continue;
5393
5394 if (leftvt == VT_NULL && rightvt == VT_NULL)
5395 resultvt = VT_NULL;
5396 else if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
5397 rightvt == VT_DATE || rightvt == VT_DECIMAL))
5398 expected_error_num = DISP_E_TYPEMISMATCH;
5399 else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
5400 leftvt == VT_R4 || leftvt == VT_R8 ||
5401 leftvt == VT_CY || leftvt == VT_BOOL ||
5402 leftvt == VT_BSTR || leftvt == VT_I1 ||
5403 leftvt == VT_UI1 || leftvt == VT_UI2 ||
5404 leftvt == VT_UI4 || leftvt == VT_I8 ||
5405 leftvt == VT_UI8 || leftvt == VT_INT ||
5406 leftvt == VT_UINT || leftvt == VT_EMPTY ||
5407 leftvt == VT_NULL || leftvt == VT_DECIMAL ||
5408 leftvt == VT_DATE)
5409 &&
5410 (rightvt == VT_I2 || rightvt == VT_I4 ||
5411 rightvt == VT_R4 || rightvt == VT_R8 ||
5412 rightvt == VT_CY || rightvt == VT_BOOL ||
5413 rightvt == VT_BSTR || rightvt == VT_I1 ||
5414 rightvt == VT_UI1 || rightvt == VT_UI2 ||
5415 rightvt == VT_UI4 || rightvt == VT_I8 ||
5416 rightvt == VT_UI8 || rightvt == VT_INT ||
5417 rightvt == VT_UINT || rightvt == VT_EMPTY ||
5418 rightvt == VT_NULL || rightvt == VT_DECIMAL ||
5419 rightvt == VT_DATE))
5420 resultvt = VT_BSTR;
5421 else if (rightvt == VT_ERROR && leftvt < VT_VOID)
5422 expected_error_num = DISP_E_TYPEMISMATCH;
5423 else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
5424 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
5425 expected_error_num = DISP_E_TYPEMISMATCH;
5426 else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
5427 rightvt == VT_DECIMAL)
5428 expected_error_num = DISP_E_BADVARTYPE;
5429 else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
5430 expected_error_num = DISP_E_TYPEMISMATCH;
5431 else if (leftvt == VT_VARIANT)
5432 expected_error_num = DISP_E_TYPEMISMATCH;
5433 else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
5434 leftvt == VT_NULL || leftvt == VT_I2 ||
5435 leftvt == VT_I4 || leftvt == VT_R4 ||
5436 leftvt == VT_R8 || leftvt == VT_CY ||
5437 leftvt == VT_DATE || leftvt == VT_BSTR ||
5438 leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
5439 leftvt == VT_I1 || leftvt == VT_UI1 ||
5440 leftvt == VT_UI2 || leftvt == VT_UI4 ||
5441 leftvt == VT_I8 || leftvt == VT_UI8 ||
5442 leftvt == VT_INT || leftvt == VT_UINT
5443 ))
5444 expected_error_num = DISP_E_TYPEMISMATCH;
5445 else
5446 expected_error_num = DISP_E_BADVARTYPE;
5447
5448 V_VT(&left) = leftvt;
5449 V_VT(&right) = rightvt;
5450
5451 switch (leftvt) {
5452 case VT_BSTR:
5453 V_BSTR(&left) = SysAllocString(sz_empty); break;
5454 case VT_DATE:
5455 V_DATE(&left) = 0.0; break;
5456 case VT_DECIMAL:
5457 VarDecFromR8(0.0, &V_DECIMAL(&left)); break;
5458 default:
5459 V_I8(&left) = 0;
5460 }
5461
5462 switch (rightvt) {
5463 case VT_BSTR:
5464 V_BSTR(&right) = SysAllocString(sz_empty); break;
5465 case VT_DATE:
5466 V_DATE(&right) = 0.0; break;
5467 case VT_DECIMAL:
5468 VarDecFromR8(0.0, &V_DECIMAL(&right)); break;
5469 default:
5470 V_I8(&right) = 0;
5471 }
5472
5473 hres = pVarCat(&left, &right, &result);
5474
5475 /* Determine the error code for the vt combination */
5476 ok(hres == expected_error_num,
5477 "VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
5478 leftvt, rightvt, expected_error_num, hres);
5479
5480 /* Check types are correct */
5481 ok(V_VT(&result) == resultvt,
5482 "VarCat: %d, %d: expected vt %d, got vt %d\n",
5483 leftvt, rightvt, resultvt, V_VT(&result));
5484
5485 VariantClear(&left);
5486 VariantClear(&right);
5487 VariantClear(&result);
5488 }
5489 }
5490
5491 /* Running single comparison tests to compare outputs */
5492
5493 /* Test concat strings */
5494 V_VT(&left) = VT_BSTR;
5495 V_VT(&right) = VT_BSTR;
5496 V_VT(&expected) = VT_BSTR;
5497 V_BSTR(&left) = SysAllocString(sz12);
5498 V_BSTR(&right) = SysAllocString(sz34);
5499 V_BSTR(&expected) = SysAllocString(sz1234);
5500 hres = pVarCat(&left,&right,&result);
5501 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5502 if (pVarCmp)
5503 ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5504 "VarCat: VT_BSTR concat with VT_BSTR failed to return correct result\n");
5505
5506 VariantClear(&left);
5507 VariantClear(&right);
5508 VariantClear(&result);
5509
5510 /* Test if expression is VT_ERROR */
5511 V_VT(&left) = VT_ERROR;
5512 V_VT(&right) = VT_BSTR;
5513 V_BSTR(&right) = SysAllocString(sz1234);
5514 hres = pVarCat(&left,&right,&result);
5515 ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5516 ok(V_VT(&result) == VT_EMPTY,
5517 "VarCat: VT_ERROR concat with VT_BSTR should have returned VT_EMPTY\n");
5518
5519 VariantClear(&left);
5520 VariantClear(&right);
5521 VariantClear(&result);
5522
5523 V_VT(&left) = VT_BSTR;
5524 V_VT(&right) = VT_ERROR;
5525 V_BSTR(&left) = SysAllocString(sz1234);
5526 hres = pVarCat(&left,&right,&result);
5527 ok(hres == DISP_E_TYPEMISMATCH, "VarCat should have returned DISP_E_TYPEMISMATCH instead of 0x%08x\n", hres);
5528 ok(V_VT(&result) == VT_EMPTY,
5529 "VarCat: VT_BSTR concat with VT_ERROR should have returned VT_EMPTY\n");
5530
5531 VariantClear(&left);
5532 VariantClear(&right);
5533 VariantClear(&result);
5534 VariantClear(&expected);
5535
5536 /* Test combining boolean with number */
5537 V_VT(&left) = VT_INT;
5538 V_VT(&right) = VT_BOOL;
5539 V_VT(&expected) = VT_BSTR;
5540 V_INT(&left) = 12;
5541 V_BOOL(&right) = TRUE;
5542 V_BSTR(&expected) = SysAllocString(sz12_true);
5543 hres = pVarCat(&left,&right,&result);
5544 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5545 if (pVarCmp)
5546 {
5547 hres = pVarCmp(&result,&expected,lcid,0);
5548 ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5549 hres, variantstr(&result), variantstr(&expected));
5550 }
5551
5552 VariantClear(&left);
5553 VariantClear(&right);
5554 VariantClear(&result);
5555 VariantClear(&expected);
5556
5557 V_VT(&left) = VT_INT;
5558 V_VT(&right) = VT_BOOL;
5559 V_VT(&expected) = VT_BSTR;
5560 V_INT(&left) = 12;
5561 V_BOOL(&right) = FALSE;
5562 V_BSTR(&expected) = SysAllocString(sz12_false);
5563 hres = pVarCat(&left,&right,&result);
5564 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5565 if (pVarCmp)
5566 {
5567 hres = pVarCmp(&result,&expected,lcid,0);
5568 ok(hres == VARCMP_EQ, "Expected VARCMP_EQ, got %08x for %s, %s\n",
5569 hres, variantstr(&result), variantstr(&expected));
5570 }
5571
5572 VariantClear(&left);
5573 VariantClear(&right);
5574 VariantClear(&result);
5575 VariantClear(&expected);
5576
5577 /* Test when both expressions are numeric */
5578 V_VT(&left) = VT_INT;
5579 V_VT(&right) = VT_INT;
5580 V_VT(&expected) = VT_BSTR;
5581 V_INT(&left) = 12;
5582 V_INT(&right) = 34;
5583 V_BSTR(&expected) = SysAllocString(sz1234);
5584 hres = pVarCat(&left,&right,&result);
5585 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5586 if (pVarCmp)
5587 ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5588 "VarCat: NUMBER concat with NUMBER returned incorrect result\n");
5589
5590 VariantClear(&left);
5591 VariantClear(&right);
5592 VariantClear(&result);
5593
5594 /* Test if one expression is numeric and the other is a string */
5595 V_VT(&left) = VT_INT;
5596 V_VT(&right) = VT_BSTR;
5597 V_INT(&left) = 12;
5598 V_BSTR(&right) = SysAllocString(sz34);
5599 hres = pVarCat(&left,&right,&result);
5600 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5601 if (pVarCmp)
5602 ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5603 "VarCat: NUMBER concat with VT_BSTR, incorrect result\n");
5604
5605 VariantClear(&left);
5606 VariantClear(&right);
5607 VariantClear(&result);
5608
5609 V_VT(&left) = VT_BSTR;
5610 V_VT(&right) = VT_INT;
5611 V_BSTR(&left) = SysAllocString(sz12);
5612 V_INT(&right) = 34;
5613 hres = pVarCat(&left,&right,&result);
5614 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5615 if (pVarCmp)
5616 ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ,
5617 "VarCat: VT_BSTR concat with NUMBER, incorrect result\n");
5618
5619 VariantClear(&left);
5620 VariantClear(&right);
5621 VariantClear(&result);
5622 VariantClear(&expected);
5623
5624 /* Test concat dates with strings */
5625 V_VT(&left) = VT_BSTR;
5626 V_VT(&right) = VT_DATE;
5627 V_VT(&expected) = VT_BSTR;
5628 V_VT(&expected_broken) = VT_BSTR;
5629 V_BSTR(&left) = SysAllocString(sz12);
5630 V_DATE(&right) = 29494.0;
5631 V_BSTR(&expected)= SysAllocString(sz12_date);
5632 V_BSTR(&expected_broken)= SysAllocString(sz12_date_broken);
5633 hres = pVarCat(&left,&right,&result);
5634 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5635 if (pVarCmp)
5636 ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5637 broken(pVarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5638 "VarCat: VT_BSTR concat with VT_DATE returned incorrect result\n");
5639
5640 VariantClear(&left);
5641 VariantClear(&right);
5642 VariantClear(&result);
5643 VariantClear(&expected);
5644 VariantClear(&expected_broken);
5645
5646 V_VT(&left) = VT_DATE;
5647 V_VT(&right) = VT_BSTR;
5648 V_VT(&expected) = VT_BSTR;
5649 V_VT(&expected_broken) = VT_BSTR;
5650 V_DATE(&left) = 29494.0;
5651 V_BSTR(&right) = SysAllocString(sz12);
5652 V_BSTR(&expected)= SysAllocString(date_sz12);
5653 V_BSTR(&expected_broken)= SysAllocString(date_sz12_broken);
5654 hres = pVarCat(&left,&right,&result);
5655 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5656 if (pVarCmp)
5657 ok(pVarCmp(&result,&expected,lcid,0) == VARCMP_EQ ||
5658 broken(pVarCmp(&result,&expected_broken,lcid,0) == VARCMP_EQ), /* Some W98 and NT4 (intermittent) */
5659 "VarCat: VT_DATE concat with VT_BSTR returned incorrect result\n");
5660
5661 VariantClear(&left);
5662 VariantClear(&right);
5663 VariantClear(&result);
5664 VariantClear(&expected);
5665 VariantClear(&expected_broken);
5666
5667 /* Test of both expressions are empty */
5668 V_VT(&left) = VT_BSTR;
5669 V_VT(&right) = VT_BSTR;
5670 V_VT(&expected) = VT_BSTR;
5671 V_BSTR(&left) = SysAllocString(sz_empty);
5672 V_BSTR(&right) = SysAllocString(sz_empty);
5673 V_BSTR(&expected)= SysAllocString(sz_empty);
5674 hres = pVarCat(&left,&right,&result);
5675 ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
5676 if (pVarCmp)
5677 ok(pVarCmp(&result,&left,lcid,0) == VARCMP_EQ,
5678 "VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
5679
5680 /* Restore original date format settings */
5681 SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
5682
5683 VariantClear(&left);
5684 VariantClear(&right);
5685 VariantClear(&result);
5686 VariantClear(&expected);
5687
5688 /* Test boolean conversion */
5689 V_VT(&left) = VT_BOOL;
5690 V_BOOL(&left) = VARIANT_TRUE;
5691 V_VT(&right) = VT_BSTR;
5692 V_BSTR(&right) = SysAllocStringLen(NULL,0);
5693 hres = pVarCat(&left, &right, &result);
5694 ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5695 if(!strcmp_wa(V_BSTR(&result), "True")) {
5696 V_VT(&right) = VT_BOOL;
5697 V_BOOL(&right) = 100;
5698 hres = pVarCat(&left, &right, &result);
5699 ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5700 test_bstr_var(&result, "TrueTrue");
5701 VariantClear(&result);
5702
5703 V_BOOL(&right) = VARIANT_FALSE;
5704 hres = pVarCat(&left, &right, &result);
5705 ok(hres == S_OK, "VarCat failed: %08x\n", hres);
5706 test_bstr_var(&result, "TrueFalse");
5707 VariantClear(&result);
5708 }else {
5709 skip("Got %s as True, assuming non-English locale\n", wine_dbgstr_w(V_BSTR(&result)));
5710 }
5711 }
5712
5713 static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);
5714
5715 #define VARAND(vt1,val1,vt2,val2,rvt,rval) \
5716 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
5717 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
5718 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
5719 test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5720
5721 #define VARANDCY(vt1,val1,val2,rvt,rval) \
5722 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
5723 V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
5724 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
5725 test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
5726
5727 /* Skip any type that is not defined or produces an error for every case */
5728 #define SKIPTESTAND(a) \
5729 if (a == VT_ERROR || a == VT_VARIANT || \
5730 a == VT_DISPATCH || a == VT_UNKNOWN || \
5731 a > VT_UINT || a == 15 /*not defined*/) \
5732 continue
5733
5734 static void test_VarAnd(void)
5735 {
5736 static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
5737 static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
5738 VARIANT left, right, exp, result;
5739 BSTR false_str, true_str;
5740 VARTYPE i;
5741 HRESULT hres;
5742
5743 true_str = SysAllocString(szTrue);
5744 false_str = SysAllocString(szFalse);
5745
5746 CHECKPTR(VarAnd);
5747
5748 /* Test all possible flag/vt combinations & the resulting vt type */
5749 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
5750 {
5751 VARTYPE leftvt, rightvt, resvt;
5752
5753 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
5754 {
5755 SKIPTESTAND(leftvt);
5756
5757 /* Check if we need/have support for I8 and/or UI8 */
5758 if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5759 continue;
5760
5761 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
5762 {
5763 BOOL bFail = FALSE;
5764 SKIPTESTAND(rightvt);
5765
5766 /* Check if we need/have support for I8 and/or UI8 */
5767 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
5768 continue;
5769
5770 memset(&left, 0, sizeof(left));
5771 memset(&right, 0, sizeof(right));
5772 V_VT(&left) = leftvt | ExtraFlags[i];
5773 V_VT(&right) = rightvt | ExtraFlags[i];
5774 V_VT(&result) = VT_EMPTY;
5775 resvt = VT_EMPTY;
5776 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
5777 V_BSTR(&left) = true_str;
5778 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
5779 V_BSTR(&right) = true_str;
5780
5781 /* Native VarAnd always returns an error when using extra
5782 * flags or if the variant combination is I8 and INT.
5783 */
5784 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5785 (leftvt == VT_INT && rightvt == VT_I8) ||
5786 ExtraFlags[i] != 0)
5787 bFail = TRUE;
5788
5789 /* Determine return type */
5790 else if (leftvt == VT_I8 || rightvt == VT_I8)
5791 resvt = VT_I8;
5792 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5793 leftvt == VT_UINT || rightvt == VT_UINT ||
5794 leftvt == VT_INT || rightvt == VT_INT ||
5795 leftvt == VT_UINT || rightvt == VT_UINT ||
5796 leftvt == VT_R4 || rightvt == VT_R4 ||
5797 leftvt == VT_R8 || rightvt == VT_R8 ||
5798 leftvt == VT_CY || rightvt == VT_CY ||
5799 leftvt == VT_DATE || rightvt == VT_DATE ||
5800 leftvt == VT_I1 || rightvt == VT_I1 ||
5801 leftvt == VT_UI2 || rightvt == VT_UI2 ||
5802 leftvt == VT_UI4 || rightvt == VT_UI4 ||
5803 leftvt == VT_UI8 || rightvt == VT_UI8 ||
5804 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
5805 resvt = VT_I4;
5806 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
5807 leftvt == VT_I2 || rightvt == VT_I2 ||
5808 leftvt == VT_EMPTY || rightvt == VT_EMPTY)
5809 if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
5810 (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5811 (leftvt == VT_UI1 && rightvt == VT_UI1))
5812 resvt = VT_UI1;
5813 else
5814 resvt = VT_I2;
5815 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5816 (leftvt == VT_BSTR && rightvt == VT_BSTR))
5817 resvt = VT_BOOL;
5818 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
5819 leftvt == VT_BSTR || rightvt == VT_BSTR)
5820 resvt = VT_NULL;
5821 else
5822 bFail = TRUE;
5823
5824 hres = pVarAnd(&left, &right, &result);
5825
5826 /* Check expected HRESULT and if result variant type is correct */
5827 if (bFail)
5828 ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
5829 "VarAnd: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
5830 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
5831 vtstr(V_VT(&result)), hres);
5832 else
5833 ok (hres == S_OK && resvt == V_VT(&result),
5834 "VarAnd: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
5835 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
5836 S_OK, vtstr(V_VT(&result)), hres);
5837 }
5838 }
5839 }
5840
5841 /*
5842 * Test returned values. Since we know the returned type is correct
5843 * and that we handle all combinations of invalid types, just check
5844 * that good type combinations produce the desired value.
5845 * FIXME: Test VT_DECIMAL
5846 */
5847 VARAND(EMPTY,0,EMPTY,0,I2,0);
5848 VARAND(EMPTY,1,EMPTY,0,I2,0);
5849 VARAND(EMPTY,1,EMPTY,1,I2,0);
5850 VARAND(EMPTY,0,NULL,0,I2,0);
5851 VARAND(EMPTY,1,NULL,0,I2,0);
5852 VARAND(EMPTY,1,NULL,1,I2,0);
5853 VARAND(EMPTY,0,I1,0,I4,0);
5854 VARAND(EMPTY,0,I1,1,I4,0);
5855 VARAND(EMPTY,1,I1,1,I4,0);
5856 VARAND(EMPTY,0,UI1,0,I2,0);
5857 VARAND(EMPTY,0,UI1,1,I2,0);
5858 VARAND(EMPTY,1,UI1,1,I2,0);
5859 VARAND(EMPTY,0,I2,0,I2,0);
5860 VARAND(EMPTY,0,I2,1,I2,0);
5861 VARAND(EMPTY,1,I2,1,I2,0);
5862 VARAND(EMPTY,0,UI2,0,I4,0);
5863 VARAND(EMPTY,0,UI2,1,I4,0);
5864 VARAND(EMPTY,1,UI2,1,I4,0);
5865 VARAND(EMPTY,0,I4,0,I4,0);
5866 VARAND(EMPTY,0,I4,1,I4,0);
5867 VARAND(EMPTY,1,I4,1,I4,0);
5868 VARAND(EMPTY,0,UI4,0,I4,0);
5869 VARAND(EMPTY,0,UI4,1,I4,0);
5870 VARAND(EMPTY,1,UI4,1,I4,0);
5871 if (HAVE_OLEAUT32_I8)
5872 {
5873 VARAND(EMPTY,0,I8,0,I8,0);
5874 VARAND(EMPTY,0,I8,1,I8,0);
5875 VARAND(EMPTY,1,I8,1,I8,0);
5876 VARAND(EMPTY,0,UI8,0,I4,0);
5877 VARAND(EMPTY,0,UI8,1,I4,0);
5878 VARAND(EMPTY,1,UI8,1,I4,0);
5879 }
5880 VARAND(EMPTY,0,INT,0,I4,0);
5881 VARAND(EMPTY,0,INT,1,I4,0);
5882 VARAND(EMPTY,1,INT,1,I4,0);
5883 VARAND(EMPTY,0,UINT,0,I4,0);
5884 VARAND(EMPTY,0,UINT,1,I4,0);
5885 VARAND(EMPTY,1,UINT,1,I4,0);
5886 VARAND(EMPTY,0,BOOL,0,I2,0);
5887 VARAND(EMPTY,0,BOOL,1,I2,0);
5888 VARAND(EMPTY,1,BOOL,1,I2,0);
5889 VARAND(EMPTY,0,R4,0,I4,0);
5890 VARAND(EMPTY,0,R4,1,I4,0);
5891 VARAND(EMPTY,1,R4,1,I4,0);
5892 VARAND(EMPTY,0,R8,0,I4,0);
5893 VARAND(EMPTY,0,R8,1,I4,0);
5894 VARAND(EMPTY,1,R8,1,I4,0);
5895 VARAND(EMPTY,0,BSTR,false_str,I2,0);
5896 VARAND(EMPTY,0,BSTR,true_str,I2,0);
5897 VARANDCY(EMPTY,0,10000,I4,0);
5898
5899 /* NULL OR 0 = NULL. NULL OR n = n */
5900 VARAND(NULL,0,NULL,0,NULL,0);
5901 VARAND(NULL,1,NULL,0,NULL,0);
5902 VARAND(NULL,0,I1,0,I4,0);
5903 VARAND(NULL,0,I1,1,NULL,0);
5904 VARAND(NULL,0,UI1,0,UI1,0);
5905 VARAND(NULL,0,UI1,1,NULL,0);
5906 VARAND(NULL,0,I2,0,I2,0);
5907 VARAND(NULL,0,I2,1,NULL,0);
5908 VARAND(NULL,0,UI2,0,I4,0);
5909 VARAND(NULL,0,UI2,1,NULL,0);
5910 VARAND(NULL,0,I4,0,I4,0);
5911 VARAND(NULL,0,I4,1,NULL,0);
5912 VARAND(NULL,0,UI4,0,I4,0);
5913 VARAND(NULL,0,UI4,1,NULL,0);
5914 if (HAVE_OLEAUT32_I8)
5915 {
5916 VARAND(NULL,0,I8,0,I8,0);
5917 VARAND(NULL,0,I8,1,NULL,0);
5918 VARAND(NULL,0,UI8,0,I4,0);
5919 VARAND(NULL,0,UI8,1,NULL,0);
5920 }
5921 VARAND(NULL,0,INT,0,I4,0);
5922 VARAND(NULL,0,INT,1,NULL,0);
5923 VARAND(NULL,0,UINT,0,I4,0);
5924 VARAND(NULL,0,UINT,1,NULL,0);
5925 VARAND(NULL,0,BOOL,0,BOOL,0);
5926 VARAND(NULL,0,BOOL,1,NULL,0);
5927 VARAND(NULL,0,R4,0,I4,0);
5928 VARAND(NULL,0,R4,1,NULL,0);
5929 VARAND(NULL,0,R8,0,I4,0);
5930 VARAND(NULL,0,R8,1,NULL,0);
5931 VARAND(NULL,0,BSTR,false_str,BOOL,0);
5932 VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
5933 VARANDCY(NULL,0,10000,NULL,0);
5934 VARANDCY(NULL,0,0,I4,0);
5935 VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
5936 VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5937 VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
5938 VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
5939
5940 /* Assume x,y & y,x are the same from now on to reduce the number of tests */
5941 VARAND(BOOL,VARIANT_TRUE,I1,-1,I4,-1);
5942 VARAND(BOOL,VARIANT_TRUE,I1,0,I4,0);
5943 VARAND(BOOL,VARIANT_FALSE,I1,0,I4,0);
5944 VARAND(BOOL,VARIANT_TRUE,UI1,255,I2,255);
5945 VARAND(BOOL,VARIANT_TRUE,UI1,0,I2,0);
5946 VARAND(BOOL,VARIANT_FALSE,UI1,0,I2,0);
5947 VARAND(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
5948 VARAND(BOOL,VARIANT_TRUE,I2,0,I2,0);
5949 VARAND(BOOL,VARIANT_FALSE,I2,0,I2,0);
5950 VARAND(BOOL,VARIANT_TRUE,UI2,65535,I4,65535);
5951 VARAND(BOOL,VARIANT_TRUE,UI2,0,I4,0);
5952 VARAND(BOOL,VARIANT_FALSE,UI2,0,I4,0);
5953 VARAND(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
5954 VARAND(BOOL,VARIANT_TRUE,I4,0,I4,0);
5955 VARAND(BOOL,VARIANT_FALSE,I4,0,I4,0);
5956 VARAND(BOOL,VARIANT_TRUE,UI4,0xffffffff,I4,-1);
5957 VARAND(BOOL,VARIANT_TRUE,UI4,0,I4,0);
5958 VARAND(BOOL,VARIANT_FALSE,UI4,0,I4,0);
5959 VARAND(BOOL,VARIANT_TRUE,R4,-1,I4,-1);
5960 VARAND(BOOL,VARIANT_TRUE,R4,0,I4,0);
5961 VARAND(BOOL,VARIANT_FALSE,R4,0,I4,0);
5962 VARAND(BOOL,VARIANT_TRUE,R8,-1,I4,-1);
5963 VARAND(BOOL,VARIANT_TRUE,R8,0,I4,0);
5964 VARAND(BOOL,VARIANT_FALSE,R8,0,I4,0);
5965 VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
5966 VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
5967 VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
5968 if (HAVE_OLEAUT32_I8)
5969 {
5970 VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
5971 VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
5972 VARAND(BOOL,VARIANT_FALSE,I8,0,I8,0);
5973 VARAND(BOOL,VARIANT_TRUE,UI8,0,I4,0);
5974 VARAND(BOOL,VARIANT_FALSE,UI8,0,I4,0);
5975 }
5976 VARAND(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
5977 VARAND(BOOL,VARIANT_TRUE,INT,0,I4,0);
5978 VARAND(BOOL,VARIANT_FALSE,INT,0,I4,0);
5979 VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
5980 VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
5981 VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
5982 VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
5983 VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
5984 VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
5985 VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
5986 VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
5987 VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
5988 VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
5989 VARAND(I1,-1,I1,-1,I4,-1);
5990 VARAND(I1,-1,I1,0,I4,0);
5991 VARAND(I1,0,I1,0,I4,0);
5992 VARAND(I1,-1,UI1,255,I4,255);
5993 VARAND(I1,-1,UI1,0,I4,0);
5994 VARAND(I1,0,UI1,0,I4,0);
5995 VARAND(I1,-1,I2,-1,I4,-1);
5996 VARAND(I1,-1,I2,0,I4,0);
5997 VARAND(I1,0,I2,0,I4,0);
5998 VARAND(I1,-1,UI2,65535,I4,65535);
5999 VARAND(I1,-1,UI2,0,I4,0);
6000 VARAND(I1,0,UI2,0,I4,0);
6001 VARAND(I1,-1,I4,-1,I4,-1);
6002 VARAND(I1,-1,I4,0,I4,0);
6003 VARAND(I1,0,I4,0,I4,0);
6004 VARAND(I1,-1,UI4,0xffffffff,I4,-1);
6005 VARAND(I1,-1,UI4,0,I4,0);
6006 VARAND(I1,0,UI4,0,I4,0);
6007 VARAND(I1,-1,R4,-1,I4,-1);
6008 VARAND(I1,-1,R4,0,I4,0);
6009 VARAND(I1,0,R4,0,I4,0);
6010 VARAND(I1,-1,R8,-1,I4,-1);
6011 VARAND(I1,-1,R8,0,I4,0);
6012 VARAND(I1,0,R8,0,I4,0);
6013 VARAND(I1,-1,DATE,-1,I4,-1);
6014 VARAND(I1,-1,DATE,0,I4,0);
6015 VARAND(I1,0,DATE,0,I4,0);
6016 if (HAVE_OLEAUT32_I8)
6017 {
6018 VARAND(I1,-1,I8,-1,I8,-1);
6019 VARAND(I1,-1,I8,0,I8,0);
6020 VARAND(I1,0,I8,0,I8,0);
6021 VARAND(I1,-1,UI8,0,I4,0);
6022 VARAND(I1,0,UI8,0,I4,0);
6023 }
6024 VARAND(I1,-1,INT,-1,I4,-1);
6025 VARAND(I1,-1,INT,0,I4,0);
6026 VARAND(I1,0,INT,0,I4,0);
6027 VARAND(I1,-1,UINT,0xffffffff,I4,-1);
6028 VARAND(I1,-1,UINT,0,I4,0);
6029 VARAND(I1,0,UINT,0,I4,0);
6030 VARAND(I1,0,BSTR,false_str,I4,0);
6031 VARAND(I1,-1,BSTR,false_str,I4,0);
6032 VARAND(I1,0,BSTR,true_str,I4,0);
6033 VARAND(I1,-1,BSTR,true_str,I4,-1);
6034 VARANDCY(I1,-1,10000,I4,1);
6035 VARANDCY(I1,-1,0,I4,0);
6036 VARANDCY(I1,0,0,I4,0);
6037
6038 VARAND(UI1,255,UI1,255,UI1,255);
6039 VARAND(UI1,255,UI1,0,UI1,0);
6040 VARAND(UI1,0,UI1,0,UI1,0);
6041 VARAND(UI1,255,I2,-1,I2,255);
6042 VARAND(UI1,255,I2,0,I2,0);
6043 VARAND(UI1,0,I2,0,I2,0);
6044 VARAND(UI1,255,UI2,65535,I4,255);
6045 VARAND(UI1,255,UI2,0,I4,0);
6046 VARAND(UI1,0,UI2,0,I4,0);
6047 VARAND(UI1,255,I4,-1,I4,255);
6048 VARAND(UI1,255,I4,0,I4,0);
6049 VARAND(UI1,0,I4,0,I4,0);
6050 VARAND(UI1,255,UI4,0xffffffff,I4,255);
6051 VARAND(UI1,255,UI4,0,I4,0);
6052 VARAND(UI1,0,UI4,0,I4,0);
6053 VARAND(UI1,255,R4,-1,I4,255);
6054 VARAND(UI1,255,R4,0,I4,0);
6055 VARAND(UI1,0,R4,0,I4,0);
6056 VARAND(UI1,255,R8,-1,I4,255);
6057 VARAND(UI1,255,R8,0,I4,0);
6058 VARAND(UI1,0,R8,0,I4,0);
6059 VARAND(UI1,255,DATE,-1,I4,255);
6060 VARAND(UI1,255,DATE,0,I4,0);
6061 VARAND(UI1,0,DATE,0,I4,0);
6062 if (HAVE_OLEAUT32_I8)
6063 {
6064 VARAND(UI1,255,I8,-1,I8,255);
6065 VARAND(UI1,255,I8,0,I8,0);
6066 VARAND(UI1,0,I8,0,I8,0);
6067 VARAND(UI1,255,UI8,0,I4,0);
6068 VARAND(UI1,0,UI8,0,I4,0);
6069 }
6070 VARAND(UI1,255,INT,-1,I4,255);
6071 VARAND(UI1,255,INT,0,I4,0);
6072 VARAND(UI1,0,INT,0,I4,0);
6073 VARAND(UI1,255,UINT,0xffffffff,I4,255);
6074 VARAND(UI1,255,UINT,0,I4,0);
6075 VARAND(UI1,0,UINT,0,I4,0);
6076 VARAND(UI1,0,BSTR,false_str,I2,0);
6077 VARAND(UI1,255,BSTR,false_str,I2,0);
6078 VARAND(UI1,0,BSTR,true_str,I2,0);
6079 VARAND(UI1,255,BSTR,true_str,I2,255);
6080 VARANDCY(UI1,255,10000,I4,1);
6081 VARANDCY(UI1,255,0,I4,0);
6082 VARANDCY(UI1,0,0,I4,0);
6083
6084 VARAND(I2,-1,I2,-1,I2,-1);
6085 VARAND(I2,-1,I2,0,I2,0);
6086 VARAND(I2,0,I2,0,I2,0);
6087 VARAND(I2,-1,UI2,65535,I4,65535);
6088 VARAND(I2,-1,UI2,0,I4,0);
6089 VARAND(I2,0,UI2,0,I4,0);
6090 VARAND(I2,-1,I4,-1,I4,-1);
6091 VARAND(I2,-1,I4,0,I4,0);
6092 VARAND(I2,0,I4,0,I4,0);
6093 VARAND(I2,-1,UI4,0xffffffff,I4,-1);
6094 VARAND(I2,-1,UI4,0,I4,0);
6095 VARAND(I2,0,UI4,0,I4,0);
6096 VARAND(I2,-1,R4,-1,I4,-1);
6097 VARAND(I2,-1,R4,0,I4,0);
6098 VARAND(I2,0,R4,0,I4,0);
6099 VARAND(I2,-1,R8,-1,I4,-1);
6100 VARAND(I2,-1,R8,0,I4,0);
6101 VARAND(I2,0,R8,0,I4,0);
6102 VARAND(I2,-1,DATE,-1,I4,-1);
6103 VARAND(I2,-1,DATE,0,I4,0);
6104 VARAND(I2,0,DATE,0,I4,0);
6105 if (HAVE_OLEAUT32_I8)
6106 {
6107 VARAND(I2,-1,I8,-1,I8,-1);
6108 VARAND(I2,-1,I8,0,I8,0);
6109 VARAND(I2,0,I8,0,I8,0);
6110 VARAND(I2,-1,UI8,0,I4,0);
6111 VARAND(I2,0,UI8,0,I4,0);
6112 }
6113 VARAND(I2,-1,INT,-1,I4,-1);
6114 VARAND(I2,-1,INT,0,I4,0);
6115 VARAND(I2,0,INT,0,I4,0);
6116 VARAND(I2,-1,UINT,0xffffffff,I4,-1);
6117 VARAND(I2,-1,UINT,0,I4,0);
6118 VARAND(I2,0,UINT,0,I4,0);
6119 VARAND(I2,0,BSTR,false_str,I2,0);
6120 VARAND(I2,-1,BSTR,false_str,I2,0);
6121 VARAND(I2,0,BSTR,true_str,I2,0);
6122 VARAND(I2,-1,BSTR,true_str,I2,-1);
6123 VARANDCY(I2,-1,10000,I4,1);
6124 VARANDCY(I2,-1,0,I4,0);
6125 VARANDCY(I2,0,0,I4,0);
6126
6127 VARAND(UI2,65535,UI2,65535,I4,65535);
6128 VARAND(UI2,65535,UI2,0,I4,0);
6129 VARAND(UI2,0,UI2,0,I4,0);
6130 VARAND(UI2,65535,I4,-1,I4,65535);
6131 VARAND(UI2,65535,I4,0,I4,0);
6132 VARAND(UI2,0,I4,0,I4,0);
6133 VARAND(UI2,65535,UI4,0xffffffff,I4,65535);
6134 VARAND(UI2,65535,UI4,0,I4,0);
6135 VARAND(UI2,0,UI4,0,I4,0);
6136 VARAND(UI2,65535,R4,-1,I4,65535);
6137 VARAND(UI2,65535,R4,0,I4,0);
6138 VARAND(UI2,0,R4,0,I4,0);
6139 VARAND(UI2,65535,R8,-1,I4,65535);
6140 VARAND(UI2,65535,R8,0,I4,0);
6141 VARAND(UI2,0,R8,0,I4,0);
6142 VARAND(UI2,65535,DATE,-1,I4,65535);
6143 VARAND(UI2,65535,DATE,0,I4,0);
6144 VARAND(UI2,0,DATE,0,I4,0);
6145 if (HAVE_OLEAUT32_I8)
6146 {
6147 VARAND(UI2,65535,I8,-1,I8,65535);
6148 VARAND(UI2,65535,I8,0,I8,0);
6149 VARAND(UI2,0,I8,0,I8,0);
6150 VARAND(UI2,65535,UI8,0,I4,0);
6151 VARAND(UI2,0,UI8,0,I4,0);
6152 }
6153 VARAND(UI2,65535,INT,-1,I4,65535);
6154 VARAND(UI2,65535,INT,0,I4,0);
6155 VARAND(UI2,0,INT,0,I4,0);
6156 VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
6157 VARAND(UI2,65535,UINT,0,I4,0);
6158 VARAND(UI2,0,UINT,0,I4,0);
6159 VARAND(UI2,0,BSTR,false_str,I4,0);
6160 VARAND(UI2,65535,BSTR,false_str,I4,0);
6161 VARAND(UI2,0,BSTR,true_str,I4,0);
6162 VARAND(UI2,65535,BSTR,true_str,I4,65535);
6163 VARANDCY(UI2,65535,10000,I4,1);
6164 VARANDCY(UI2,65535,0,I4,0);
6165 VARANDCY(UI2,0,0,I4,0);
6166
6167 VARAND(I4,-1,I4,-1,I4,-1);
6168 VARAND(I4,-1,I4,0,I4,0);
6169 VARAND(I4,0,I4,0,I4,0);
6170 VARAND(I4,-1,UI4,0xffffffff,I4,-1);
6171 VARAND(I4,-1,UI4,0,I4,0);
6172 VARAND(I4,0,UI4,0,I4,0);
6173 VARAND(I4,-1,R4,-1,I4,-1);
6174 VARAND(I4,-1,R4,0,I4,0);
6175 VARAND(I4,0,R4,0,I4,0);
6176 VARAND(I4,-1,R8,-1,I4,-1);
6177 VARAND(I4,-1,R8,0,I4,0);
6178 VARAND(I4,0,R8,0,I4,0);
6179 VARAND(I4,-1,DATE,-1,I4,-1);
6180 VARAND(I4,-1,DATE,0,I4,0);
6181 VARAND(I4,0,DATE,0,I4,0);
6182 if (HAVE_OLEAUT32_I8)
6183 {
6184 VARAND(I4,-1,I8,-1,I8,-1);
6185 VARAND(I4,-1,I8,0,I8,0);
6186 VARAND(I4,0,I8,0,I8,0);
6187 VARAND(I4,-1,UI8,0,I4,0);
6188 VARAND(I4,0,UI8,0,I4,0);
6189 }
6190 VARAND(I4,-1,INT,-1,I4,-1);
6191 VARAND(I4,-1,INT,0,I4,0);
6192 VARAND(I4,0,INT,0,I4,0);
6193 VARAND(I4,-1,UINT,0xffffffff,I4,-1);
6194 VARAND(I4,-1,UINT,0,I4,0);
6195 VARAND(I4,0,UINT,0,I4,0);
6196 VARAND(I4,0,BSTR,false_str,I4,0);
6197 VARAND(I4,-1,BSTR,false_str,I4,0);
6198 VARAND(I4,0,BSTR,true_str,I4,0);
6199 VARAND(I4,-1,BSTR,true_str,I4,-1);
6200 VARANDCY(I4,-1,10000,I4,1);
6201 VARANDCY(I4,-1,0,I4,0);
6202 VARANDCY(I4,0,0,I4,0);
6203
6204 VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
6205 VARAND(UI4,0xffffffff,UI4,0,I4,0);
6206 VARAND(UI4,0,UI4,0,I4,0);
6207 VARAND(UI4,0xffffffff,R4,-1,I4,-1);
6208 VARAND(UI4,0xffffffff,R4,0,I4,0);
6209 VARAND(UI4,0,R4,0,I4,0);
6210 VARAND(UI4,0xffffffff,R8,-1,I4,-1);
6211 VARAND(UI4,0xffffffff,R8,0,I4,0);
6212 VARAND(UI4,0,R8,0,I4,0);
6213 VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
6214 VARAND(UI4,0xffffffff,DATE,0,I4,0);
6215 VARAND(UI4,0,DATE,0,I4,0);
6216 if (HAVE_OLEAUT32_I8)
6217 {
6218 VARAND(UI4,0xffffffff,I8,0,I8,0);
6219 VARAND(UI4,0,I8,0,I8,0);
6220 VARAND(UI4,0xffffffff,UI8,0,I4,0);
6221 VARAND(UI4,0,UI8,0,I4,0);
6222 }
6223 VARAND(UI4,0xffffffff,INT,-1,I4,-1);
6224 VARAND(UI4,0xffffffff,INT,0,I4,0);
6225 VARAND(UI4,0,INT,0,I4,0);
6226 VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
6227 VARAND(UI4,0xffffffff,UINT,0,I4,0);
6228 VARAND(UI4,0,UINT,0,I4,0);
6229 VARAND(UI4,0,BSTR,false_str,I4,0);
6230 VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
6231 VARAND(UI4,0,BSTR,true_str,I4,0);
6232 VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
6233 VARANDCY(UI4,0xffffffff,10000,I4,1);
6234 VARANDCY(UI4,0xffffffff,0,I4,0);
6235 VARANDCY(UI4,0,0,I4,0);
6236
6237 VARAND(R4,-1,R4,-1,I4,-1);
6238 VARAND(R4,-1,R4,0,I4,0);
6239 VARAND(R4,0,R4,0,I4,0);
6240 VARAND(R4,-1,R8,-1,I4,-1);
6241 VARAND(R4,-1,R8,0,I4,0);
6242 VARAND(R4,0,R8,0,I4,0);
6243 VARAND(R4,-1,DATE,-1,I4,-1);
6244 VARAND(R4,-1,DATE,0,I4,0);
6245 VARAND(R4,0,DATE,0,I4,0);
6246 if (HAVE_OLEAUT32_I8)
6247 {
6248 VARAND(R4,-1,I8,-1,I8,-1);
6249 VARAND(R4,-1,I8,0,I8,0);
6250 VARAND(R4,0,I8,0,I8,0);
6251 VARAND(R4,-1,UI8,0,I4,0);
6252 VARAND(R4,0,UI8,0,I4,0);
6253 }
6254 VARAND(R4,-1,INT,-1,I4,-1);
6255 VARAND(R4,-1,INT,0,I4,0);
6256 VARAND(R4,0,INT,0,I4,0);
6257 VARAND(R4,-1,UINT,0xffffffff,I4,-1);
6258 VARAND(R4,-1,UINT,0,I4,0);
6259 VARAND(R4,0,UINT,0,I4,0);
6260 VARAND(R4,0,BSTR,false_str,I4,0);
6261 VARAND(R4,-1,BSTR,false_str,I4,0);
6262 VARAND(R4,0,BSTR,true_str,I4,0);
6263 VARAND(R4,-1,BSTR,true_str,I4,-1);
6264 VARANDCY(R4,-1,10000,I4,1);
6265 VARANDCY(R4,-1,0,I4,0);
6266 VARANDCY(R4,0,0,I4,0);
6267
6268 VARAND(R8,-1,R8,-1,I4,-1);
6269 VARAND(R8,-1,R8,0,I4,0);
6270 VARAND(R8,0,R8,0,I4,0);
6271 VARAND(R8,-1,DATE,-1,I4,-1);
6272 VARAND(R8,-1,DATE,0,I4,0);
6273 VARAND(R8,0,DATE,0,I4,0);
6274 if (HAVE_OLEAUT32_I8)
6275 {
6276 VARAND(R8,-1,I8,-1,I8,-1);
6277 VARAND(R8,-1,I8,0,I8,0);
6278 VARAND(R8,0,I8,0,I8,0);
6279 VARAND(R8,-1,UI8,0,I4,0);
6280 VARAND(R8,0,UI8,0,I4,0);
6281 }
6282 VARAND(R8,-1,INT,-1,I4,-1);
6283 VARAND(R8,-1,INT,0,I4,0);
6284 VARAND(R8,0,INT,0,I4,0);
6285 VARAND(R8,-1,UINT,0xffffffff,I4,-1);
6286 VARAND(R8,-1,UINT,0,I4,0);
6287 VARAND(R8,0,UINT,0,I4,0);
6288 VARAND(R8,0,BSTR,false_str,I4,0);
6289 VARAND(R8,-1,BSTR,false_str,I4,0);
6290 VARAND(R8,0,BSTR,true_str,I4,0);
6291 VARAND(R8,-1,BSTR,true_str,I4,-1);
6292 VARANDCY(R8,-1,10000,I4,1);
6293 VARANDCY(R8,-1,0,I4,0);
6294 VARANDCY(R8,0,0,I4,0);
6295
6296 VARAND(DATE,-1,DATE,-1,I4,-1);
6297 VARAND(DATE,-1,DATE,0,I4,0);
6298 VARAND(DATE,0,DATE,0,I4,0);
6299 if (HAVE_OLEAUT32_I8)
6300 {
6301 VARAND(DATE,-1,I8,-1,I8,-1);
6302 VARAND(DATE,-1,I8,0,I8,0);
6303 VARAND(DATE,0,I8,0,I8,0);
6304 VARAND(DATE,-1,UI8,0,I4,0);
6305 VARAND(DATE,0,UI8,0,I4,0);
6306 }
6307 VARAND(DATE,-1,INT,-1,I4,-1);
6308 VARAND(DATE,-1,INT,0,I4,0);
6309 VARAND(DATE,0,INT,0,I4,0);
6310 VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
6311 VARAND(DATE,-1,UINT,0,I4,0);
6312 VARAND(DATE,0,UINT,0,I4,0);
6313 VARAND(DATE,0,BSTR,false_str,I4,0);
6314 VARAND(DATE,-1,BSTR,false_str,I4,0);
6315 VARAND(DATE,0,BSTR,true_str,I4,0);
6316 VARAND(DATE,-1,BSTR,true_str,I4,-1);
6317 VARANDCY(DATE,-1,10000,I4,1);
6318 VARANDCY(DATE,-1,0,I4,0);
6319 VARANDCY(DATE,0,0,I4,0);
6320
6321 if (HAVE_OLEAUT32_I8)
6322 {
6323 VARAND(I8,-1,I8,-1,I8,-1);
6324 VARAND(I8,-1,I8,0,I8,0);
6325 VARAND(I8,0,I8,0,I8,0);
6326 VARAND(I8,-1,UI8,0,I8,0);
6327 VARAND(I8,0,UI8,0,I8,0);
6328 VARAND(I8,-1,UINT,0,I8,0);
6329 VARAND(I8,0,UINT,0,I8,0);
6330 VARAND(I8,0,BSTR,false_str,I8,0);
6331 VARAND(I8,-1,BSTR,false_str,I8,0);
6332 VARAND(I8,0,BSTR,true_str,I8,0);
6333 VARAND(I8,-1,BSTR,true_str,I8,-1);
6334 VARANDCY(I8,-1,10000,I8,1);
6335 VARANDCY(I8,-1,0,I8,0);
6336 VARANDCY(I8,0,0,I8,0);
6337
6338 VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
6339 VARAND(UI8,0xffff,UI8,0,I4,0);
6340 VARAND(UI8,0,UI8,0,I4,0);
6341 VARAND(UI8,0xffff,INT,-1,I4,65535);
6342 VARAND(UI8,0xffff,INT,0,I4,0);
6343 VARAND(UI8,0,INT,0,I4,0);
6344 VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
6345 VARAND(UI8,0xffff,UINT,0,I4,0);
6346 VARAND(UI8,0,UINT,0,I4,0);
6347 VARAND(UI8,0,BSTR,false_str,I4,0);
6348 VARAND(UI8,0xffff,BSTR,false_str,I4,0);
6349 VARAND(UI8,0,BSTR,true_str,I4,0);
6350 VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
6351 VARANDCY(UI8,0xffff,10000,I4,1);
6352 VARANDCY(UI8,0xffff,0,I4,0);
6353 VARANDCY(UI8,0,0,I4,0);
6354 }
6355
6356 VARAND(INT,-1,INT,-1,I4,-1);
6357 VARAND(INT,-1,INT,0,I4,0);
6358 VARAND(INT,0,INT,0,I4,0);
6359 VARAND(INT,-1,UINT,0xffff,I4,65535);
6360 VARAND(INT,-1,UINT,0,I4,0);
6361 VARAND(INT,0,UINT,0,I4,0);
6362 VARAND(INT,0,BSTR,false_str,I4,0);
6363 VARAND(INT,-1,BSTR,false_str,I4,0);
6364 VARAND(INT,0,BSTR,true_str,I4,0);
6365 VARAND(INT,-1,BSTR,true_str,I4,-1);
6366 VARANDCY(INT,-1,10000,I4,1);
6367 VARANDCY(INT,-1,0,I4,0);
6368 VARANDCY(INT,0,0,I4,0);
6369
6370 VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
6371 VARAND(UINT,0xffff,UINT,0,I4,0);
6372 VARAND(UINT,0,UINT,0,I4,0);
6373 VARAND(UINT,0,BSTR,false_str,I4,0);
6374 VARAND(UINT,0xffff,BSTR, false_str,I4,0);
6375 VARAND(UINT,0,BSTR,true_str,I4,0);
6376 VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
6377 VARANDCY(UINT,0xffff,10000,I4,1);
6378 VARANDCY(UINT,0xffff,0,I4,0);
6379 VARANDCY(UINT,0,0,I4,0);
6380
6381 VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
6382 VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
6383 VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
6384 VARANDCY(BSTR,true_str,10000,I4,1);
6385 VARANDCY(BSTR,false_str,10000,I4,0);
6386
6387 SysFreeString(true_str);
6388 SysFreeString(false_str);
6389 }
6390
6391 static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )
6392 {
6393 HRESULT hres;
6394
6395 CHECKPTR(VarCmp);
6396
6397 hres = pVarCmp(left,right,lcid,flags);
6398 ok_(__FILE__,line)(hres == result, "VarCmp(%s,%s): expected 0x%x, got hres=0x%x\n",
6399 variantstr(left), variantstr(right), result, hres );
6400 }
6401 static void test_cmpex( int line, LCID lcid, VARIANT *left, VARIANT *right,
6402 HRESULT res1, HRESULT res2, HRESULT res3, HRESULT res4 )
6403 {
6404 test_cmp( line, lcid, 0, left, right, res1 );
6405 V_VT(left) |= VT_RESERVED;
6406 test_cmp( line, lcid, 0, left, right, res2 );
6407 V_VT(left) &= ~VT_RESERVED;
6408 V_VT(right) |= VT_RESERVED;
6409 test_cmp( line, lcid, 0, left, right, res3 );
6410 V_VT(left) |= VT_RESERVED;
6411 test_cmp( line, lcid, 0, left, right, res4 );
6412 ok_(__FILE__,line)(V_VT(left) & V_VT(right) & VT_RESERVED, "VT_RESERVED filtered out\n");
6413 }
6414
6415 /* ERROR from wingdi.h is interfering here */
6416 #undef ERROR
6417 #define _VARCMP(vt1,val1,vtfl1,vt2,val2,vtfl2,lcid,flags,result) \
6418 V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1 | vtfl1; \
6419 V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2 | vtfl2; \
6420 test_cmp( __LINE__, lcid, flags, &left, &right, result )
6421 #define VARCMPEX(vt1,val1,vt2,val2,res1,res2,res3,res4) \
6422 V_##vt1(&left) = val1; V_VT(&left) = VT_##vt1; \
6423 V_##vt2(&right) = val2; V_VT(&right) = VT_##vt2; \
6424 test_cmpex( __LINE__, lcid, &left, &right, res1, res2, res3, res4 )
6425 #define VARCMP(vt1,val1,vt2,val2,result) \
6426 VARCMPEX(vt1,val1,vt2,val2,result,result,result,result)
6427 /* The above macros do not work for VT_NULL as NULL gets expanded first */
6428 #define V_NULL_ V_NULL
6429 #define VT_NULL_ VT_NULL
6430
6431 static void test_VarCmp(void)
6432 {
6433 VARIANT left, right;
6434 VARTYPE i;
6435 LCID lcid;
6436 HRESULT hres;
6437 DECIMAL dec;
6438 static const WCHAR szhuh[] = {'h','u','h','?','\0'};
6439 static const WCHAR sz2cents[] = {'2','c','e','n','t','s','\0'};
6440 static const WCHAR szempty[] = {'\0'};
6441 static const WCHAR sz0[] = {'0','\0'};
6442 static const WCHAR sz1[] = {'1','\0'};
6443 static const WCHAR sz7[] = {'7','\0'};
6444 static const WCHAR sz42[] = {'4','2','\0'};
6445 static const WCHAR sz1neg[] = {'-','1','\0'};
6446 static const WCHAR sz666neg[] = {'-','6','6','6','\0'};
6447 static const WCHAR sz1few[] = {'1','.','0','0','0','0','0','0','0','1','\0'};
6448 BSTR bstrhuh, bstrempty, bstr0, bstr1, bstr7, bstr42, bstr1neg, bstr666neg;
6449 BSTR bstr2cents, bstr1few;
6450
6451 CHECKPTR(VarCmp);
6452
6453 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
6454 bstrempty = SysAllocString(szempty);
6455 bstrhuh = SysAllocString(szhuh);
6456 bstr2cents = SysAllocString(sz2cents);
6457 bstr0 = SysAllocString(sz0);
6458 bstr1 = SysAllocString(sz1);
6459 bstr7 = SysAllocString(sz7);
6460 bstr42 = SysAllocString(sz42);
6461 bstr1neg = SysAllocString(sz1neg);
6462 bstr666neg = SysAllocString(sz666neg);
6463 bstr1few = SysAllocString(sz1few);
6464
6465 /* Test all possible flag/vt combinations & the resulting vt type */
6466 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6467 {
6468 VARTYPE leftvt, rightvt;
6469
6470 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6471 {
6472
6473 SKIPTESTS(leftvt);
6474
6475 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6476 {
6477 BOOL bFail = FALSE;
6478 HRESULT expect = VARCMP_EQ;
6479
6480 SKIPTESTS(rightvt);
6481
6482 memset(&left, 0, sizeof(left));
6483 memset(&right, 0, sizeof(right));
6484 V_VT(&left) = leftvt | ExtraFlags[i];
6485 if (leftvt == VT_BSTR) {
6486 V_BSTR(&left) = bstr1neg;
6487 if (ExtraFlags[i] & VT_RESERVED)
6488 expect = VARCMP_LT;
6489 else
6490 expect = VARCMP_GT;
6491 }
6492 V_VT(&right) = rightvt | ExtraFlags[i];
6493 if (rightvt == VT_BSTR) {
6494 V_BSTR(&right) = bstr1neg;
6495 if (ExtraFlags[i] & VT_RESERVED)
6496 expect = VARCMP_GT;
6497 else
6498 expect = VARCMP_LT;
6499 }
6500
6501 /* Don't ask me why but native VarCmp cannot handle:
6502 VT_I1, VT_UI2, VT_UI4, VT_UINT and VT_UI8.
6503 VT_INT is only supported as left variant. Go figure.
6504 Tested with DCOM98, Win2k, WinXP */
6505 if (ExtraFlags[i] & VT_ARRAY || ExtraFlags[i] & VT_BYREF ||
6506 !IsValidVariantClearVT(leftvt, ExtraFlags[i] & ~VT_RESERVED) ||
6507 !IsValidVariantClearVT(rightvt, ExtraFlags[i] & ~VT_RESERVED) ||
6508 leftvt == VT_CLSID || rightvt == VT_CLSID ||
6509 leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
6510 leftvt == VT_ERROR || rightvt == VT_ERROR ||
6511 leftvt == VT_RECORD || rightvt == VT_RECORD ||
6512 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
6513 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
6514 leftvt == VT_I1 || rightvt == VT_I1 ||
6515 leftvt == VT_UI2 || rightvt == VT_UI2 ||
6516 leftvt == VT_UI4 || rightvt == VT_UI4 ||
6517 leftvt == VT_UI8 || rightvt == VT_UI8 ||
6518 rightvt == VT_INT ||
6519 leftvt == VT_UINT || rightvt == VT_UINT) {
6520 bFail = TRUE;
6521 }
6522
6523 if (leftvt == VT_ERROR && rightvt == VT_ERROR &&
6524 !(ExtraFlags[i] & ~VT_RESERVED)) {
6525 expect = VARCMP_EQ;
6526 bFail = FALSE;
6527 } else if (leftvt == VT_NULL || rightvt == VT_NULL)
6528 expect = VARCMP_NULL;
6529 else if (leftvt == VT_BSTR && rightvt == VT_BSTR)
6530 expect = VARCMP_EQ;
6531 else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
6532 expect = VARCMP_GT;
6533 else if (leftvt == VT_EMPTY && rightvt == VT_BSTR)
6534 expect = VARCMP_LT;
6535
6536 hres = pVarCmp(&left, &right, LOCALE_USER_DEFAULT, 0);
6537 if (bFail) {
6538 ok(hres == DISP_E_TYPEMISMATCH || hres == DISP_E_BADVARTYPE,
6539 "VarCmp: %d|0x%X, %d|0x%X: Expected failure, got 0x%X\n",
6540 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], hres);
6541 } else {
6542 ok(hres == expect,
6543 "VarCmp: %d|0x%X, %d|0x%X: Expected 0x%X, got 0x%X\n",
6544 leftvt, ExtraFlags[i], rightvt, ExtraFlags[i], expect,
6545 hres);
6546 }
6547 }
6548 }
6549 }
6550
6551 /* VARCMP{,EX} run each 4 tests with a permutation of all possible
6552 input variants with (1) and without (0) VT_RESERVED set. The order
6553 of the permutations is (0,0); (1,0); (0,1); (1,1) */
6554 VARCMP(INT,4711,I2,4711,VARCMP_EQ);
6555 VARCMP(INT,4711,I2,-4711,VARCMP_GT);
6556 VARCMP(ERROR,0,ERROR,0,VARCMP_EQ);
6557 VARCMP(ERROR,0,UI1,0,DISP_E_TYPEMISMATCH);
6558 VARCMP(EMPTY,0,EMPTY,0,VARCMP_EQ);
6559 VARCMP(I4,1,R8,1.0,VARCMP_EQ);
6560 VARCMP(EMPTY,19,I2,0,VARCMP_EQ);
6561 ok(V_EMPTY(&left) == 19, "VT_EMPTY modified!\n");
6562 VARCMP(I4,1,UI1,1,VARCMP_EQ);
6563 VARCMP(I2,2,I2,2,VARCMP_EQ);
6564 VARCMP(I2,1,I2,2,VARCMP_LT);
6565 VARCMP(I2,2,I2,1,VARCMP_GT);
6566 VARCMP(I2,2,EMPTY,1,VARCMP_GT);
6567 VARCMP(I2,2,NULL_,1,VARCMP_NULL);
6568
6569 /* BSTR handling, especially in conjunction with VT_RESERVED */
6570 VARCMP(BSTR,bstr0,NULL_,0,VARCMP_NULL);
6571 VARCMP(BSTR,bstr0,BSTR,bstr0,VARCMP_EQ);
6572 VARCMP(BSTR,bstrempty,BSTR,bstr0,VARCMP_LT);
6573 VARCMP(BSTR,bstr7,BSTR,bstr0,VARCMP_GT);
6574 VARCMP(BSTR,bstr7,BSTR,bstr1neg,VARCMP_GT);
6575 VARCMP(BSTR,bstr0,BSTR,NULL,VARCMP_GT);
6576 VARCMP(BSTR,NULL,BSTR,NULL,VARCMP_EQ);
6577 VARCMP(BSTR,bstrempty,BSTR,NULL,VARCMP_EQ);
6578 VARCMP(BSTR,NULL,EMPTY,0,VARCMP_EQ);
6579 VARCMP(EMPTY,0,BSTR,NULL,VARCMP_EQ);
6580 VARCMP(EMPTY,0,BSTR,bstrempty,VARCMP_EQ);
6581 VARCMP(EMPTY,1,BSTR,bstrempty,VARCMP_EQ);
6582 VARCMP(BSTR,bstr0,EMPTY,0,VARCMP_GT);
6583 VARCMP(BSTR,bstr42,EMPTY,0,VARCMP_GT);
6584 VARCMPEX(BSTR,bstrempty,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6585 VARCMPEX(BSTR,bstrempty,I2,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6586 VARCMPEX(I4,0,BSTR,bstrempty,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6587 VARCMPEX(BSTR,NULL,UI1,0,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6588 VARCMPEX(I4,7,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6589 _VARCMP(BSTR,(BSTR)100,0,I2,100,0,lcid,0,VARCMP_GT);
6590 VARCMPEX(BSTR,bstr0,UI1,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6591 VARCMPEX(I2,0,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6592 VARCMP(BSTR,bstrhuh,I4,I4_MAX,VARCMP_GT);
6593 VARCMP(BSTR,bstr2cents,I4,2,VARCMP_GT);
6594 VARCMPEX(BSTR,bstr2cents,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6595 VARCMP(BSTR,bstr2cents,I4,-1,VARCMP_GT);
6596 VARCMPEX(BSTR,bstr2cents,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6597 VARCMPEX(BSTR,bstr0,I2,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6598 VARCMPEX(BSTR,bstr0,I4,0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6599 VARCMPEX(BSTR,bstr0,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6600 VARCMP(BSTR,bstr1,I4,0,VARCMP_GT);
6601 VARCMPEX(BSTR,bstr1,I4,1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6602 VARCMPEX(BSTR,bstr1,I4,I4_MAX,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_GT);
6603 VARCMPEX(BSTR,bstr1,I4,-1,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6604 VARCMP(BSTR,bstr7,I4,1,VARCMP_GT);
6605 VARCMPEX(BSTR,bstr7,I4,7,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6606 VARCMPEX(BSTR,bstr7,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6607 VARCMPEX(BSTR,bstr42,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_GT);
6608 VARCMPEX(BSTR,bstr42,I4,42,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6609 VARCMPEX(BSTR,bstr42,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_GT);
6610 VARCMPEX(BSTR,bstr1neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6611 VARCMPEX(BSTR,bstr1neg,I4,42,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6612 VARCMPEX(BSTR,bstr1neg,I4,-1,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6613 VARCMPEX(BSTR,bstr1neg,I4,-666,VARCMP_GT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6614 VARCMPEX(BSTR,bstr666neg,I4,1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6615 VARCMPEX(BSTR,bstr666neg,I4,7,VARCMP_GT,VARCMP_LT,VARCMP_LT,VARCMP_LT);
6616 VARCMPEX(BSTR,bstr666neg,I4,42,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6617 VARCMPEX(BSTR,bstr666neg,I4,I4_MAX,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6618 VARCMPEX(BSTR,bstr666neg,I4,-1,VARCMP_GT,VARCMP_GT,VARCMP_LT,VARCMP_LT);
6619 VARCMPEX(BSTR,bstr666neg,I4,-666,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6620 VARCMPEX(BSTR,bstr7,R8,7.0,VARCMP_GT,VARCMP_EQ,VARCMP_EQ,VARCMP_GT);
6621 VARCMPEX(R8,3.141592,BSTR,NULL,VARCMP_LT,VARCMP_LT,VARCMP_GT,VARCMP_LT);
6622 VARCMP(BSTR,bstr7,BSTR,bstr7,VARCMP_EQ);
6623 VARCMP(BSTR,bstr7,BSTR,bstr42,VARCMP_GT);
6624 VARCMP(BSTR,bstr42,BSTR,bstr7,VARCMP_LT);
6625
6626 /* DECIMAL handling */
6627 setdec(&dec,0,0,0,0);
6628 VARCMPEX(DECIMAL,dec,BSTR,bstr0,VARCMP_LT,VARCMP_EQ,VARCMP_EQ,VARCMP_LT);
6629 setdec64(&dec,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); /* max DECIMAL */
6630 VARCMP(DECIMAL,dec,R8,R8_MAX,VARCMP_LT); /* R8 has bigger range */
6631 VARCMP(DECIMAL,dec,DATE,R8_MAX,VARCMP_LT); /* DATE has bigger range */
6632 setdec64(&dec,0,0x80,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
6633 VARCMP(DECIMAL,dec,R8,-R8_MAX,VARCMP_GT);
6634 setdec64(&dec,20,0,0x5,0x6BC75E2D,0x63100001); /* 1+1e-20 */
6635 VARCMP(DECIMAL,dec,R8,1,VARCMP_GT); /* DECIMAL has higher precision */
6636
6637 /* Show that DATE is handled just as a R8 */
6638 VARCMP(DATE,DATE_MAX,DATE,DATE_MAX+1,VARCMP_LT);
6639 VARCMP(DATE,DATE_MIN,DATE,DATE_MIN-1,VARCMP_GT);
6640 VARCMP(DATE,R8_MIN,R8,R8_MIN,VARCMP_EQ);
6641 VARCMP(DATE,1,DATE,1+1e-15,VARCMP_LT); /* 1e-15 == 8.64e-11 seconds */
6642 VARCMP(DATE,25570.0,DATE,25570.0,VARCMP_EQ);
6643 VARCMP(DATE,25570.0,DATE,25571.0,VARCMP_LT);
6644 VARCMP(DATE,25571.0,DATE,25570.0,VARCMP_GT);
6645 VARCMP(DATE,25570.0,EMPTY,0,VARCMP_GT);
6646 VARCMP(DATE,25570.0,NULL_,0,VARCMP_NULL);
6647
6648 /* R4 precision handling */
6649 VARCMP(R4,1,R8,1+1e-8,VARCMP_EQ);
6650 VARCMP(R8,1+1e-8,R4,1,VARCMP_EQ);
6651 VARCMP(R8,1+1e-8,R8,1,VARCMP_GT);
6652 VARCMP(R8,R4_MAX*1.1,R4,R4_MAX,VARCMP_GT);
6653 VARCMP(R4,R4_MAX,R8,R8_MAX,VARCMP_LT);
6654 VARCMP(R4,1,DATE,1+1e-8,VARCMP_EQ);
6655 VARCMP(R4,1,BSTR,bstr1few,VARCMP_LT); /* bstr1few == 1+1e-8 */
6656 setdec(&dec,8,0,0,0x5F5E101); /* 1+1e-8 */
6657 VARCMP(R4,1,DECIMAL,dec,VARCMP_LT);
6658
6659 SysFreeString(bstrhuh);
6660 SysFreeString(bstrempty);
6661 SysFreeString(bstr0);
6662 SysFreeString(bstr1);
6663 SysFreeString(bstr7);
6664 SysFreeString(bstr42);
6665 SysFreeString(bstr1neg);
6666 SysFreeString(bstr666neg);
6667 SysFreeString(bstr2cents);
6668 SysFreeString(bstr1few);
6669 }
6670
6671 static HRESULT (WINAPI *pVarPow)(LPVARIANT,LPVARIANT,LPVARIANT);
6672
6673 #define VARPOW(vt1,val1,vt2,val2,rvt,rval) \
6674 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
6675 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
6676 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
6677 test_var_call2( __LINE__, pVarPow, &left, &right, &exp )
6678
6679 /* Skip any type that is not defined or produces an error for every case */
6680 #define SKIPTESTPOW(a) \
6681 if (a == VT_ERROR || a == VT_VARIANT || \
6682 a == VT_DISPATCH || a == VT_UNKNOWN || \
6683 a == VT_RECORD || a > VT_UINT || \
6684 a == 15 /*not defined*/) \
6685 continue
6686
6687 static void test_VarPow(void)
6688 {
6689 static const WCHAR str2[] = { '2','\0' };
6690 static const WCHAR str3[] = { '3','\0' };
6691 VARIANT left, right, exp, result, cy, dec;
6692 BSTR num2_str, num3_str;
6693 VARTYPE i;
6694 HRESULT hres;
6695
6696 CHECKPTR(VarPow);
6697
6698 num2_str = SysAllocString(str2);
6699 num3_str = SysAllocString(str3);
6700
6701 /* Test all possible flag/vt combinations & the resulting vt type */
6702 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
6703 {
6704 VARTYPE leftvt, rightvt, resvt;
6705
6706 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
6707 {
6708 SKIPTESTPOW(leftvt);
6709
6710 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
6711 {
6712 BOOL bFail = FALSE;
6713 SKIPTESTPOW(rightvt);
6714
6715 /* Native crashes with VT_BYREF */
6716 if (ExtraFlags[i] == VT_BYREF)
6717 continue;
6718
6719 memset(&left, 0, sizeof(left));
6720 memset(&right, 0, sizeof(right));
6721 V_VT(&left) = leftvt | ExtraFlags[i];
6722 V_VT(&right) = rightvt | ExtraFlags[i];
6723 V_VT(&result) = VT_EMPTY;
6724 resvt = VT_EMPTY;
6725
6726 if (leftvt == VT_BSTR)
6727 V_BSTR(&left) = num2_str;
6728 if (rightvt == VT_BSTR)
6729 V_BSTR(&right) = num2_str;
6730
6731 /* Native VarPow always returns an error when using extra flags */
6732 if (ExtraFlags[i] != 0)
6733 bFail = TRUE;
6734
6735 /* Determine return type */
6736 else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
6737 ((leftvt != VT_I8 && leftvt != VT_UI8 &&
6738 rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
6739 resvt = VT_NULL;
6740 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
6741 leftvt == VT_I4 || leftvt == VT_R4 ||
6742 leftvt == VT_R8 || leftvt == VT_CY ||
6743 leftvt == VT_DATE || leftvt == VT_BSTR ||
6744 leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
6745 (leftvt >= VT_I1 && leftvt <= VT_UI4) ||
6746 (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
6747 leftvt == VT_INT || leftvt == VT_UINT) &&
6748 (rightvt == VT_EMPTY || rightvt == VT_I2 ||
6749 rightvt == VT_I4 || rightvt == VT_R4 ||
6750 rightvt == VT_R8 || rightvt == VT_CY ||
6751 rightvt == VT_DATE || rightvt == VT_BSTR ||
6752 rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
6753 (rightvt >= VT_I1 && rightvt <= VT_UI4) ||
6754 (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
6755 rightvt == VT_INT || rightvt == VT_UINT))
6756 resvt = VT_R8;
6757 else
6758 bFail = TRUE;
6759
6760 hres = pVarPow(&left, &right, &result);
6761
6762 /* Check expected HRESULT and if result variant type is correct */
6763 if (bFail)
6764 ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
6765 "VarPow: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
6766 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
6767 vtstr(V_VT(&result)), hres);
6768 else
6769 ok (hres == S_OK && resvt == V_VT(&result),
6770 "VarPow: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
6771 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
6772 S_OK, vtstr(V_VT(&result)), hres);
6773 }
6774 }
6775 }
6776
6777 /* Check return values for valid variant type combinations */
6778 VARPOW(EMPTY,0,EMPTY,0,R8,1.0);
6779 VARPOW(EMPTY,0,NULL,0,NULL,0);
6780 VARPOW(EMPTY,0,I2,3,R8,0.0);
6781 VARPOW(EMPTY,0,I4,3,R8,0.0);
6782 VARPOW(EMPTY,0,R4,3.0f,R8,0.0);
6783 VARPOW(EMPTY,0,R8,3.0,R8,0.0);
6784 VARPOW(EMPTY,0,DATE,3,R8,0.0);
6785 VARPOW(EMPTY,0,BSTR,num3_str,R8,0.0);
6786 VARPOW(EMPTY,0,BOOL,VARIANT_FALSE,R8,1.0);
6787 VARPOW(EMPTY,0,I1,3,R8,0.0);
6788 VARPOW(EMPTY,0,UI1,3,R8,0.0);
6789 VARPOW(EMPTY,0,UI2,3,R8,0.0);
6790 VARPOW(EMPTY,0,UI4,3,R8,0.0);
6791 if (HAVE_OLEAUT32_I8)
6792 {
6793 VARPOW(EMPTY,0,I8,3,R8,0.0);
6794 VARPOW(EMPTY,0,UI8,3,R8,0.0);
6795 }
6796 VARPOW(EMPTY,0,INT,3,R8,0.0);
6797 VARPOW(EMPTY,0,UINT,3,R8,0.0);
6798 VARPOW(NULL,0,EMPTY,0,NULL,0);
6799 VARPOW(NULL,0,NULL,0,NULL,0);
6800 VARPOW(NULL,0,I2,3,NULL,0);
6801 VARPOW(NULL,0,I4,3,NULL,0);
6802 VARPOW(NULL,0,R4,3.0f,NULL,0);
6803 VARPOW(NULL,0,R8,3.0,NULL,0);
6804 VARPOW(NULL,0,DATE,3,NULL,0);
6805 VARPOW(NULL,0,BSTR,num3_str,NULL,0);
6806 VARPOW(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
6807 VARPOW(NULL,0,I1,3,NULL,0);
6808 VARPOW(NULL,0,UI1,3,NULL,0);
6809 VARPOW(NULL,0,UI2,3,NULL,0);
6810 VARPOW(NULL,0,UI4,3,NULL,0);
6811 if (HAVE_OLEAUT32_I8)
6812 {
6813 VARPOW(NULL,0,I8,3,NULL,0);
6814 VARPOW(NULL,0,UI8,3,NULL,0);
6815 }
6816 VARPOW(NULL,0,INT,3,NULL,0);
6817 VARPOW(NULL,0,UINT,3,NULL,0);
6818 VARPOW(I2,2,EMPTY,0,R8,1.0);
6819 VARPOW(I2,2,NULL,0,NULL,0);
6820 VARPOW(I2,2,I2,3,R8,8.0);
6821 VARPOW(I2,2,I4,3,R8,8.0);
6822 VARPOW(I2,2,R4,3.0f,R8,8.0);
6823 VARPOW(I2,2,R8,3.0,R8,8.0);
6824 VARPOW(I2,2,DATE,3,R8,8.0);
6825 VARPOW(I2,2,BSTR,num3_str,R8,8.0);
6826 VARPOW(I2,2,BOOL,VARIANT_FALSE,R8,1.0);
6827 VARPOW(I2,2,I1,3,R8,8.0);
6828 VARPOW(I2,2,UI1,3,R8,8.0);
6829 VARPOW(I2,2,UI2,3,R8,8.0);
6830 VARPOW(I2,2,UI4,3,R8,8.0);
6831 if (HAVE_OLEAUT32_I8)
6832 {
6833 VARPOW(I2,2,I8,3,R8,8.0);
6834 VARPOW(I2,2,UI8,3,R8,8.0);
6835 }
6836 VARPOW(I2,2,INT,3,R8,8.0);
6837 VARPOW(I2,2,UINT,3,R8,8.0);
6838 VARPOW(I4,2,EMPTY,0,R8,1.0);
6839 VARPOW(I4,2,NULL,0,NULL,0);
6840 VARPOW(I4,2,I2,3,R8,8.0);
6841 VARPOW(I4,2,I4,3,R8,8.0);
6842 VARPOW(I4,2,R4,3.0f,R8,8.0);
6843 VARPOW(I4,2,R8,3.0,R8,8.0);
6844 VARPOW(I4,2,DATE,3,R8,8.0);
6845 VARPOW(I4,2,BSTR,num3_str,R8,8.0);
6846 VARPOW(I4,2,BOOL,VARIANT_FALSE,R8,1.0);
6847 VARPOW(I4,2,I1,3,R8,8.0);
6848 VARPOW(I4,2,UI1,3,R8,8.0);
6849 VARPOW(I4,2,UI2,3,R8,8.0);
6850 VARPOW(I4,2,UI4,3,R8,8.0);
6851 if (HAVE_OLEAUT32_I8)
6852 {
6853 VARPOW(I4,2,I8,3,R8,8.0);
6854 VARPOW(I4,2,UI8,3,R8,8.0);
6855 }
6856 VARPOW(I4,2,INT,3,R8,8.0);
6857 VARPOW(I4,2,UINT,3,R8,8.0);
6858 VARPOW(R4,2,EMPTY,0,R8,1.0);
6859 VARPOW(R4,2,NULL,0,NULL,0);
6860 VARPOW(R4,2,I2,3,R8,8.0);
6861 VARPOW(R4,2,I4,3,R8,8.0);
6862 VARPOW(R4,2,R4,3.0f,R8,8.0);
6863 VARPOW(R4,2,R8,3.0,R8,8.0);
6864 VARPOW(R4,2,DATE,3,R8,8.0);
6865 VARPOW(R4,2,BSTR,num3_str,R8,8.0);
6866 VARPOW(R4,2,BOOL,VARIANT_FALSE,R8,1.0);
6867 VARPOW(R4,2,I1,3,R8,8.0);
6868 VARPOW(R4,2,UI1,3,R8,8.0);
6869 VARPOW(R4,2,UI2,3,R8,8.0);
6870 VARPOW(R4,2,UI4,3,R8,8.0);
6871 if (HAVE_OLEAUT32_I8)
6872 {
6873 VARPOW(R4,2,I8,3,R8,8.0);
6874 VARPOW(R4,2,UI8,3,R8,8.0);
6875 }
6876 VARPOW(R4,2,INT,3,R8,8.0);
6877 VARPOW(R4,2,UINT,3,R8,8.0);
6878 VARPOW(R8,2,EMPTY,0,R8,1.0);
6879 VARPOW(R8,2,NULL,0,NULL,0);
6880 VARPOW(R8,2,I2,3,R8,8.0);
6881 VARPOW(R8,2,I4,3,R8,8.0);
6882 VARPOW(R8,2,R4,3.0f,R8,8.0);
6883 VARPOW(R8,2,R8,3.0,R8,8.0);
6884 VARPOW(R8,2,DATE,3,R8,8.0);
6885 VARPOW(R8,2,BSTR,num3_str,R8,8.0);
6886 VARPOW(R8,2,BOOL,VARIANT_FALSE,R8,1.0);
6887 VARPOW(R8,2,I1,3,R8,8.0);
6888 VARPOW(R8,2,UI1,3,R8,8.0);
6889 VARPOW(R8,2,UI2,3,R8,8.0);
6890 VARPOW(R8,2,UI4,3,R8,8.0);
6891 if (HAVE_OLEAUT32_I8)
6892 {
6893 VARPOW(R8,2,I8,3,R8,8.0);
6894 VARPOW(R8,2,UI8,3,R8,8.0);
6895 }
6896 VARPOW(R8,2,INT,3,R8,8.0);
6897 VARPOW(R8,2,UINT,3,R8,8.0);
6898 VARPOW(DATE,2,EMPTY,0,R8,1.0);
6899 VARPOW(DATE,2,NULL,0,NULL,0);
6900 VARPOW(DATE,2,I2,3,R8,8.0);
6901 VARPOW(DATE,2,I4,3,R8,8.0);
6902 VARPOW(DATE,2,R4,3.0f,R8,8.0);
6903 VARPOW(DATE,2,R8,3.0,R8,8.0);
6904 VARPOW(DATE,2,DATE,3,R8,8.0);
6905 VARPOW(DATE,2,BSTR,num3_str,R8,8.0);
6906 VARPOW(DATE,2,BOOL,VARIANT_FALSE,R8,1.0);
6907 VARPOW(DATE,2,I1,3,R8,8.0);
6908 VARPOW(DATE,2,UI1,3,R8,8.0);
6909 VARPOW(DATE,2,UI2,3,R8,8.0);
6910 VARPOW(DATE,2,UI4,3,R8,8.0);
6911 if (HAVE_OLEAUT32_I8)
6912 {
6913 VARPOW(DATE,2,I8,3,R8,8.0);
6914 VARPOW(DATE,2,UI8,3,R8,8.0);
6915 }
6916 VARPOW(DATE,2,INT,3,R8,8.0);
6917 VARPOW(DATE,2,UINT,3,R8,8.0);
6918 VARPOW(BSTR,num2_str,EMPTY,0,R8,1.0);
6919 VARPOW(BSTR,num2_str,NULL,0,NULL,0);
6920 VARPOW(BSTR,num2_str,I2,3,R8,8.0);
6921 VARPOW(BSTR,num2_str,I4,3,R8,8.0);
6922 VARPOW(BSTR,num2_str,R4,3.0f,R8,8.0);
6923 VARPOW(BSTR,num2_str,R8,3.0,R8,8.0);
6924 VARPOW(BSTR,num2_str,DATE,3,R8,8.0);
6925 VARPOW(BSTR,num2_str,BSTR,num3_str,R8,8.0);
6926 VARPOW(BSTR,num2_str,BOOL,VARIANT_FALSE,R8,1.0);
6927 VARPOW(BSTR,num2_str,I1,3,R8,8.0);
6928 VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
6929 VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
6930 VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
6931 if (HAVE_OLEAUT32_I8)
6932 {
6933 VARPOW(BSTR,num2_str,I8,3,R8,8.0);
6934 VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
6935 }
6936 VARPOW(BSTR,num2_str,INT,3,R8,8.0);
6937 VARPOW(BSTR,num2_str,UINT,3,R8,8.0);
6938 VARPOW(BOOL,VARIANT_TRUE,EMPTY,0,R8,1.0);
6939 VARPOW(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
6940 VARPOW(BOOL,VARIANT_TRUE,I2,3,R8,-1.0);
6941 VARPOW(BOOL,VARIANT_TRUE,I4,3,R8,-1.0);
6942 VARPOW(BOOL,VARIANT_TRUE,R4,3.0f,R8,-1.0);
6943 VARPOW(BOOL,VARIANT_TRUE,R8,3.0,R8,-1.0);
6944 VARPOW(BOOL,VARIANT_TRUE,DATE,3,R8,-1.0);
6945 VARPOW(BOOL,VARIANT_TRUE,BSTR,num3_str,R8,-1.0);
6946 VARPOW(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,-1.0);
6947 VARPOW(BOOL,VARIANT_TRUE,I1,3,R8,-1.0);
6948 VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
6949 VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
6950 VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
6951 if (HAVE_OLEAUT32_I8)
6952 {
6953 VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
6954 VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
6955 }
6956 VARPOW(BOOL,VARIANT_TRUE,INT,3,R8,-1.0);
6957 VARPOW(BOOL,VARIANT_TRUE,UINT,3,R8,-1.0);
6958 VARPOW(I1,2,EMPTY,0,R8,1.0);
6959 VARPOW(I1,2,NULL,0,NULL,0);
6960 VARPOW(I1,2,I2,3,R8,8.0);
6961 VARPOW(I1,2,I4,3,R8,8.0);
6962 VARPOW(I1,2,R4,3.0f,R8,8.0);
6963 VARPOW(I1,2,R8,3.0,R8,8.0);
6964 VARPOW(I1,2,DATE,3,R8,8.0);
6965 VARPOW(I1,2,BSTR,num3_str,R8,8.0);
6966 VARPOW(I1,2,BOOL,VARIANT_FALSE,R8,1.0);
6967 VARPOW(I1,2,I1,3,R8,8.0);
6968 VARPOW(I1,2,UI1,3,R8,8.0);
6969 VARPOW(I1,2,UI2,3,R8,8.0);
6970 VARPOW(I1,2,UI4,3,R8,8.0);
6971 if (HAVE_OLEAUT32_I8)
6972 {
6973 VARPOW(I1,2,I8,3,R8,8.0);
6974 VARPOW(I1,2,UI8,3,R8,8.0);
6975 }
6976 VARPOW(I1,2,INT,3,R8,8.0);
6977 VARPOW(I1,2,UINT,3,R8,8.0);
6978 VARPOW(UI1,2,EMPTY,0,R8,1.0);
6979 VARPOW(UI1,2,NULL,0,NULL,0);
6980 VARPOW(UI1,2,I2,3,R8,8.0);
6981 VARPOW(UI1,2,I4,3,R8,8.0);
6982 VARPOW(UI1,2,R4,3.0f,R8,8.0);
6983 VARPOW(UI1,2,R8,3.0,R8,8.0);
6984 VARPOW(UI1,2,DATE,3,R8,8.0);
6985 VARPOW(UI1,2,BSTR,num3_str,R8,8.0);
6986 VARPOW(UI1,2,BOOL,VARIANT_FALSE,R8,1.0);
6987 VARPOW(UI1,2,I1,3,R8,8.0);
6988 VARPOW(UI1,2,UI1,3,R8,8.0);
6989 VARPOW(UI1,2,UI2,3,R8,8.0);
6990 VARPOW(UI1,2,UI4,3,R8,8.0);
6991 if (HAVE_OLEAUT32_I8)
6992 {
6993 VARPOW(UI1,2,I8,3,R8,8.0);
6994 VARPOW(UI1,2,UI8,3,R8,8.0);
6995 }
6996 VARPOW(UI1,2,INT,3,R8,8.0);
6997 VARPOW(UI1,2,UINT,3,R8,8.0);
6998 VARPOW(UI2,2,EMPTY,0,R8,1.0);
6999 VARPOW(UI2,2,NULL,0,NULL,0);
7000 VARPOW(UI2,2,I2,3,R8,8.0);
7001 VARPOW(UI2,2,I4,3,R8,8.0);
7002 VARPOW(UI2,2,R4,3.0f,R8,8.0);
7003 VARPOW(UI2,2,R8,3.0,R8,8.0);
7004 VARPOW(UI2,2,DATE,3,R8,8.0);
7005 VARPOW(UI2,2,BSTR,num3_str,R8,8.0);
7006 VARPOW(UI2,2,BOOL,VARIANT_FALSE,R8,1.0);
7007 VARPOW(UI2,2,I1,3,R8,8.0);
7008 VARPOW(UI2,2,UI1,3,R8,8.0);
7009 VARPOW(UI2,2,UI2,3,R8,8.0);
7010 VARPOW(UI2,2,UI4,3,R8,8.0);
7011 if (HAVE_OLEAUT32_I8)
7012 {
7013 VARPOW(UI2,2,I8,3,R8,8.0);
7014 VARPOW(UI2,2,UI8,3,R8,8.0);
7015 }
7016 VARPOW(UI2,2,INT,3,R8,8.0);
7017 VARPOW(UI2,2,UINT,3,R8,8.0);
7018 VARPOW(UI4,2,EMPTY,0,R8,1.0);
7019 VARPOW(UI4,2,NULL,0,NULL,0);
7020 VARPOW(UI4,2,I2,3,R8,8.0);
7021 VARPOW(UI4,2,I4,3,R8,8.0);
7022 VARPOW(UI4,2,R4,3.0f,R8,8.0);
7023 VARPOW(UI4,2,R8,3.0,R8,8.0);
7024 VARPOW(UI4,2,DATE,3,R8,8.0);
7025 VARPOW(UI4,2,BSTR,num3_str,R8,8.0);
7026 VARPOW(UI4,2,BOOL,VARIANT_FALSE,R8,1.0);
7027 VARPOW(UI4,2,I1,3,R8,8.0);
7028 VARPOW(UI4,2,UI1,3,R8,8.0);
7029 VARPOW(UI4,2,UI2,3,R8,8.0);
7030 VARPOW(UI4,2,UI4,3,R8,8.0);
7031 if (HAVE_OLEAUT32_I8)
7032 {
7033 VARPOW(UI4,2,I8,3,R8,8.0);
7034 VARPOW(UI4,2,UI8,3,R8,8.0);
7035 }
7036 VARPOW(UI4,2,INT,3,R8,8.0);
7037 VARPOW(UI4,2,UINT,3,R8,8.0);
7038 if (HAVE_OLEAUT32_I8)
7039 {
7040 VARPOW(I8,2,EMPTY,0,R8,1.0);
7041 VARPOW(I8,2,NULL,0,NULL,0);
7042 VARPOW(I8,2,I2,3,R8,8.0);
7043 VARPOW(I8,2,I4,3,R8,8.0);
7044 VARPOW(I8,2,R4,3.0f,R8,8.0);
7045 VARPOW(I8,2,R8,3.0,R8,8.0);
7046 VARPOW(I8,2,DATE,3,R8,8.0);
7047 VARPOW(I8,2,BSTR,num3_str,R8,8.0);
7048 VARPOW(I8,2,BOOL,VARIANT_FALSE,R8,1.0);
7049 VARPOW(I8,2,I1,3,R8,8.0);
7050 VARPOW(I8,2,UI1,3,R8,8.0);
7051 VARPOW(I8,2,UI2,3,R8,8.0);
7052 VARPOW(I8,2,UI4,3,R8,8.0);
7053 VARPOW(I8,2,I8,3,R8,8.0);
7054 VARPOW(I8,2,UI8,3,R8,8.0);
7055 VARPOW(I8,2,INT,3,R8,8.0);
7056 VARPOW(I8,2,UINT,3,R8,8.0);
7057 VARPOW(UI8,2,EMPTY,0,R8,1.0);
7058 VARPOW(UI8,2,NULL,0,NULL,0);
7059 VARPOW(UI8,2,I2,3,R8,8.0);
7060 VARPOW(UI8,2,I4,3,R8,8.0);
7061 VARPOW(UI8,2,R4,3.0f,R8,8.0);
7062 VARPOW(UI8,2,R8,3.0,R8,8.0);
7063 VARPOW(UI8,2,DATE,3,R8,8.0);
7064 VARPOW(UI8,2,BSTR,num3_str,R8,8.0);
7065 VARPOW(UI8,2,I1,3,R8,8.0);
7066 VARPOW(UI8,2,UI1,3,R8,8.0);
7067 VARPOW(UI8,2,UI2,3,R8,8.0);
7068 VARPOW(UI8,2,UI4,3,R8,8.0);
7069 VARPOW(UI8,2,I8,3,R8,8.0);
7070 VARPOW(UI8,2,UI8,3,R8,8.0);
7071 VARPOW(UI8,2,INT,3,R8,8.0);
7072 VARPOW(UI8,2,UINT,3,R8,8.0);
7073 }
7074 VARPOW(INT,2,EMPTY,0,R8,1.0);
7075 VARPOW(INT,2,NULL,0,NULL,0);
7076 VARPOW(INT,2,I2,3,R8,8.0);
7077 VARPOW(INT,2,I4,3,R8,8.0);
7078 VARPOW(INT,2,R4,3.0f,R8,8.0);
7079 VARPOW(INT,2,R8,3.0,R8,8.0);
7080 VARPOW(INT,2,DATE,3,R8,8.0);
7081 VARPOW(INT,2,BSTR,num3_str,R8,8.0);
7082 VARPOW(INT,2,BOOL,VARIANT_FALSE,R8,1.0);
7083 VARPOW(INT,2,I1,3,R8,8.0);
7084 VARPOW(INT,2,UI1,3,R8,8.0);
7085 VARPOW(INT,2,UI2,3,R8,8.0);
7086 VARPOW(INT,2,UI4,3,R8,8.0);
7087 if (HAVE_OLEAUT32_I8)
7088 {
7089 VARPOW(INT,2,I8,3,R8,8.0);
7090 VARPOW(INT,2,UI8,3,R8,8.0);
7091 }
7092 VARPOW(INT,2,INT,3,R8,8.0);
7093 VARPOW(INT,2,UINT,3,R8,8.0);
7094 VARPOW(UINT,2,EMPTY,0,R8,1.0);
7095 VARPOW(UINT,2,NULL,0,NULL,0);
7096 VARPOW(UINT,2,I2,3,R8,8.0);
7097 VARPOW(UINT,2,I4,3,R8,8.0);
7098 VARPOW(UINT,2,R4,3.0f,R8,8.0);
7099 VARPOW(UINT,2,R8,3.0,R8,8.0);
7100 VARPOW(UINT,2,DATE,3,R8,8.0);
7101 VARPOW(UINT,2,BSTR,num3_str,R8,8.0);
7102 VARPOW(UINT,2,BOOL,VARIANT_FALSE,R8,1.0);
7103 VARPOW(UINT,2,I1,3,R8,8.0);
7104 VARPOW(UINT,2,UI1,3,R8,8.0);
7105 VARPOW(UINT,2,UI2,3,R8,8.0);
7106 VARPOW(UINT,2,UI4,3,R8,8.0);
7107 if (HAVE_OLEAUT32_I8)
7108 {
7109 VARPOW(UINT,2,I8,3,R8,8.0);
7110 VARPOW(UINT,2,UI8,3,R8,8.0);
7111 }
7112 VARPOW(UINT,2,INT,3,R8,8.0);
7113 VARPOW(UINT,2,UINT,3,R8,8.0);
7114
7115 /* Manually test some VT_CY, VT_DECIMAL variants */
7116 V_VT(&cy) = VT_CY;
7117 hres = VarCyFromI4(2, &V_CY(&cy));
7118 ok(hres == S_OK, "VarCyFromI4 failed!\n");
7119 V_VT(&dec) = VT_DECIMAL;
7120 hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7121 ok(hres == S_OK, "VarDecFromR4 failed!\n");
7122 memset(&left, 0, sizeof(left));
7123 memset(&right, 0, sizeof(right));
7124 V_VT(&left) = VT_I4;
7125 V_I4(&left) = 100;
7126 V_VT(&right) = VT_I8;
7127 V_UI1(&right) = 2;
7128
7129 hres = pVarPow(&cy, &cy, &result);
7130 ok(hres == S_OK && V_VT(&result) == VT_R8,
7131 "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7132 S_OK, hres, vtstr(V_VT(&result)));
7133 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7134 "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7135
7136 hres = pVarPow(&cy, &right, &result);
7137 if (hres == S_OK)
7138 {
7139 ok(hres == S_OK && V_VT(&result) == VT_R8,
7140 "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7141 S_OK, hres, vtstr(V_VT(&result)));
7142 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7143 "VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
7144 }
7145 else
7146 {
7147 ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7148 "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7149 DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7150 }
7151
7152 hres = pVarPow(&left, &cy, &result);
7153 ok(hres == S_OK && V_VT(&result) == VT_R8,
7154 "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7155 S_OK, hres, vtstr(V_VT(&result)));
7156 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 10000.0),
7157 "VARPOW: CY value %f, expected %f\n", V_R8(&result), 10000.0);
7158
7159 hres = pVarPow(&left, &dec, &result);
7160 ok(hres == S_OK && V_VT(&result) == VT_R8,
7161 "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7162 S_OK, hres, vtstr(V_VT(&result)));
7163 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result),10000.0),
7164 "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 10000.0);
7165
7166 hres = pVarPow(&dec, &dec, &result);
7167 ok(hres == S_OK && V_VT(&result) == VT_R8,
7168 "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7169 S_OK, hres, vtstr(V_VT(&result)));
7170 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7171 "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7172
7173 hres = pVarPow(&dec, &right, &result);
7174 if (hres == S_OK)
7175 {
7176 ok(hres == S_OK && V_VT(&result) == VT_R8,
7177 "VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
7178 S_OK, hres, vtstr(V_VT(&result)));
7179 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
7180 "VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
7181 }
7182 else
7183 {
7184 ok(hres == DISP_E_BADVARTYPE && V_VT(&result) == VT_EMPTY,
7185 "VARPOW: expected coerced hres 0x%X type VT_EMPTY, got hres 0x%X type %s!\n",
7186 DISP_E_BADVARTYPE, hres, vtstr(V_VT(&result)));
7187 }
7188
7189 SysFreeString(num2_str);
7190 SysFreeString(num3_str);
7191 }
7192
7193 static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7194
7195 #define VARDIV(vt1,val1,vt2,val2,rvt,rval) \
7196 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
7197 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7198 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
7199 test_var_call2( __LINE__, pVarDiv, &left, &right, &exp )
7200
7201 /* Skip any type that is not defined or produces an error for every case */
7202 #define SKIPTESTDIV(a) \
7203 if (a == VT_ERROR || a == VT_VARIANT || \
7204 a == VT_DISPATCH || a == VT_UNKNOWN || \
7205 a == VT_RECORD || a > VT_UINT || \
7206 a == VT_I1 || a == VT_UI8 || \
7207 a == VT_INT || a == VT_UINT || \
7208 a == VT_UI2 || a == VT_UI4 || \
7209 a == 15 /*not defined*/) \
7210 continue
7211
7212 static void test_VarDiv(void)
7213 {
7214 static const WCHAR str1[] = { '1','\0' };
7215 static const WCHAR str2[] = { '2','\0' };
7216 VARIANT left, right, exp, result, cy, dec;
7217 BSTR num1_str, num2_str;
7218 VARTYPE i;
7219 HRESULT hres;
7220 double r;
7221
7222 num1_str = SysAllocString(str1);
7223 num2_str = SysAllocString(str2);
7224
7225 CHECKPTR(VarDiv);
7226
7227 /* Test all possible flag/vt combinations & the resulting vt type */
7228 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7229 {
7230 VARTYPE leftvt, rightvt, resvt;
7231
7232 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7233 {
7234 SKIPTESTDIV(leftvt);
7235
7236 /* Check if we need/have support for I8 */
7237 if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
7238 continue;
7239
7240 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7241 {
7242 BOOL bFail = FALSE;
7243 SKIPTESTDIV(rightvt);
7244
7245 /* Check if we need/have support for I8 */
7246 if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
7247 continue;
7248
7249 /* Native crashes with VT_BYREF */
7250 if (ExtraFlags[i] == VT_BYREF)
7251 continue;
7252
7253 memset(&left, 0, sizeof(left));
7254 memset(&right, 0, sizeof(right));
7255 V_VT(&left) = leftvt | ExtraFlags[i];
7256 V_VT(&right) = rightvt | ExtraFlags[i];
7257 V_VT(&result) = VT_EMPTY;
7258 resvt = VT_EMPTY;
7259
7260 if (leftvt == VT_BSTR)
7261 V_BSTR(&left) = num2_str;
7262 else if (leftvt == VT_DECIMAL)
7263 {
7264 VarDecFromR8(2.0, &V_DECIMAL(&left));
7265 V_VT(&left) = leftvt | ExtraFlags[i];
7266 }
7267
7268 /* Division by 0 is undefined */
7269 switch(rightvt)
7270 {
7271 case VT_BSTR:
7272 V_BSTR(&right) = num2_str;
7273 break;
7274 case VT_DECIMAL:
7275 VarDecFromR8(2.0, &V_DECIMAL(&right));
7276 V_VT(&right) = rightvt | ExtraFlags[i];
7277 break;
7278 case VT_BOOL:
7279 V_BOOL(&right) = VARIANT_TRUE;
7280 break;
7281 case VT_I2: V_I2(&right) = 2; break;
7282 case VT_I4: V_I4(&right) = 2; break;
7283 case VT_R4: V_R4(&right) = 2.0f; break;
7284 case VT_R8: V_R8(&right) = 2.0; break;
7285 case VT_CY: V_CY(&right).int64 = 2; break;
7286 case VT_DATE: V_DATE(&right) = 2; break;
7287 case VT_UI1: V_UI1(&right) = 2; break;
7288 case VT_I8: V_I8(&right) = 2; break;
7289 default: break;
7290 }
7291
7292 /* Determine return type */
7293 if (!(rightvt == VT_EMPTY))
7294 {
7295 if (leftvt == VT_NULL || rightvt == VT_NULL)
7296 resvt = VT_NULL;
7297 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
7298 resvt = VT_DECIMAL;
7299 else if (leftvt == VT_I8 || rightvt == VT_I8 ||
7300 leftvt == VT_CY || rightvt == VT_CY ||
7301 leftvt == VT_DATE || rightvt == VT_DATE ||
7302 leftvt == VT_I4 || rightvt == VT_I4 ||
7303 leftvt == VT_BSTR || rightvt == VT_BSTR ||
7304 leftvt == VT_I2 || rightvt == VT_I2 ||
7305 leftvt == VT_BOOL || rightvt == VT_BOOL ||
7306 leftvt == VT_R8 || rightvt == VT_R8 ||
7307 leftvt == VT_UI1 || rightvt == VT_UI1)
7308 {
7309 if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
7310 (leftvt == VT_R4 && rightvt == VT_UI1))
7311 resvt = VT_R4;
7312 else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
7313 rightvt == VT_I2)) || (rightvt == VT_R4 &&
7314 (leftvt == VT_BOOL || leftvt == VT_I2)))
7315 resvt = VT_R4;
7316 else
7317 resvt = VT_R8;
7318 }
7319 else if (leftvt == VT_R4 || rightvt == VT_R4)
7320 resvt = VT_R4;
7321 }
7322 else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
7323 resvt = VT_NULL;
7324 else
7325 bFail = TRUE;
7326
7327 /* Native VarDiv always returns an error when using extra flags */
7328 if (ExtraFlags[i] != 0)
7329 bFail = TRUE;
7330
7331 hres = pVarDiv(&left, &right, &result);
7332
7333 /* Check expected HRESULT and if result variant type is correct */
7334 if (bFail)
7335 ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7336 hres == DISP_E_OVERFLOW || hres == DISP_E_DIVBYZERO,
7337 "VarDiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7338 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7339 vtstr(V_VT(&result)), hres);
7340 else
7341 ok (hres == S_OK && resvt == V_VT(&result),
7342 "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7343 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7344 S_OK, vtstr(V_VT(&result)), hres);
7345 }
7346 }
7347 }
7348
7349 /* Test return values for all the good cases */
7350 VARDIV(EMPTY,0,NULL,0,NULL,0);
7351 VARDIV(EMPTY,0,I2,2,R8,0.0);
7352 VARDIV(EMPTY,0,I4,2,R8,0.0);
7353 VARDIV(EMPTY,0,R4,2.0f,R4,0.0f);
7354 VARDIV(EMPTY,0,R8,2.0,R8,0.0);
7355 VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
7356 VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
7357 VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
7358 VARDIV(EMPTY,0,UI1,2,R8,0.0);
7359 if (HAVE_OLEAUT32_I8)
7360 {
7361 VARDIV(EMPTY,0,I8,2,R8,0.0);
7362 }
7363 VARDIV(NULL,0,EMPTY,0,NULL,0);
7364 VARDIV(NULL,0,NULL,0,NULL,0);
7365 VARDIV(NULL,0,I2,2,NULL,0);
7366 VARDIV(NULL,0,I4,2,NULL,0);
7367 VARDIV(NULL,0,R4,2.0f,NULL,0);
7368 VARDIV(NULL,0,R8,2.0,NULL,0);
7369 VARDIV(NULL,0,DATE,2,NULL,0);
7370 VARDIV(NULL,0,BSTR,num2_str,NULL,0);
7371 VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7372 VARDIV(NULL,0,UI1,2,NULL,0);
7373 if (HAVE_OLEAUT32_I8)
7374 {
7375 VARDIV(NULL,0,I8,2,NULL,0);
7376 }
7377 VARDIV(I2,2,NULL,0,NULL,0);
7378 VARDIV(I2,1,I2,2,R8,0.5);
7379 VARDIV(I2,1,I4,2,R8,0.5);
7380 VARDIV(I2,1,R4,2,R4,0.5f);
7381 VARDIV(I2,1,R8,2.0,R8,0.5);
7382 VARDIV(I2,1,DATE,2,R8,0.5);
7383 VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
7384 VARDIV(I2,1,UI1,2,R8,0.5);
7385 if (HAVE_OLEAUT32_I8)
7386 {
7387 VARDIV(I2,1,I8,2,R8,0.5);
7388 }
7389 VARDIV(I4,1,NULL,0,NULL,0);
7390 VARDIV(I4,1,I2,2,R8,0.5);
7391 VARDIV(I4,1,I4,2,R8,0.5);
7392 VARDIV(I4,1,R4,2.0f,R8,0.5);
7393 VARDIV(I4,1,R8,2.0,R8,0.5);
7394 VARDIV(I4,1,DATE,2,R8,0.5);
7395 VARDIV(I4,1,BSTR,num2_str,R8,0.5);
7396 VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
7397 VARDIV(I4,1,UI1,2,R8,0.5);
7398 if (HAVE_OLEAUT32_I8)
7399 {
7400 VARDIV(I4,1,I8,2,R8,0.5);
7401 }
7402 VARDIV(R4,1.0f,NULL,0,NULL,0);
7403 VARDIV(R4,1.0f,I2,2,R4,0.5f);
7404 VARDIV(R4,1.0f,I4,2,R8,0.5);
7405 VARDIV(R4,1.0f,R4,2.0f,R4,0.5f);
7406 VARDIV(R4,1.0f,R8,2.0,R8,0.5);
7407 VARDIV(R4,1.0f,DATE,2,R8,0.5);
7408 VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
7409 VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
7410 VARDIV(R4,1.0f,UI1,2,R4,0.5f);
7411 if (HAVE_OLEAUT32_I8)
7412 {
7413 VARDIV(R4,1.0f,I8,2,R8,0.5);
7414 }
7415 VARDIV(R8,1.0,NULL,0,NULL,0);
7416 VARDIV(R8,1.0,I2,2,R8,0.5);
7417 VARDIV(R8,1.0,I4,2,R8,0.5);
7418 VARDIV(R8,1.0,R4,2.0f,R8,0.5);
7419 VARDIV(R8,1.0,R8,2.0,R8,0.5);
7420 VARDIV(R8,1.0,DATE,2,R8,0.5);
7421 VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
7422 VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
7423 VARDIV(R8,1.0,UI1,2,R8,0.5);
7424 if (HAVE_OLEAUT32_I8)
7425 {
7426 VARDIV(R8,1.0,I8,2,R8,0.5);
7427 }
7428 VARDIV(DATE,1,NULL,0,NULL,0);
7429 VARDIV(DATE,1,I2,2,R8,0.5);
7430 VARDIV(DATE,1,I4,2,R8,0.5);
7431 VARDIV(DATE,1,R4,2.0f,R8,0.5);
7432 VARDIV(DATE,1,R8,2.0,R8,0.5);
7433 VARDIV(DATE,1,DATE,2,R8,0.5);
7434 VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
7435 VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
7436 VARDIV(DATE,1,UI1,2,R8,0.5);
7437 if (HAVE_OLEAUT32_I8)
7438 {
7439 VARDIV(DATE,1,I8,2,R8,0.5);
7440 }
7441 VARDIV(BSTR,num1_str,NULL,0,NULL,0);
7442 VARDIV(BSTR,num1_str,I2,2,R8,0.5);
7443 VARDIV(BSTR,num1_str,I4,2,R8,0.5);
7444 VARDIV(BSTR,num1_str,R4,2.0f,R8,0.5);
7445 VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
7446 VARDIV(BSTR,num1_str,DATE,2,R8,0.5);
7447 VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
7448 VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
7449 VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
7450 if (HAVE_OLEAUT32_I8)
7451 {
7452 VARDIV(BSTR,num1_str,I8,2,R8,0.5);
7453 }
7454 VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7455 VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
7456 VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
7457 VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
7458 VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
7459 VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0f);
7460 VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0f);
7461 VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
7462 VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
7463 VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
7464 VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
7465 VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
7466 VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
7467 VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
7468 if (HAVE_OLEAUT32_I8)
7469 {
7470 VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
7471 }
7472 VARDIV(UI1,1,NULL,0,NULL,0);
7473 VARDIV(UI1,1,I2,2,R8,0.5);
7474 VARDIV(UI1,1,I4,2,R8,0.5);
7475 VARDIV(UI1,1,R4,2.0f,R4,0.5f);
7476 VARDIV(UI1,1,R8,2.0,R8,0.5);
7477 VARDIV(UI1,1,DATE,2,R8,0.5);
7478 VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
7479 VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
7480 VARDIV(UI1,1,UI1,2,R8,0.5);
7481 if (HAVE_OLEAUT32_I8)
7482 {
7483 VARDIV(UI1,1,I8,2,R8,0.5);
7484 VARDIV(I8,1,NULL,0,NULL,0);
7485 VARDIV(I8,1,I2,2,R8,0.5);
7486 VARDIV(I8,1,I4,2,R8,0.5);
7487 VARDIV(I8,1,R4,2.0f,R8,0.5);
7488 VARDIV(I8,1,R8,2.0,R8,0.5);
7489 VARDIV(I8,1,DATE,2,R8,0.5);
7490 VARDIV(I8,1,BSTR,num2_str,R8,0.5);
7491 VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
7492 VARDIV(I8,1,UI1,2,R8,0.5);
7493 VARDIV(I8,1,I8,2,R8,0.5);
7494 }
7495
7496 /* Manually test some VT_CY, VT_DECIMAL variants */
7497 V_VT(&cy) = VT_CY;
7498 hres = VarCyFromI4(10000, &V_CY(&cy));
7499 ok(hres == S_OK, "VarCyFromI4 failed!\n");
7500 V_VT(&dec) = VT_DECIMAL;
7501 hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
7502 ok(hres == S_OK, "VarDecFromR4 failed!\n");
7503 memset(&left, 0, sizeof(left));
7504 memset(&right, 0, sizeof(right));
7505 V_VT(&left) = VT_I4;
7506 V_I4(&left) = 100;
7507 V_VT(&right) = VT_UI1;
7508 V_UI1(&right) = 2;
7509
7510 hres = pVarDiv(&cy, &cy, &result);
7511 ok(hres == S_OK && V_VT(&result) == VT_R8,
7512 "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7513 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
7514 "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
7515
7516 hres = pVarDiv(&cy, &right, &result);
7517 ok(hres == S_OK && V_VT(&result) == VT_R8,
7518 "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7519 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
7520 "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
7521
7522 hres = pVarDiv(&left, &cy, &result);
7523 ok(hres == S_OK && V_VT(&result) == VT_R8,
7524 "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
7525 ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
7526 "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
7527
7528 hres = pVarDiv(&left, &dec, &result);
7529 ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7530 "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7531 hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7532 ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
7533 "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
7534
7535 hres = pVarDiv(&dec, &dec, &result);
7536 ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7537 "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7538 hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7539 ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7540 "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7541
7542 hres = pVarDiv(&dec, &right, &result);
7543 ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
7544 "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
7545 hres = VarR8FromDec(&V_DECIMAL(&result), &r);
7546 ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
7547 "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
7548
7549 /* Check for division by zero and overflow */
7550 V_VT(&left) = VT_R8;
7551 V_I4(&left) = 1;
7552 V_VT(&right) = VT_R8;
7553 V_I4(&right) = 0;
7554 hres = pVarDiv(&left, &right, &result);
7555 ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
7556 "VARDIV: Division by (1.0/0.0) should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
7557
7558 V_VT(&left) = VT_R8;
7559 V_I4(&left) = 0;
7560 V_VT(&right) = VT_R8;
7561 V_I4(&right) = 0;
7562 hres = pVarDiv(&left, &right, &result);
7563 ok(hres == DISP_E_OVERFLOW && V_VT(&result) == VT_EMPTY,
7564 "VARDIV: Division by (0.0/0.0) should result in DISP_E_OVERFLOW but got 0x%X\n", hres);
7565
7566 SysFreeString(num1_str);
7567 SysFreeString(num2_str);
7568 }
7569
7570 static HRESULT (WINAPI *pVarIdiv)(LPVARIANT,LPVARIANT,LPVARIANT);
7571
7572 #define VARIDIV(vt1,val1,vt2,val2,rvt,rval) \
7573 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
7574 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
7575 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
7576 test_var_call2( __LINE__, pVarIdiv, &left, &right, &exp )
7577
7578 /* Skip any type that is not defined or produces an error for every case */
7579 #define SKIPTESTIDIV(a) \
7580 if (a == VT_ERROR || a == VT_VARIANT || \
7581 a == VT_DISPATCH || a == VT_UNKNOWN || \
7582 a == VT_RECORD || a > VT_UINT || \
7583 a == 15 /*not defined*/) \
7584 continue
7585
7586 static void test_VarIdiv(void)
7587 {
7588 static const WCHAR str1[] = { '1','\0' };
7589 static const WCHAR str2[] = { '2','\0' };
7590 VARIANT left, right, exp, result, cy, dec;
7591 BSTR num1_str, num2_str;
7592 VARTYPE i;
7593 HRESULT hres;
7594
7595 CHECKPTR(VarIdiv);
7596
7597 num1_str = SysAllocString(str1);
7598 num2_str = SysAllocString(str2);
7599
7600 /* Test all possible flag/vt combinations & the resulting vt type */
7601 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
7602 {
7603 VARTYPE leftvt, rightvt, resvt;
7604
7605 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
7606 {
7607 SKIPTESTIDIV(leftvt);
7608
7609 /* Check if we need/have support for I8 and/or UI8 */
7610 if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7611 continue;
7612
7613 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
7614 {
7615 BOOL bFail = FALSE;
7616 SKIPTESTIDIV(rightvt);
7617
7618 /* Native crashes with extra flag VT_BYREF */
7619 if (ExtraFlags[i] == VT_BYREF)
7620 continue;
7621
7622 /* Check if we need/have support for I8 and/or UI8 */
7623 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
7624 continue;
7625
7626 memset(&left, 0, sizeof(left));
7627 memset(&right, 0, sizeof(right));
7628 V_VT(&left) = leftvt | ExtraFlags[i];
7629 V_VT(&right) = rightvt | ExtraFlags[i];
7630 V_VT(&result) = VT_EMPTY;
7631 resvt = VT_EMPTY;
7632
7633 if (leftvt == VT_BSTR)
7634 V_BSTR(&left) = num2_str;
7635 else if (leftvt == VT_DECIMAL)
7636 {
7637 VarDecFromR8(2.0, &V_DECIMAL(&left));
7638 V_VT(&left) = leftvt | ExtraFlags[i];
7639 }
7640
7641 /* Division by 0 is undefined */
7642 switch(rightvt)
7643 {
7644 case VT_BSTR:
7645 V_BSTR(&right) = num2_str;
7646 break;
7647 case VT_DECIMAL:
7648 VarDecFromR8(2.0, &V_DECIMAL(&right));
7649 V_VT(&right) = rightvt | ExtraFlags[i];
7650 break;
7651 case VT_BOOL:
7652 V_BOOL(&right) = VARIANT_TRUE;
7653 break;
7654 case VT_CY:
7655 VarCyFromI4(10000, &V_CY(&right));
7656 V_VT(&right) = rightvt | ExtraFlags[i];
7657 break;
7658 case VT_I2: V_I2(&right) = 2; break;
7659 case VT_I4: V_I4(&right) = 2; break;
7660 case VT_R4: V_R4(&right) = 2.0f; break;
7661 case VT_R8: V_R8(&right) = 2.0; break;
7662 case VT_DATE: V_DATE(&right) = 2; break;
7663 case VT_I1: V_I1(&right) = 2; break;
7664 case VT_UI1: V_UI1(&right) = 2; break;
7665 case VT_UI2: V_UI2(&right) = 2; break;
7666 case VT_UI4: V_UI4(&right) = 2; break;
7667 case VT_I8: V_I8(&right) = 2; break;
7668 case VT_UI8: V_UI8(&right) = 2; break;
7669 case VT_INT: V_INT(&right) = 2; break;
7670 case VT_UINT: V_UINT(&right) = 2; break;
7671 default: break;
7672 }
7673
7674 /* Native VarIdiv always returns an error when using extra
7675 * flags or if the variant combination is I8 and INT.
7676 */
7677 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
7678 (leftvt == VT_INT && rightvt == VT_I8) ||
7679 (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
7680 ExtraFlags[i] != 0)
7681 bFail = TRUE;
7682
7683 /* Determine variant type */
7684 else if (leftvt == VT_NULL || rightvt == VT_NULL)
7685 resvt = VT_NULL;
7686 else if (leftvt == VT_I8 || rightvt == VT_I8)
7687 resvt = VT_I8;
7688 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
7689 leftvt == VT_INT || rightvt == VT_INT ||
7690 leftvt == VT_UINT || rightvt == VT_UINT ||
7691 leftvt == VT_UI8 || rightvt == VT_UI8 ||
7692 leftvt == VT_UI4 || rightvt == VT_UI4 ||
7693 leftvt == VT_UI2 || rightvt == VT_UI2 ||
7694 leftvt == VT_I1 || rightvt == VT_I1 ||
7695 leftvt == VT_BSTR || rightvt == VT_BSTR ||
7696 leftvt == VT_DATE || rightvt == VT_DATE ||
7697 leftvt == VT_CY || rightvt == VT_CY ||
7698 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
7699 leftvt == VT_R8 || rightvt == VT_R8 ||
7700 leftvt == VT_R4 || rightvt == VT_R4)
7701 resvt = VT_I4;
7702 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
7703 leftvt == VT_BOOL || rightvt == VT_BOOL ||
7704 leftvt == VT_EMPTY)
7705 resvt = VT_I2;
7706 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
7707 resvt = VT_UI1;
7708 else
7709 bFail = TRUE;
7710
7711 hres = pVarIdiv(&left, &right, &result);
7712
7713 /* Check expected HRESULT and if result variant type is correct */
7714 if (bFail)
7715 ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH ||
7716 hres == DISP_E_DIVBYZERO,
7717 "VarIdiv: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
7718 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
7719 vtstr(V_VT(&result)), hres);
7720 else
7721 ok (hres == S_OK && resvt == V_VT(&result),
7722 "VarIdiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
7723 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
7724 S_OK, vtstr(V_VT(&result)), hres);
7725 }
7726 }
7727 }
7728
7729 /* Test return values for all the good cases */
7730 VARIDIV(EMPTY,0,NULL,0,NULL,0);
7731 VARIDIV(EMPTY,0,I2,1,I2,0);
7732 VARIDIV(EMPTY,0,I4,1,I4,0);
7733 VARIDIV(EMPTY,0,R4,1.0f,I4,0);
7734 VARIDIV(EMPTY,0,R8,1.0,I4,0);
7735 VARIDIV(EMPTY,0,DATE,1.0,I4,0);
7736 VARIDIV(EMPTY,0,BSTR,num1_str,I4,0);
7737 VARIDIV(EMPTY,0,BOOL,VARIANT_TRUE,I2,0);
7738 VARIDIV(EMPTY,0,I1,1,I4,0);
7739 VARIDIV(EMPTY,0,UI1,1,I2,0);
7740 VARIDIV(EMPTY,0,UI2,1,I4,0);
7741 VARIDIV(EMPTY,0,UI4,1,I4,0);
7742 if (HAVE_OLEAUT32_I8)
7743 {
7744 VARIDIV(EMPTY,0,I8,1,I8,0);
7745 VARIDIV(EMPTY,0,UI8,1,I4,0);
7746 }
7747 VARIDIV(EMPTY,0,INT,1,I4,0);
7748 VARIDIV(EMPTY,0,UINT,1,I4,0);
7749 VARIDIV(NULL,0,EMPTY,0,NULL,0);
7750 VARIDIV(NULL,0,NULL,0,NULL,0);
7751 VARIDIV(NULL,0,I2,1,NULL,0);
7752 VARIDIV(NULL,0,I4,1,NULL,0);
7753 VARIDIV(NULL,0,R4,1,NULL,0);
7754 VARIDIV(NULL,0,R8,1,NULL,0);
7755 VARIDIV(NULL,0,DATE,1,NULL,0);
7756 VARIDIV(NULL,0,BSTR,num1_str,NULL,0);
7757 VARIDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
7758 VARIDIV(NULL,0,I1,1,NULL,0);
7759 VARIDIV(NULL,0,UI1,1,NULL,0);
7760 VARIDIV(NULL,0,UI2,1,NULL,0);
7761 VARIDIV(NULL,0,UI4,1,NULL,0);
7762 if (HAVE_OLEAUT32_I8)
7763 {
7764 VARIDIV(NULL,0,I8,1,NULL,0);
7765 VARIDIV(NULL,0,UI8,1,NULL,0);
7766 }
7767 VARIDIV(NULL,0,INT,1,NULL,0);
7768 VARIDIV(NULL,0,UINT,1,NULL,0);
7769 VARIDIV(I2,2,NULL,0,NULL,0);
7770 VARIDIV(I2,2,I2,1,I2,2);
7771 VARIDIV(I2,2,I4,1,I4,2);
7772 VARIDIV(I2,2,R4,1,I4,2);
7773 VARIDIV(I2,2,R8,1,I4,2);
7774 VARIDIV(I2,2,DATE,1,I4,2);
7775 VARIDIV(I2,2,BSTR,num1_str,I4,2);
7776 VARIDIV(I2,2,BOOL,VARIANT_TRUE,I2,-2);
7777 VARIDIV(I2,2,I1,1,I4,2);
7778 VARIDIV(I2,2,UI1,1,I2,2);
7779 VARIDIV(I2,2,UI2,1,I4,2);
7780 VARIDIV(I2,2,UI4,1,I4,2);
7781 if (HAVE_OLEAUT32_I8)
7782 {
7783 VARIDIV(I2,2,I8,1,I8,2);
7784 VARIDIV(I2,2,UI8,1,I4,2);
7785 }
7786 VARIDIV(I2,2,INT,1,I4,2);
7787 VARIDIV(I2,2,UINT,1,I4,2);
7788 VARIDIV(I4,2,NULL,0,NULL,0);
7789 VARIDIV(I4,2,I2,1,I4,2);
7790 VARIDIV(I4,2,I4,1,I4,2);
7791 VARIDIV(I4,2,R4,1,I4,2);
7792 VARIDIV(I4,2,R8,1,I4,2);
7793 VARIDIV(I4,2,DATE,1,I4,2);
7794 VARIDIV(I4,2,BSTR,num1_str,I4,2);
7795 VARIDIV(I4,2,BOOL,VARIANT_TRUE,I4,-2);
7796 VARIDIV(I4,2,I1,1,I4,2);
7797 VARIDIV(I4,2,UI1,1,I4,2);
7798 VARIDIV(I4,2,UI2,1,I4,2);
7799 VARIDIV(I4,2,UI4,1,I4,2);
7800 if (HAVE_OLEAUT32_I8)
7801 {
7802 VARIDIV(I4,2,I8,1,I8,2);
7803 VARIDIV(I4,2,UI8,1,I4,2);
7804 }
7805 VARIDIV(I4,2,INT,1,I4,2);
7806 VARIDIV(I4,2,UINT,1,I4,2);
7807 VARIDIV(R4,2.0f,NULL,0,NULL,0);
7808 VARIDIV(R4,2.0f,I2,1,I4,2);
7809 VARIDIV(R4,2.0f,I4,1,I4,2);
7810 VARIDIV(R4,2.0f,R4,1.0f,I4,2);
7811 VARIDIV(R4,2.0f,R8,1.0,I4,2);
7812 VARIDIV(R4,2.0f,DATE,1,I4,2);
7813 VARIDIV(R4,2.0f,BSTR,num1_str,I4,2);
7814 VARIDIV(R4,2.0f,BOOL,VARIANT_TRUE,I4,-2);
7815 VARIDIV(R4,2.0f,I1,1,I4,2);
7816 VARIDIV(R4,2.0f,UI1,1,I4,2);
7817 VARIDIV(R4,2.0f,UI2,1,I4,2);
7818 VARIDIV(R4,2.0f,UI4,1,I4,2);
7819 if (HAVE_OLEAUT32_I8)
7820 {
7821 VARIDIV(R4,2.0f,I8,1,I8,2);
7822 VARIDIV(R4,2.0f,UI8,1,I4,2);
7823 }
7824 VARIDIV(R4,2.0f,INT,1,I4,2);
7825 VARIDIV(R4,2.0f,UINT,1,I4,2);
7826 VARIDIV(R8,2.0,NULL,0,NULL,0);
7827 VARIDIV(R8,2.0,I2,1,I4,2);
7828 VARIDIV(R8,2.0,I4,1,I4,2);
7829 VARIDIV(R8,2.0,R4,1,I4,2);
7830 VARIDIV(R8,2.0,R8,1,I4,2);
7831 VARIDIV(R8,2.0,DATE,1,I4,2);
7832 VARIDIV(R8,2.0,BSTR,num1_str,I4,2);
7833 VARIDIV(R8,2.0,BOOL,VARIANT_TRUE,I4,-2);
7834 VARIDIV(R8,2.0,I1,1,I4,2);
7835 VARIDIV(R8,2.0,UI1,1,I4,2);
7836 VARIDIV(R8,2.0,UI2,1,I4,2);
7837 VARIDIV(R8,2.0,UI4,1,I4,2);
7838 if (HAVE_OLEAUT32_I8)
7839 {
7840 VARIDIV(R8,2.0,I8,1,I8,2);
7841 VARIDIV(R8,2.0,UI8,1,I4,2);
7842 }
7843 VARIDIV(R8,2.0,INT,1,I4,2);
7844 VARIDIV(R8,2.0,UINT,1,I4,2);
7845 VARIDIV(DATE,2,NULL,0,NULL,0);
7846 VARIDIV(DATE,2,I2,1,I4,2);
7847 VARIDIV(DATE,2,I4,1,I4,2);
7848 VARIDIV(DATE,2,R4,1,I4,2);
7849 VARIDIV(DATE,2,R8,1,I4,2);
7850 VARIDIV(DATE,2,DATE,1,I4,2);
7851 VARIDIV(DATE,2,BSTR,num1_str,I4,2);
7852 VARIDIV(DATE,2,BOOL,VARIANT_TRUE,I4,-2);
7853 VARIDIV(DATE,2,I1,1,I4,2);
7854 VARIDIV(DATE,2,UI1,1,I4,2);
7855 VARIDIV(DATE,2,UI2,1,I4,2);
7856 VARIDIV(DATE,2,UI4,1,I4,2);
7857 if (HAVE_OLEAUT32_I8)
7858 {
7859 VARIDIV(DATE,2,I8,1,I8,2);
7860 VARIDIV(DATE,2,UI8,1,I4,2);
7861 }
7862 VARIDIV(DATE,2,INT,1,I4,2);
7863 VARIDIV(DATE,2,UINT,1,I4,2);
7864 VARIDIV(BSTR,num2_str,NULL,0,NULL,0);
7865 VARIDIV(BSTR,num2_str,I2,1,I4,2);
7866 VARIDIV(BSTR,num2_str,I4,1,I4,2);
7867 VARIDIV(BSTR,num2_str,R4,1.0f,I4,2);
7868 VARIDIV(BSTR,num2_str,R8,1.0,I4,2);
7869 VARIDIV(BSTR,num2_str,DATE,1,I4,2);
7870 VARIDIV(BSTR,num2_str,BSTR,num1_str,I4,2);
7871 VARIDIV(BSTR,num2_str,BOOL,VARIANT_TRUE,I4,-2);
7872 VARIDIV(BSTR,num2_str,I1,1,I4,2);
7873 VARIDIV(BSTR,num2_str,UI1,1,I4,2);
7874 VARIDIV(BSTR,num2_str,UI2,1,I4,2);
7875 VARIDIV(BSTR,num2_str,UI4,1,I4,2);
7876 if (HAVE_OLEAUT32_I8)
7877 {
7878 VARIDIV(BSTR,num2_str,I8,1,I8,2);
7879 VARIDIV(BSTR,num2_str,UI8,1,I4,2);
7880 }
7881 VARIDIV(BSTR,num2_str,INT,1,I4,2);
7882 VARIDIV(BSTR,num2_str,UINT,1,I4,2);
7883 VARIDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
7884 VARIDIV(BOOL,VARIANT_TRUE,I2,1,I2,-1);
7885 VARIDIV(BOOL,VARIANT_TRUE,I4,1,I4,-1);
7886 VARIDIV(BOOL,VARIANT_TRUE,R4,1.0f,I4,-1);
7887 VARIDIV(BOOL,VARIANT_TRUE,R8,1.0,I4,-1);
7888 VARIDIV(BOOL,VARIANT_TRUE,DATE,1,I4,-1);
7889 VARIDIV(BOOL,VARIANT_TRUE,BSTR,num1_str,I4,-1);
7890 VARIDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,I2,1);
7891 VARIDIV(BOOL,VARIANT_TRUE,I1,1,I4,-1);
7892 VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
7893 VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
7894 VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
7895 if (HAVE_OLEAUT32_I8)
7896 {
7897 VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
7898 VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
7899 }
7900 VARIDIV(BOOL,VARIANT_TRUE,INT,1,I4,-1);
7901 VARIDIV(BOOL,VARIANT_TRUE,UINT,1,I4,-1);
7902 VARIDIV(I1,2,NULL,0,NULL,0);
7903 VARIDIV(I1,2,I2,1,I4,2);
7904 VARIDIV(I1,2,I4,1,I4,2);
7905 VARIDIV(I1,2,R4,1.0f,I4,2);
7906 VARIDIV(I1,2,R8,1.0,I4,2);
7907 VARIDIV(I1,2,DATE,1,I4,2);
7908 VARIDIV(I1,2,BSTR,num1_str,I4,2);
7909 VARIDIV(I1,2,BOOL,VARIANT_TRUE,I4,-2);
7910 VARIDIV(I1,2,I1,1,I4,2);
7911 VARIDIV(I1,2,UI1,1,I4,2);
7912 VARIDIV(I1,2,UI2,1,I4,2);
7913 VARIDIV(I1,2,UI4,1,I4,2);
7914 if (HAVE_OLEAUT32_I8)
7915 {
7916 VARIDIV(I1,2,I8,1,I8,2);
7917 VARIDIV(I1,2,UI8,1,I4,2);
7918 }
7919 VARIDIV(I1,2,INT,1,I4,2);
7920 VARIDIV(I1,2,UINT,1,I4,2);
7921 VARIDIV(UI1,2,NULL,0,NULL,0);
7922 VARIDIV(UI1,2,I2,1,I2,2);
7923 VARIDIV(UI1,2,I4,1,I4,2);
7924 VARIDIV(UI1,2,R4,1.0f,I4,2);
7925 VARIDIV(UI1,2,R8,1.0,I4,2);
7926 VARIDIV(UI1,2,DATE,1,I4,2);
7927 VARIDIV(UI1,2,BSTR,num1_str,I4,2);
7928 VARIDIV(UI1,2,BOOL,VARIANT_TRUE,I2,-2);
7929 VARIDIV(UI1,2,I1,1,I4,2);
7930 VARIDIV(UI1,2,UI1,1,UI1,2);
7931 VARIDIV(UI1,2,UI2,1,I4,2);
7932 VARIDIV(UI1,2,UI4,1,I4,2);
7933 if (HAVE_OLEAUT32_I8)
7934 {
7935 VARIDIV(UI1,2,I8,1,I8,2);
7936 VARIDIV(UI1,2,UI8,1,I4,2);
7937 }
7938 VARIDIV(UI1,2,INT,1,I4,2);
7939 VARIDIV(UI1,2,UINT,1,I4,2);
7940 VARIDIV(UI2,2,NULL,0,NULL,0);
7941 VARIDIV(UI2,2,I2,1,I4,2);
7942 VARIDIV(UI2,2,I4,1,I4,2);
7943 VARIDIV(UI2,2,R4,1.0f,I4,2);
7944 VARIDIV(UI2,2,R8,1.0,I4,2);
7945 VARIDIV(UI2,2,DATE,1,I4,2);
7946 VARIDIV(UI2,2,BSTR,num1_str,I4,2);
7947 VARIDIV(UI2,2,BOOL,VARIANT_TRUE,I4,-2);
7948 VARIDIV(UI2,2,I1,1,I4,2);
7949 VARIDIV(UI2,2,UI1,1,I4,2);
7950 VARIDIV(UI2,2,UI2,1,I4,2);
7951 VARIDIV(UI2,2,UI4,1,I4,2);
7952 if (HAVE_OLEAUT32_I8)
7953 {
7954 VARIDIV(UI2,2,I8,1,I8,2);
7955 VARIDIV(UI2,2,UI8,1,I4,2);
7956 }
7957 VARIDIV(UI2,2,INT,1,I4,2);
7958 VARIDIV(UI2,2,UINT,1,I4,2);
7959 VARIDIV(UI4,2,NULL,0,NULL,0);
7960 VARIDIV(UI4,2,I2,1,I4,2);
7961 VARIDIV(UI4,2,I4,1,I4,2);
7962 VARIDIV(UI4,2,R4,1.0f,I4,2);
7963 VARIDIV(UI4,2,R8,1.0,I4,2);
7964 VARIDIV(UI4,2,DATE,1,I4,2);
7965 VARIDIV(UI4,2,BSTR,num1_str,I4,2);
7966 VARIDIV(UI4,2,BOOL,VARIANT_TRUE,I4,-2);
7967 VARIDIV(UI4,2,I1,1,I4,2);
7968 VARIDIV(UI4,2,UI1,1,I4,2);
7969 VARIDIV(UI4,2,UI2,1,I4,2);
7970 VARIDIV(UI4,2,UI4,1,I4,2);
7971 if (HAVE_OLEAUT32_I8)
7972 {
7973 VARIDIV(UI4,2,I8,1,I8,2);
7974 VARIDIV(UI4,2,UI8,1,I4,2);
7975 }
7976 VARIDIV(UI4,2,INT,1,I4,2);
7977 VARIDIV(UI4,2,UINT,1,I4,2);
7978 if (HAVE_OLEAUT32_I8)
7979 {
7980 VARIDIV(I8,2,NULL,0,NULL,0);
7981 VARIDIV(I8,2,I2,1,I8,2);
7982 VARIDIV(I8,2,I4,1,I8,2);
7983 VARIDIV(I8,2,R4,1.0f,I8,2);
7984 VARIDIV(I8,2,R8,1.0,I8,2);
7985 VARIDIV(I8,2,DATE,1,I8,2);
7986 VARIDIV(I8,2,BSTR,num1_str,I8,2);
7987 VARIDIV(I8,2,BOOL,1,I8,2);
7988 VARIDIV(I8,2,I1,1,I8,2);
7989 VARIDIV(I8,2,UI1,1,I8,2);
7990 VARIDIV(I8,2,UI2,1,I8,2);
7991 VARIDIV(I8,2,UI4,1,I8,2);
7992 VARIDIV(I8,2,I8,1,I8,2);
7993 VARIDIV(I8,2,UI8,1,I8,2);
7994 VARIDIV(I8,2,UINT,1,I8,2);
7995 VARIDIV(UI8,2,NULL,0,NULL,0);
7996 VARIDIV(UI8,2,I2,1,I4,2);
7997 VARIDIV(UI8,2,I4,1,I4,2);
7998 VARIDIV(UI8,2,R4,1.0f,I4,2);
7999 VARIDIV(UI8,2,R8,1.0,I4,2);
8000 VARIDIV(UI8,2,DATE,1,I4,2);
8001 VARIDIV(UI8,2,BSTR,num1_str,I4,2);
8002 VARIDIV(UI8,2,BOOL,VARIANT_TRUE,I4,-2);
8003 VARIDIV(UI8,2,I1,1,I4,2);
8004 VARIDIV(UI8,2,UI1,1,I4,2);
8005 VARIDIV(UI8,2,UI2,1,I4,2);
8006 VARIDIV(UI8,2,UI4,1,I4,2);
8007 VARIDIV(UI8,2,I8,1,I8,2);
8008 VARIDIV(UI8,2,UI8,1,I4,2);
8009 VARIDIV(UI8,2,INT,1,I4,2);
8010 VARIDIV(UI8,2,UINT,1,I4,2);
8011 }
8012 VARIDIV(INT,2,NULL,0,NULL,0);
8013 VARIDIV(INT,2,I2,1,I4,2);
8014 VARIDIV(INT,2,I4,1,I4,2);
8015 VARIDIV(INT,2,R4,1.0f,I4,2);
8016 VARIDIV(INT,2,R8,1.0,I4,2);
8017 VARIDIV(INT,2,DATE,1,I4,2);
8018 VARIDIV(INT,2,BSTR,num1_str,I4,2);
8019 VARIDIV(INT,2,BOOL,VARIANT_TRUE,I4,-2);
8020 VARIDIV(INT,2,I1,1,I4,2);
8021 VARIDIV(INT,2,UI1,1,I4,2);
8022 VARIDIV(INT,2,UI2,1,I4,2);
8023 VARIDIV(INT,2,UI4,1,I4,2);
8024 if (HAVE_OLEAUT32_I8)
8025 {
8026 VARIDIV(INT,2,UI8,1,I4,2);
8027 }
8028 VARIDIV(INT,2,INT,1,I4,2);
8029 VARIDIV(INT,2,UINT,1,I4,2);
8030 VARIDIV(UINT,2,NULL,0,NULL,0);
8031 VARIDIV(UINT,2,I2,1,I4,2);
8032 VARIDIV(UINT,2,I4,1,I4,2);
8033 VARIDIV(UINT,2,R4,1.0f,I4,2);
8034 VARIDIV(UINT,2,R8,1.0,I4,2);
8035 VARIDIV(UINT,2,DATE,1,I4,2);
8036 VARIDIV(UINT,2,BSTR,num1_str,I4,2);
8037 VARIDIV(UINT,2,BOOL,VARIANT_TRUE,I4,-2);
8038 VARIDIV(UINT,2,I1,1,I4,2);
8039 VARIDIV(UINT,2,UI1,1,I4,2);
8040 VARIDIV(UINT,2,UI2,1,I4,2);
8041 VARIDIV(UINT,2,UI4,1,I4,2);
8042 if (HAVE_OLEAUT32_I8)
8043 {
8044 VARIDIV(UINT,2,I8,1,I8,2);
8045 VARIDIV(UINT,2,UI8,1,I4,2);
8046 }
8047 VARIDIV(UINT,2,INT,1,I4,2);
8048 VARIDIV(UINT,2,UINT,1,I4,2);
8049
8050 /* Manually test some VT_CY, VT_DECIMAL variants */
8051 V_VT(&cy) = VT_CY;
8052 hres = VarCyFromI4(10000, &V_CY(&cy));
8053 ok(hres == S_OK, "VarCyFromI4 failed!\n");
8054 V_VT(&dec) = VT_DECIMAL;
8055 hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8056 ok(hres == S_OK, "VarDecFromR4 failed!\n");
8057 memset(&left, 0, sizeof(left));
8058 memset(&right, 0, sizeof(right));
8059 V_VT(&left) = VT_I4;
8060 V_I4(&left) = 100;
8061 V_VT(&right) = VT_I8;
8062 V_UI1(&right) = 2;
8063
8064 hres = pVarIdiv(&cy, &cy, &result);
8065 ok(hres == S_OK && V_VT(&result) == VT_I4,
8066 "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8067 S_OK, hres, vtstr(V_VT(&result)));
8068 ok(hres == S_OK && V_I4(&result) == 1,
8069 "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
8070
8071 if (HAVE_OLEAUT32_I8)
8072 {
8073 hres = pVarIdiv(&cy, &right, &result);
8074 ok(hres == S_OK && V_VT(&result) == VT_I8,
8075 "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8076 S_OK, hres, vtstr(V_VT(&result)));
8077 ok(hres == S_OK && V_I8(&result) == 5000,
8078 "VARIDIV: CY value 0x%x%08x, expected 0x%x\n",
8079 (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), 5000);
8080 }
8081
8082 hres = pVarIdiv(&left, &cy, &result);
8083 ok(hres == S_OK && V_VT(&result) == VT_I4,
8084 "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8085 S_OK, hres, vtstr(V_VT(&result)));
8086 ok(hres == S_OK && V_I4(&result) == 0,
8087 "VARIDIV: CY value %d, expected %d\n", V_I4(&result), 0);
8088
8089 hres = pVarIdiv(&left, &dec, &result);
8090 ok(hres == S_OK && V_VT(&result) == VT_I4,
8091 "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8092 S_OK, hres, vtstr(V_VT(&result)));
8093 ok(hres == S_OK && V_I4(&result) == 50,
8094 "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 50);
8095
8096 hres = pVarIdiv(&dec, &dec, &result);
8097 ok(hres == S_OK && V_VT(&result) == VT_I4,
8098 "VARIDIV: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8099 S_OK, hres, vtstr(V_VT(&result)));
8100 ok(hres == S_OK && V_I4(&result) == 1,
8101 "VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
8102
8103 if (HAVE_OLEAUT32_I8)
8104 {
8105 hres = pVarIdiv(&dec, &right, &result);
8106 ok(hres == S_OK && V_VT(&result) == VT_I8,
8107 "VARIDIV: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8108 S_OK, hres, vtstr(V_VT(&result)));
8109 ok(hres == S_OK && V_I8(&result) == 1,
8110 "VARIDIV: DECIMAL value 0x%x%08x, expected %d\n",
8111 (DWORD)(V_I8(&result) >> 32), (DWORD)V_I8(&result), 1);
8112 }
8113
8114 /* Check for division by zero */
8115 V_VT(&left) = VT_INT;
8116 V_I4(&left) = 1;
8117 V_VT(&right) = VT_INT;
8118 V_I4(&right) = 0;
8119 hres = pVarIdiv(&left, &right, &result);
8120 ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8121 "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8122
8123 V_VT(&left) = VT_INT;
8124 V_I4(&left) = 0;
8125 V_VT(&right) = VT_INT;
8126 V_I4(&right) = 0;
8127 hres = pVarIdiv(&left, &right, &result);
8128 ok(hres == DISP_E_DIVBYZERO && V_VT(&result) == VT_EMPTY,
8129 "VARIDIV: Division by 0 should result in DISP_E_DIVBYZERO but got 0x%X\n", hres);
8130
8131 SysFreeString(num1_str);
8132 SysFreeString(num2_str);
8133 }
8134
8135
8136 static HRESULT (WINAPI *pVarImp)(LPVARIANT,LPVARIANT,LPVARIANT);
8137
8138 #define VARIMP(vt1,val1,vt2,val2,rvt,rval) \
8139 V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \
8140 V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
8141 V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \
8142 test_var_call2( __LINE__, pVarImp, &left, &right, &exp )
8143
8144 /* Skip any type that is not defined or produces an error for every case */
8145 #define SKIPTESTIMP(a) \
8146 if (a == VT_ERROR || a == VT_VARIANT || \
8147 a == VT_DISPATCH || a == VT_UNKNOWN || \
8148 a == VT_RECORD || a > VT_UINT || \
8149 a == 15 /*not defined*/) \
8150 continue
8151
8152 static void test_VarImp(void)
8153 {
8154 static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
8155 static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
8156 VARIANT left, right, exp, result, cy, dec;
8157 BSTR true_str, false_str;
8158 VARTYPE i;
8159 HRESULT hres;
8160
8161 CHECKPTR(VarImp);
8162
8163 true_str = SysAllocString(szTrue);
8164 false_str = SysAllocString(szFalse);
8165
8166 /* Test all possible flag/vt combinations & the resulting vt type */
8167 for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
8168 {
8169 VARTYPE leftvt, rightvt, resvt;
8170
8171 for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
8172 {
8173 SKIPTESTIMP(leftvt);
8174
8175 /* Check if we need/have support for I8 and/or UI8 */
8176 if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8177 continue;
8178
8179 for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
8180 {
8181 BOOL bFail = FALSE;
8182 SKIPTESTIMP(rightvt);
8183
8184 /* Native crashes when using the extra flag VT_BYREF
8185 * or with the following VT combinations
8186 */
8187 if ((leftvt == VT_UI4 && rightvt == VT_BSTR) ||
8188 (leftvt == VT_UI8 && rightvt == VT_BSTR) ||
8189 ExtraFlags[i] == VT_BYREF)
8190 continue;
8191
8192 /* Check if we need/have support for I8 and/or UI8 */
8193 if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
8194 continue;
8195
8196 memset(&left, 0, sizeof(left));
8197 memset(&right, 0, sizeof(right));
8198 V_VT(&left) = leftvt | ExtraFlags[i];
8199 V_VT(&right) = rightvt | ExtraFlags[i];
8200 V_VT(&result) = VT_EMPTY;
8201 resvt = VT_EMPTY;
8202
8203 if (leftvt == VT_BSTR)
8204 V_BSTR(&left) = true_str;
8205
8206 /* This allows us to test return types that are not NULL
8207 * (NULL Imp value = n, NULL Imp 0 = NULL)
8208 */
8209 switch(rightvt)
8210 {
8211 case VT_BSTR:
8212 V_BSTR(&right) = true_str;
8213 break;
8214 case VT_DECIMAL:
8215 VarDecFromR8(2.0, &V_DECIMAL(&right));
8216 V_VT(&right) = rightvt | ExtraFlags[i];
8217 break;
8218 case VT_BOOL:
8219 V_BOOL(&right) = VARIANT_TRUE;
8220 break;
8221 case VT_I1: V_I1(&right) = 2; break;
8222 case VT_I2: V_I2(&right) = 2; break;
8223 case VT_I4: V_I4(&right) = 2; break;
8224 case VT_R4: V_R4(&right) = 2.0f; break;
8225 case VT_R8: V_R8(&right) = 2.0; break;
8226 case VT_CY: V_CY(&right).int64 = 10000; break;
8227 case VT_DATE: V_DATE(&right) = 2; break;
8228 case VT_I8: V_I8(&right) = 2; break;
8229 case VT_INT: V_INT(&right) = 2; break;
8230 case VT_UINT: V_UINT(&right) = 2; break;
8231 case VT_UI1: V_UI1(&right) = 2; break;
8232 case VT_UI2: V_UI2(&right) = 2; break;
8233 case VT_UI4: V_UI4(&right) = 2; break;
8234 case VT_UI8: V_UI8(&right) = 2; break;
8235 default: break;
8236 }
8237
8238 /* Native VarImp always returns an error when using extra
8239 * flags or if the variants are I8 and INT.
8240 */
8241 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
8242 ExtraFlags[i] != 0)
8243 bFail = TRUE;
8244
8245 /* Determine result type */
8246 else if ((leftvt == VT_BSTR && rightvt == VT_NULL) ||
8247 (leftvt == VT_NULL && rightvt == VT_NULL) ||
8248 (leftvt == VT_NULL && rightvt == VT_EMPTY))
8249 resvt = VT_NULL;
8250 else if (leftvt == VT_I8 || rightvt == VT_I8)
8251 resvt = VT_I8;
8252 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
8253 leftvt == VT_INT || rightvt == VT_INT ||
8254 leftvt == VT_UINT || rightvt == VT_UINT ||
8255 leftvt == VT_UI4 || rightvt == VT_UI4 ||
8256 leftvt == VT_UI8 || rightvt == VT_UI8 ||
8257 leftvt == VT_UI2 || rightvt == VT_UI2 ||
8258 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
8259 leftvt == VT_DATE || rightvt == VT_DATE ||
8260 leftvt == VT_CY || rightvt == VT_CY ||
8261 leftvt == VT_R8 || rightvt == VT_R8 ||
8262 leftvt == VT_R4 || rightvt == VT_R4 ||
8263 leftvt == VT_I1 || rightvt == VT_I1)
8264 resvt = VT_I4;
8265 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
8266 (leftvt == VT_UI1 && rightvt == VT_NULL) ||
8267 (leftvt == VT_NULL && rightvt == VT_UI1))
8268 resvt = VT_UI1;
8269 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
8270 leftvt == VT_I2 || rightvt == VT_I2 ||
8271 leftvt == VT_UI1 || rightvt == VT_UI1)
8272 resvt = VT_I2;
8273 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
8274 leftvt == VT_BSTR || rightvt == VT_BSTR)
8275 resvt = VT_BOOL;
8276
8277 hres = pVarImp(&left, &right, &result);
8278
8279 /* Check expected HRESULT and if result variant type is correct */
8280 if (bFail)
8281 ok (hres == DISP_E_BADVARTYPE || hres == DISP_E_TYPEMISMATCH,
8282 "VarImp: %s|0x%X, %s|0x%X: got vt %s hr 0x%X\n",
8283 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i],
8284 vtstr(V_VT(&result)), hres);
8285 else
8286 ok (hres == S_OK && resvt == V_VT(&result),
8287 "VarImp: %s|0x%X, %s|0x%X: expected vt %s hr 0x%X, got vt %s hr 0x%X\n",
8288 vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
8289 S_OK, vtstr(V_VT(&result)), hres);
8290 }
8291 }
8292 }
8293
8294 VARIMP(EMPTY,0,EMPTY,0,I2,-1);
8295 VARIMP(EMPTY,0,NULL,0,I2,-1);
8296 VARIMP(EMPTY,0,I2,-1,I2,-1);
8297 VARIMP(EMPTY,0,I4,-1,I4,-1);
8298 VARIMP(EMPTY,0,R4,0.0f,I4,-1);
8299 VARIMP(EMPTY,0,R8,-1.0,I4,-1);
8300 VARIMP(EMPTY,0,DATE,0,I4,-1);
8301 VARIMP(EMPTY,0,BSTR,true_str,I2,-1);
8302 VARIMP(EMPTY,0,BOOL,VARIANT_FALSE,I2,-1);
8303 VARIMP(EMPTY,0,I1,0,I4,-1);
8304 VARIMP(EMPTY,0,UI1,1,I2,-1);
8305 VARIMP(EMPTY,0,UI2,1,I4,-1);
8306 VARIMP(EMPTY,0,UI4,1,I4,-1);
8307 if (HAVE_OLEAUT32_I8)
8308 {
8309 VARIMP(EMPTY,0,I8,1,I8,-1);
8310 VARIMP(EMPTY,0,UI8,1,I4,-1);
8311 }
8312 VARIMP(EMPTY,0,INT,-1,I4,-1);
8313 VARIMP(EMPTY,0,UINT,1,I4,-1);
8314 VARIMP(NULL,0,EMPTY,0,NULL,0);
8315 VARIMP(NULL,0,NULL,0,NULL,0);
8316 VARIMP(NULL,0,I2,-1,I2,-1);
8317 VARIMP(NULL,0,I4,-1,I4,-1);
8318 VARIMP(NULL,0,R4,0.0f,NULL,0);
8319 VARIMP(NULL,0,R8,-1.0,I4,-1);
8320 VARIMP(NULL,0,DATE,0,NULL,0);
8321 VARIMP(NULL,0,BSTR,true_str,BOOL,-1);
8322 VARIMP(NULL,0,BOOL,VARIANT_FALSE,NULL,0);
8323 VARIMP(NULL,0,I1,0,NULL,0);
8324 VARIMP(NULL,0,UI1,1,UI1,1);
8325 VARIMP(NULL,0,UI2,1,I4,1);
8326 VARIMP(NULL,0,UI4,1,I4,1);
8327 if (HAVE_OLEAUT32_I8)
8328 {
8329 VARIMP(NULL,0,I8,1,I8,1);
8330 VARIMP(NULL,0,UI8,1,I4,1);
8331 }
8332 VARIMP(NULL,0,INT,-1,I4,-1);
8333 VARIMP(NULL,0,UINT,1,I4,1);
8334 VARIMP(I2,-1,EMPTY,0,I2,0);
8335 VARIMP(I2,-1,I2,-1,I2,-1);
8336 VARIMP(I2,-1,I4,-1,I4,-1);
8337 VARIMP(I2,-1,R4,0.0f,I4,0);
8338 VARIMP(I2,-1,R8,-1.0,I4,-1);
8339 VARIMP(I2,-1,DATE,0,I4,0);
8340 VARIMP(I2,-1,BSTR,true_str,I2,-1);
8341 VARIMP(I2,-1,BOOL,VARIANT_FALSE,I2,0);
8342 VARIMP(I2,-1,I1,0,I4,0);
8343 VARIMP(I2,-1,UI1,1,I2,1);
8344 VARIMP(I2,-1,UI2,1,I4,1);
8345 VARIMP(I2,-1,UI4,1,I4,1);
8346 if (HAVE_OLEAUT32_I8)
8347 {
8348 VARIMP(I2,-1,I8,1,I8,1);
8349 VARIMP(I2,-1,UI8,1,I4,1);
8350 }
8351 VARIMP(I2,-1,INT,-1,I4,-1);
8352 VARIMP(I2,-1,UINT,1,I4,1);
8353 VARIMP(I4,2,EMPTY,0,I4,-3);
8354 VARIMP(I4,2,NULL,0,I4,-3);
8355 VARIMP(I4,2,I2,-1,I4,-1);
8356 VARIMP(I4,2,I4,-1,I4,-1);
8357 VARIMP(I4,2,R4,0.0f,I4,-3);
8358 VARIMP(I4,2,R8,-1.0,I4,-1);
8359 VARIMP(I4,2,DATE,0,I4,-3);
8360 VARIMP(I4,2,BSTR,true_str,I4,-1);
8361 VARIMP(I4,2,BOOL,VARIANT_FALSE,I4,-3);
8362 VARIMP(I4,2,I1,0,I4,-3);
8363 VARIMP(I4,2,UI1,1,I4,-3);
8364 VARIMP(I4,2,UI2,1,I4,-3);
8365 VARIMP(I4,2,UI4,1,I4,-3);
8366 if (HAVE_OLEAUT32_I8)
8367 {
8368 VARIMP(I4,2,I8,1,I8,-3);
8369 VARIMP(I4,2,UI8,1,I4,-3);
8370 }
8371 VARIMP(I4,2,INT,-1,I4,-1);
8372 VARIMP(I4,2,UINT,1,I4,-3);
8373 VARIMP(R4,-1.0f,EMPTY,0,I4,0);
8374 VARIMP(R4,-1.0f,NULL,0,NULL,0);
8375 VARIMP(R4,-1.0f,I2,-1,I4,-1);
8376 VARIMP(R4,-1.0f,I4,-1,I4,-1);
8377 VARIMP(R4,-1.0f,R4,0.0f,I4,0);
8378 VARIMP(R4,-1.0f,R8,-1.0,I4,-1);
8379 VARIMP(R4,-1.0f,DATE,1,I4,1);
8380 VARIMP(R4,-1.0f,BSTR,true_str,I4,-1);
8381 VARIMP(R4,-1.0f,BOOL,VARIANT_FALSE,I4,0);
8382 VARIMP(R4,-1.0f,I1,0,I4,0);
8383 VARIMP(R4,-1.0f,UI1,1,I4,1);
8384 VARIMP(R4,-1.0f,UI2,1,I4,1);
8385 VARIMP(R4,-1.0f,UI4,1,I4,1);
8386 if (HAVE_OLEAUT32_I8)
8387 {
8388 VARIMP(R4,-1.0f,I8,1,I8,1);
8389 VARIMP(R4,-1.0f,UI8,1,I4,1);
8390 }
8391 VARIMP(R4,-1.0f,INT,-1,I4,-1);
8392 VARIMP(R4,-1.0f,UINT,1,I4,1);
8393 VARIMP(R8,1.0,EMPTY,0,I4,-2);
8394 VARIMP(R8,1.0,NULL,0,I4,-2);
8395 VARIMP(R8,1.0,I2,-1,I4,-1);
8396 VARIMP(R8,1.0,I4,-1,I4,-1);
8397 VARIMP(R8,1.0,R4,0.0f,I4,-2);
8398 VARIMP(R8,1.0,R8,-1.0,I4,-1);
8399 VARIMP(R8,1.0,DATE,0,I4,-2);
8400 VARIMP(R8,1.0,BSTR,true_str,I4,-1);
8401 VARIMP(R8,1.0,BOOL,VARIANT_FALSE,I4,-2);
8402 VARIMP(R8,1.0,I1,0,I4,-2);
8403 VARIMP(R8,1.0,UI1,1,I4,-1);
8404 VARIMP(R8,1.0,UI2,1,I4,-1);
8405 VARIMP(R8,1.0,UI4,1,I4,-1);
8406 if (HAVE_OLEAUT32_I8)
8407 {
8408 VARIMP(R8,1.0,I8,1,I8,-1);
8409 VARIMP(R8,1.0,UI8,1,I4,-1);
8410 }
8411 VARIMP(R8,1.0,INT,-1,I4,-1);
8412 VARIMP(R8,1.0,UINT,1,I4,-1);
8413 VARIMP(DATE,0,EMPTY,0,I4,-1);
8414 VARIMP(DATE,0,NULL,0,I4,-1);
8415 VARIMP(DATE,0,I2,-1,I4,-1);
8416 VARIMP(DATE,0,I4,-1,I4,-1);
8417 VARIMP(DATE,0,R4,0.0f,I4,-1);
8418 VARIMP(DATE,0,R8,-1.0,I4,-1);
8419 VARIMP(DATE,0,DATE,0,I4,-1);
8420 VARIMP(DATE,0,BSTR,true_str,I4,-1);
8421 VARIMP(DATE,0,BOOL,VARIANT_FALSE,I4,-1);
8422 VARIMP(DATE,0,I1,0,I4,-1);
8423 VARIMP(DATE,0,UI1,1,I4,-1);
8424 VARIMP(DATE,0,UI2,1,I4,-1);
8425 VARIMP(DATE,0,UI4,1,I4,-1);
8426 if (HAVE_OLEAUT32_I8)
8427 {
8428 VARIMP(DATE,0,I8,1,I8,-1);
8429 VARIMP(DATE,0,UI8,1,I4,-1);
8430 }
8431 VARIMP(DATE,0,INT,-1,I4,-1);
8432 VARIMP(DATE,0,UINT,1,I4,-1);
8433 VARIMP(BSTR,false_str,EMPTY,0,I2,-1);
8434 VARIMP(BSTR,false_str,NULL,0,BOOL,-1);
8435 VARIMP(BSTR,false_str,I2,-1,I2,-1);
8436 VARIMP(BSTR,false_str,I4,-1,I4,-1);
8437 VARIMP(BSTR,false_str,R4,0.0f,I4,-1);
8438 VARIMP(BSTR,false_str,R8,-1.0,I4,-1);
8439 VARIMP(BSTR,false_str,DATE,0,I4,-1);
8440 VARIMP(BSTR,false_str,BSTR,true_str,BOOL,-1);
8441 VARIMP(BSTR,false_str,BOOL,VARIANT_FALSE,BOOL,-1);
8442 VARIMP(BSTR,false_str,I1,0,I4,-1);
8443 VARIMP(BSTR,false_str,UI1,1,I2,-1);
8444 VARIMP(BSTR,false_str,UI2,1,I4,-1);
8445 VARIMP(BSTR,false_str,UI4,1,I4,-1);
8446 if (HAVE_OLEAUT32_I8)
8447 {
8448 VARIMP(BSTR,false_str,I8,1,I8,-1);
8449 VARIMP(BSTR,false_str,UI8,1,I4,-1);
8450 }
8451 VARIMP(BSTR,false_str,INT,-1,I4,-1);
8452 VARIMP(BSTR,false_str,UINT,1,I4,-1);
8453 VARIMP(BOOL,VARIANT_TRUE,EMPTY,0,I2,0);
8454 VARIMP(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
8455 VARIMP(BOOL,VARIANT_TRUE,I2,-1,I2,-1);
8456 VARIMP(BOOL,VARIANT_TRUE,I4,-1,I4,-1);
8457 VARIMP(BOOL,VARIANT_TRUE,R4,0.0f,I4,0);
8458 VARIMP(BOOL,VARIANT_TRUE,R8,-1.0,I4,-1);
8459 VARIMP(BOOL,VARIANT_TRUE,DATE,0,I4,0);
8460 VARIMP(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,-1);
8461 VARIMP(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,0);
8462 VARIMP(BOOL,VARIANT_TRUE,I1,0,I4,0);
8463 VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
8464 VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
8465 VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
8466 if (HAVE_OLEAUT32_I8)
8467 {
8468 VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
8469 VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
8470 }
8471 VARIMP(BOOL,VARIANT_TRUE,INT,-1,I4,-1);
8472 VARIMP(BOOL,VARIANT_TRUE,UINT,1,I4,1);
8473 VARIMP(I1,-1,EMPTY,0,I4,0);
8474 VARIMP(I1,-1,NULL,0,NULL,0);
8475 VARIMP(I1,-1,I2,-1,I4,-1);
8476 VARIMP(I1,-1,I4,-1,I4,-1);
8477 VARIMP(I1,-1,R4,0.0f,I4,0);
8478 VARIMP(I1,-1,R8,-1.0,I4,-1);
8479 VARIMP(I1,-1,DATE,0,I4,0);
8480 VARIMP(I1,-1,BSTR,true_str,I4,-1);
8481 VARIMP(I1,-1,BOOL,VARIANT_FALSE,I4,0);
8482 VARIMP(I1,-1,I1,0,I4,0);
8483 VARIMP(I1,-1,UI1,1,I4,1);
8484 VARIMP(I1,-1,UI2,1,I4,1);
8485 VARIMP(I1,-1,UI4,1,I4,1);
8486 if (HAVE_OLEAUT32_I8)
8487 {
8488 VARIMP(I1,-1,I8,1,I8,1);
8489 VARIMP(I1,-1,UI8,1,I4,1);
8490 }
8491 VARIMP(I1,-1,INT,-1,I4,-1);
8492 VARIMP(I1,-1,UINT,1,I4,1);
8493 VARIMP(UI1,0,EMPTY,0,I2,-1);
8494 VARIMP(UI1,0,NULL,0,UI1,255);
8495 VARIMP(UI1,0,I2,-1,I2,-1);
8496 VARIMP(UI1,0,I4,-1,I4,-1);
8497 VARIMP(UI1,0,R4,0.0f,I4,-1);
8498 VARIMP(UI1,0,R8,-1.0,I4,-1);
8499 VARIMP(UI1,0,DATE,0,I4,-1);
8500 VARIMP(UI1,0,BSTR,true_str,I2,-1);
8501 VARIMP(UI1,0,BOOL,VARIANT_FALSE,I2,-1);
8502 VARIMP(UI1,0,I1,0,I4,-1);
8503 VARIMP(UI1,0,UI1,1,UI1,255);
8504 VARIMP(UI1,0,UI2,1,I4,-1);
8505 VARIMP(UI1,0,UI4,1,I4,-1);
8506 if (HAVE_OLEAUT32_I8)
8507 {
8508 VARIMP(UI1,0,I8,1,I8,-1);
8509 VARIMP(UI1,0,UI8,1,I4,-1);
8510 }
8511 VARIMP(UI1,0,INT,-1,I4,-1);
8512 VARIMP(UI1,0,UINT,1,I4,-1);
8513 VARIMP(UI2,0,EMPTY,0,I4,-1);
8514 VARIMP(UI2,0,NULL,0,I4,-1);
8515 VARIMP(UI2,0,I2,-1,I4,-1);
8516 VARIMP(UI2,0,I4,-1,I4,-1);
8517 VARIMP(UI2,0,R4,0.0f,I4,-1);
8518 VARIMP(UI2,0,R8,-1.0,I4,-1);
8519 VARIMP(UI2,0,DATE,0,I4,-1);
8520 VARIMP(UI2,0,BSTR,true_str,I4,-1);
8521 VARIMP(UI2,0,BOOL,VARIANT_FALSE,I4,-1);
8522 VARIMP(UI2,0,I1,0,I4,-1);
8523 VARIMP(UI2,0,UI1,1,I4,-1);
8524 VARIMP(UI2,0,UI2,1,I4,-1);
8525 VARIMP(UI2,0,UI4,1,I4,-1);
8526 if (HAVE_OLEAUT32_I8)
8527 {
8528 VARIMP(UI2,0,I8,1,I8,-1);
8529 VARIMP(UI2,0,UI8,1,I4,-1);
8530 }
8531 VARIMP(UI2,0,INT,-1,I4,-1);
8532 VARIMP(UI2,0,UINT,1,I4,-1);
8533 VARIMP(UI4,0,EMPTY,0,I4,-1);
8534 VARIMP(UI4,0,NULL,0,I4,-1);
8535 VARIMP(UI4,0,I2,-1,I4,-1);
8536 VARIMP(UI4,0,I4,-1,I4,-1);
8537 VARIMP(UI4,0,R4,0.0f,I4,-1);
8538 VARIMP(UI4,0,R8,-1.0,I4,-1);
8539 VARIMP(UI4,0,DATE,0,I4,-1);
8540 VARIMP(UI4,0,BSTR,true_str,I4,-1);
8541 VARIMP(UI4,0,BOOL,VARIANT_FALSE,I4,-1);
8542 VARIMP(UI4,0,I1,0,I4,-1);
8543 VARIMP(UI4,0,UI1,1,I4,-1);
8544 VARIMP(UI4,0,UI2,1,I4,-1);
8545 VARIMP(UI4,0,UI4,1,I4,-1);
8546 if (HAVE_OLEAUT32_I8)
8547 {
8548 VARIMP(UI4,0,I8,1,I8,-1);
8549 VARIMP(UI4,0,UI8,1,I4,-1);
8550 }
8551 VARIMP(UI4,0,INT,-1,I4,-1);
8552 VARIMP(UI4,0,UINT,1,I4,-1);
8553 if (HAVE_OLEAUT32_I8)
8554 {
8555 VARIMP(I8,-1,EMPTY,0,I8,0);
8556 VARIMP(I8,-1,NULL,0,NULL,0);
8557 VARIMP(I8,-1,I2,-1,I8,-1);
8558 VARIMP(I8,-1,I4,-1,I8,-1);
8559 VARIMP(I8,-1,R4,0.0f,I8,0);
8560 VARIMP(I8,-1,R8,-1.0,I8,-1);
8561 VARIMP(I8,-1,DATE,0,I8,0);
8562 VARIMP(I8,-1,BSTR,true_str,I8,-1);
8563 VARIMP(I8,-1,BOOL,VARIANT_FALSE,I8,0);
8564 VARIMP(I8,-1,I1,0,I8,0);
8565 VARIMP(I8,-1,UI1,1,I8,1);
8566 VARIMP(I8,-1,UI2,1,I8,1);
8567 VARIMP(I8,-1,UI4,1,I8,1);
8568 VARIMP(I8,-1,I8,1,I8,1);
8569 VARIMP(I8,-1,UI8,1,I8,1);
8570 VARIMP(I8,-1,UINT,1,I8,1);
8571 VARIMP(UI8,0,EMPTY,0,I4,-1);
8572 VARIMP(UI8,0,NULL,0,I4,-1);
8573 VARIMP(UI8,0,I2,-1,I4,-1);
8574 VARIMP(UI8,0,I4,-1,I4,-1);
8575 VARIMP(UI8,0,R4,0.0f,I4,-1);
8576 VARIMP(UI8,0,R8,-1.0,I4,-1);
8577 VARIMP(UI8,0,DATE,0,I4,-1);
8578 VARIMP(UI8,0,BSTR,true_str,I4,-1);
8579 VARIMP(UI8,0,BOOL,VARIANT_FALSE,I4,-1);
8580 VARIMP(UI8,0,I1,0,I4,-1);
8581 VARIMP(UI8,0,UI1,1,I4,-1);
8582 VARIMP(UI8,0,UI2,1,I4,-1);
8583 VARIMP(UI8,0,UI4,1,I4,-1);
8584 VARIMP(UI8,0,I8,1,I8,-1);
8585 VARIMP(UI8,0,UI8,1,I4,-1);
8586 VARIMP(UI8,0,INT,-1,I4,-1);
8587 VARIMP(UI8,0,UINT,1,I4,-1);
8588 }
8589 VARIMP(INT,-1,EMPTY,0,I4,0);
8590 VARIMP(INT,-1,NULL,0,NULL,0);
8591 VARIMP(INT,-1,I2,-1,I4,-1);
8592 VARIMP(INT,-1,I4,-1,I4,-1);
8593 VARIMP(INT,-1,R4,0.0f,I4,0);
8594 VARIMP(INT,-1,R8,-1.0,I4,-1);
8595 VARIMP(INT,-1,DATE,0,I4,0);
8596 VARIMP(INT,-1,BSTR,true_str,I4,-1);
8597 VARIMP(INT,-1,BOOL,VARIANT_FALSE,I4,0);
8598 VARIMP(INT,-1,I1,0,I4,0);
8599 VARIMP(INT,-1,UI1,1,I4,1);
8600 VARIMP(INT,-1,UI2,1,I4,1);
8601 VARIMP(INT,-1,UI4,1,I4,1);
8602 if (HAVE_OLEAUT32_I8)
8603 {
8604 VARIMP(INT,-1,I8,1,I8,1);
8605 VARIMP(INT,-1,UI8,1,I4,1);
8606 }
8607 VARIMP(INT,-1,INT,-1,I4,-1);
8608 VARIMP(INT,-1,UINT,1,I4,1);
8609 VARIMP(UINT,1,EMPTY,0,I4,-2);
8610 VARIMP(UINT,1,NULL,0,I4,-2);
8611 VARIMP(UINT,1,I2,-1,I4,-1);
8612 VARIMP(UINT,1,I4,-1,I4,-1);
8613 VARIMP(UINT,1,R4,0.0f,I4,-2);
8614 VARIMP(UINT,1,R8,-1.0,I4,-1);
8615 VARIMP(UINT,1,DATE,0,I4,-2);
8616 VARIMP(UINT,1,BSTR,true_str,I4,-1);
8617 VARIMP(UINT,1,BOOL,VARIANT_FALSE,I4,-2);
8618 VARIMP(UINT,1,I1,0,I4,-2);
8619 VARIMP(UINT,1,UI1,1,I4,-1);
8620 VARIMP(UINT,1,UI2,1,I4,-1);
8621 VARIMP(UINT,1,UI4,1,I4,-1);
8622 if (HAVE_OLEAUT32_I8)
8623 {
8624 VARIMP(UINT,1,I8,1,I8,-1);
8625 VARIMP(UINT,1,UI8,1,I4,-1);
8626 }
8627 VARIMP(UINT,1,INT,-1,I4,-1);
8628 VARIMP(UINT,1,UINT,1,I4,-1);
8629
8630 /* Manually test some VT_CY, VT_DECIMAL variants */
8631 V_VT(&cy) = VT_CY;
8632 hres = VarCyFromI4(1, &V_CY(&cy));
8633 ok(hres == S_OK, "VarCyFromI4 failed!\n");
8634 V_VT(&dec) = VT_DECIMAL;
8635 hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
8636 ok(hres == S_OK, "VarDecFromR4 failed!\n");
8637 memset(&left, 0, sizeof(left));
8638 memset(&right, 0, sizeof(right));
8639 V_VT(&left) = VT_I4;
8640 V_I4(&left) = 0;
8641 V_VT(&right) = VT_I8;
8642 V_UI1(&right) = 0;
8643
8644 hres = pVarImp(&cy, &cy, &result);
8645 ok(hres == S_OK && V_VT(&result) == VT_I4,
8646 "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8647 S_OK, hres, vtstr(V_VT(&result)));
8648 ok(hres == S_OK && V_I4(&result) == -1,
8649 "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8650
8651 if (HAVE_OLEAUT32_I8)
8652 {
8653 hres = pVarImp(&cy, &right, &result);
8654 ok(hres == S_OK && V_VT(&result) == VT_I8,
8655 "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8656 S_OK, hres, vtstr(V_VT(&result)));
8657 ok(hres == S_OK && V_I8(&result) == -2,
8658 "VARIMP: CY value %x%08x, expected %d\n",
8659 (DWORD)((V_I8(&result)) >> 32), (DWORD)(V_I8(&result)), -2);
8660 }
8661
8662 hres = pVarImp(&left, &cy, &result);
8663 ok(hres == S_OK && V_VT(&result) == VT_I4,
8664 "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8665 S_OK, hres, vtstr(V_VT(&result)));
8666 ok(hres == S_OK && V_I4(&result) == -1,
8667 "VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
8668
8669 hres = pVarImp(&left, &dec, &result);
8670 ok(hres == S_OK && V_VT(&result) == VT_I4,
8671 "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8672 S_OK, hres, vtstr(V_VT(&result)));
8673 ok(hres == S_OK && V_I4(&result) == -1,
8674 "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8675
8676 hres = pVarImp(&dec, &dec, &result);
8677 ok(hres == S_OK && V_VT(&result) == VT_I4,
8678 "VARIMP: expected coerced hres 0x%X type VT_I4, got hres 0x%X type %s!\n",
8679 S_OK, hres, vtstr(V_VT(&result)));
8680 ok(hres == S_OK && V_I4(&result) == -1,
8681 "VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
8682
8683 if (HAVE_OLEAUT32_I8)
8684 {
8685 hres = pVarImp(&dec, &right, &result);
8686 ok(hres == S_OK && V_VT(&result) == VT_I8,
8687 "VARIMP: expected coerced hres 0x%X type VT_I8, got hres 0x%X type %s!\n",
8688 S_OK, hres, vtstr(V_VT(&result)));
8689 ok(hres == S_OK && V_I8(&result) == -3,
8690 "VARIMP: DECIMAL value 0x%x%08x, expected %d\n",
8691 (DWORD)(V_I8(&result) >>32), (DWORD)V_I8(&result), -3);
8692 }
8693
8694 SysFreeString(false_str);
8695 SysFreeString(true_str);
8696 }
8697
8698 START_TEST(vartest)
8699 {
8700 init();
8701
8702 test_VariantInit();
8703 test_VariantClear();
8704 test_VariantCopy();
8705 test_VariantCopyInd();
8706 test_VarParseNumFromStr();
8707 test_VarNumFromParseNum();
8708 test_VarUdateFromDate();
8709 test_VarDateFromUdate();
8710 test_SystemTimeToVariantTime();
8711 test_VariantTimeToSystemTime();
8712 test_DosDateTimeToVariantTime();
8713 test_VariantTimeToDosDateTime();
8714 test_VarAbs();
8715 test_VarNot();
8716 test_VarSub();
8717 test_VarMod();
8718 test_VarFix();
8719 test_VarInt();
8720 test_VarNeg();
8721 test_VarRound();
8722 test_VarXor();
8723 test_VarOr();
8724 test_VarPow();
8725 test_VarEqv();
8726 test_VarMul();
8727 test_VarAdd();
8728 test_VarCmp(); /* Before test_VarCat() which needs VarCmp() */
8729 test_VarCat();
8730 test_VarAnd();
8731 test_VarDiv();
8732 test_VarIdiv();
8733 test_VarImp();
8734 }
GSOC 2012 project to enhance the control panel