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