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