?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11.drv: Support multiple adapter display settings in registry.
[wine.git] / dlls / oleaut32 / tests / vartype.c
blob8a498defbc0ca6546fd764449edba7e06b63acbc
1 /*
2 * Low level variant tests
3 *
4 * Copyright 2003 Jon Griffiths
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define CONST_VTABLE
22 #define COBJMACROS
23
24 #include "wine/test.h"
25 #include "oleauto.h"
26 #include <math.h>
27 #include <stdio.h>
28 #include "test_tlb.h"
29
30 #include "initguid.h"
31
32 DEFINE_GUID(UUID_test_struct, 0x4029f190, 0xca4a, 0x4611, 0xae,0xb9,0x67,0x39,0x83,0xcb,0x96,0xdd);
33
34 /* Some Visual C++ versions choke on __uint64 to float conversions.
35 * To fix this you need either VC++ 6.0 plus the processor pack
36 * or Visual C++ >=7.0.
37 */
38 #ifndef _MSC_VER
39 # define HAS_UINT64_TO_FLOAT
40 #else
41 # if _MSC_VER >= 1300
42 # define HAS_UINT64_TO_FLOAT
43 # else
44 # include <malloc.h>
45 # if defined(_mm_free)
46 /* _mm_free is defined if the Processor Pack has been installed */
47 # define HAS_UINT64_TO_FLOAT
48 # endif
49
50 # endif
51 #endif
52
53 static HMODULE hOleaut32;
54
55 /* Has I8/UI8 data type? */
56 static BOOL has_i8;
57 /* Has proper locale conversions? */
58 static BOOL has_locales;
59
60 /* Is vt a type unavailable to ancient versions? */
61 #define IS_MODERN_VTYPE(vt) (vt==VT_VARIANT||vt==VT_DECIMAL|| \
62 vt==VT_I1||vt==VT_UI2||vt==VT_UI4||vt == VT_INT||vt == VT_UINT)
63
64 /* Macros for converting and testing results */
65 #define CONVVARS(typ) HRESULT hres; CONV_TYPE out; typ in
66
67 #define _EXPECT_NO_OUT(res) ok(hres == res, "expected " #res ", got hres=0x%08x\n", hres)
68 #define EXPECT_OVERFLOW _EXPECT_NO_OUT(DISP_E_OVERFLOW)
69 #define EXPECT_MISMATCH _EXPECT_NO_OUT(DISP_E_TYPEMISMATCH)
70 #define EXPECT_BADVAR _EXPECT_NO_OUT(DISP_E_BADVARTYPE)
71 #define EXPECT_INVALID _EXPECT_NO_OUT(E_INVALIDARG)
72 #define EXPECT_LT _EXPECT_NO_OUT(VARCMP_LT)
73 #define EXPECT_GT _EXPECT_NO_OUT(VARCMP_GT)
74 #define EXPECT_EQ _EXPECT_NO_OUT(VARCMP_EQ)
75
76 #define _EXPECTRES(res, x, fs) \
77 ok(hres == S_OK && out == (CONV_TYPE)(x), "expected " #x ", got " fs "; hres=0x%08x\n", out, hres)
78 #define EXPECT(x) EXPECTRES(S_OK, (x))
79 #define EXPECT_DBL(x) \
80 ok(hres == S_OK && fabs(out-(x))<=1e-14*(x), "expected %16.16g, got %16.16g; hres=0x%08x\n", (x), out, hres)
81
82 #define CONVERT(func, val) in = val; hres = func(in, &out)
83 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT(i); };
84 #define OVERFLOWRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT_OVERFLOW; };
85
86 #define CY_MULTIPLIER 10000
87
88 #define DATE_MIN -657434
89 #define DATE_MAX 2958465
90
91 #define CONVERT_I8(func,hi,lo) in = hi; in = (in << 32) | lo; hres = func(in, &out)
92
93 #define CONVERT_CY(func,val) in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = func(in, &out)
94
95 #define CONVERT_CY64(func,hi,lo) S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = func(in, &out)
96
97 #define SETDEC(dec, scl, sgn, hi, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
98 dec.Hi32 = (ULONG)hi; U1(dec).Lo64 = (ULONG64)lo
99
100 #define SETDEC64(dec, scl, sgn, hi, mid, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
101 dec.Hi32 = (ULONG)hi; S1(U1(dec)).Mid32 = mid; S1(U1(dec)).Lo32 = lo;
102
103 #define CONVERT_DEC(func,scl,sgn,hi,lo) SETDEC(in,scl,sgn,hi,lo); hres = func(&in, &out)
104
105 #define CONVERT_DEC64(func,scl,sgn,hi,mid,lo) SETDEC64(in,scl,sgn,hi,mid,lo); hres = func(&in, &out)
106
107 #define CONVERT_BADDEC(func) \
108 CONVERT_DEC(func,29,0,0,0); EXPECT_INVALID; \
109 CONVERT_DEC(func,0,0x1,0,0); EXPECT_INVALID; \
110 CONVERT_DEC(func,0,0x40,0,0); EXPECT_INVALID; \
111 CONVERT_DEC(func,0,0x7f,0,0); EXPECT_INVALID;
112
113 #define CONVERT_STR(func,str,flags) \
114 SetLastError(0); \
115 if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,ARRAY_SIZE(buff)); \
116 hres = func(str ? buff : NULL,in,flags,&out)
117
118 #define COPYTEST(val, vt, srcval, dstval, srcref, dstref, fs) do { \
119 HRESULT hres; VARIANTARG vSrc, vDst; CONV_TYPE in = val; \
120 VariantInit(&vSrc); VariantInit(&vDst); \
121 V_VT(&vSrc) = vt; srcval = in; \
122 hres = VariantCopy(&vDst, &vSrc); \
123 ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
124 "copy hres 0x%X, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
125 V_VT(&vSrc) = vt|VT_BYREF; srcref = &in; \
126 hres = VariantCopy(&vDst, &vSrc); \
127 ok(hres == S_OK && V_VT(&vDst) == (vt|VT_BYREF) && dstref == &in, \
128 "ref hres 0x%X, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, dstref); \
129 hres = VariantCopyInd(&vDst, &vSrc); \
130 ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
131 "ind hres 0x%X, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
132 } while(0)
133
134 #define CHANGETYPEEX(typ) hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, typ)
135
136 #define TYPETEST(typ,res,fs) CHANGETYPEEX(typ); \
137 ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
138 "hres=0x%X, type=%d (should be %d(" #typ ")), value=" fs " (should be " fs ")\n", \
139 hres, V_VT(&vDst), typ, (CONV_TYPE)res, in);
140 #define TYPETESTI8(typ,res) CHANGETYPEEX(typ); \
141 ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
142 "hres=0x%X, type=%d (should be %d(" #typ ")), value=%d (should be 1)\n", \
143 hres, V_VT(&vDst), typ, (int)res);
144 #define BADVAR(typ) CHANGETYPEEX(typ); EXPECT_BADVAR
145 #define MISMATCH(typ) CHANGETYPEEX(typ); EXPECT_MISMATCH
146
147 #define INITIAL_TYPETEST(vt, val, fs) \
148 VariantInit(&vSrc); \
149 VariantInit(&vDst); \
150 V_VT(&vSrc) = vt; \
151 (val(&vSrc)) = in; \
152 TYPETEST(VT_I1, V_I1(&vDst), fs); \
153 TYPETEST(VT_UI2, V_UI2(&vDst), fs); \
154 TYPETEST(VT_UI4, V_UI4(&vDst), fs); \
155 TYPETEST(VT_INT, V_INT(&vDst), fs); \
156 TYPETEST(VT_UINT, V_UINT(&vDst), fs); \
157 TYPETEST(VT_UI1, V_UI1(&vDst), fs); \
158 TYPETEST(VT_I2, V_I2(&vDst), fs); \
159 TYPETEST(VT_I4, V_I4(&vDst), fs); \
160 TYPETEST(VT_R4, V_R4(&vDst), fs); \
161 TYPETEST(VT_R8, V_R8(&vDst), fs); \
162 TYPETEST(VT_DATE, V_DATE(&vDst), fs); \
163 if (has_i8) \
164 { \
165 TYPETEST(VT_I8, V_I8(&vDst), fs); \
166 TYPETEST(VT_UI8, V_UI8(&vDst), fs); \
167 }
168 #define NEGATIVE_TYPETEST(vt, val, fs, vtneg, valneg) \
169 in = -in; \
170 VariantInit(&vSrc); \
171 VariantInit(&vDst); \
172 V_VT(&vSrc) = vt; \
173 (val(&vSrc)) = in; \
174 TYPETEST(vtneg, valneg(&vDst), fs);
175
176 #define INITIAL_TYPETESTI8(vt, val) \
177 VariantInit(&vSrc); \
178 VariantInit(&vDst); \
179 V_VT(&vSrc) = vt; \
180 (val(&vSrc)) = in; \
181 TYPETESTI8(VT_I1, V_I1(&vDst)); \
182 TYPETESTI8(VT_UI1, V_UI1(&vDst)); \
183 TYPETESTI8(VT_I2, V_I2(&vDst)); \
184 TYPETESTI8(VT_UI2, V_UI2(&vDst)); \
185 TYPETESTI8(VT_I4, V_I4(&vDst)); \
186 TYPETESTI8(VT_UI4, V_UI4(&vDst)); \
187 TYPETESTI8(VT_INT, V_INT(&vDst)); \
188 TYPETESTI8(VT_UINT, V_UINT(&vDst)); \
189 TYPETESTI8(VT_R4, V_R4(&vDst)); \
190 TYPETESTI8(VT_R8, V_R8(&vDst)); \
191 TYPETESTI8(VT_DATE, V_DATE(&vDst)); \
192 TYPETESTI8(VT_I8, V_I8(&vDst)); \
193 TYPETESTI8(VT_UI8, V_UI8(&vDst))
194
195 #define COMMON_TYPETEST \
196 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_BOOL); \
197 ok(hres == S_OK && V_VT(&vDst) == VT_BOOL && \
198 (V_BOOL(&vDst) == VARIANT_TRUE || (V_VT(&vSrc) == VT_BOOL && V_BOOL(&vDst) == 1)), \
199 "->VT_BOOL hres=0x%X, type=%d (should be VT_BOOL), value %d (should be VARIANT_TRUE)\n", \
200 hres, V_VT(&vDst), V_BOOL(&vDst)); \
201 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_CY); \
202 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == CY_MULTIPLIER, \
203 "->VT_CY hres=0x%X, type=%d (should be VT_CY), value (%08x,%08x) (should be CY_MULTIPLIER)\n", \
204 hres, V_VT(&vDst), S(V_CY(&vDst)).Hi, S(V_CY(&vDst)).Lo); \
205 if (V_VT(&vSrc) != VT_DATE) \
206 { \
207 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_BSTR); \
208 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
209 V_BSTR(&vDst) && V_BSTR(&vDst)[0] == '1' && V_BSTR(&vDst)[1] == '\0', \
210 "->VT_BSTR hres=0x%X, type=%d (should be VT_BSTR), *bstr='%c'\n", \
211 hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?'); \
212 } \
213 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_DECIMAL); \
214 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && \
215 S(U(V_DECIMAL(&vDst))).sign == 0 && S(U(V_DECIMAL(&vDst))).scale == 0 && \
216 V_DECIMAL(&vDst).Hi32 == 0 && U1(V_DECIMAL(&vDst)).Lo64 == (ULONGLONG)in, \
217 "->VT_DECIMAL hres=0x%X, type=%d (should be VT_DECIMAL), sign=%d, scale=%d, hi=%u, lo=(%8x %8x),\n", \
218 hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign, S(U(V_DECIMAL(&vDst))).scale, \
219 V_DECIMAL(&vDst).Hi32, S1(U1(V_DECIMAL(&vDst))).Mid32, S1(U1(V_DECIMAL(&vDst))).Lo32); \
220 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_EMPTY); \
221 ok(hres == S_OK && V_VT(&vDst) == VT_EMPTY, "->VT_EMPTY hres=0x%X, type=%d (should be VT_EMPTY)\n", hres, V_VT(&vDst)); \
222 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_NULL); \
223 ok(hres == S_OK && V_VT(&vDst) == VT_NULL, "->VT_NULL hres=0x%X, type=%d (should be VT_NULL)\n", hres, V_VT(&vDst)); \
224 MISMATCH(VT_DISPATCH); \
225 MISMATCH(VT_ERROR); \
226 MISMATCH(VT_UNKNOWN); \
227 MISMATCH(VT_VARIANT); \
228 MISMATCH(VT_RECORD); \
229 BADVAR(VT_VOID); \
230 BADVAR(VT_HRESULT); \
231 BADVAR(VT_SAFEARRAY); \
232 BADVAR(VT_CARRAY); \
233 BADVAR(VT_USERDEFINED); \
234 BADVAR(VT_LPSTR); \
235 BADVAR(VT_LPWSTR); \
236 BADVAR(VT_PTR); \
237 BADVAR(VT_INT_PTR); \
238 BADVAR(VT_UINT_PTR); \
239 BADVAR(VT_FILETIME); \
240 BADVAR(VT_BLOB); \
241 BADVAR(VT_STREAM); \
242 BADVAR(VT_STORAGE); \
243 BADVAR(VT_STREAMED_OBJECT); \
244 BADVAR(VT_STORED_OBJECT); \
245 BADVAR(VT_BLOB_OBJECT); \
246 BADVAR(VT_CF); \
247 BADVAR(VT_CLSID); \
248 BADVAR(VT_BSTR_BLOB)
249
250 #define DEFINE_EXPECT(func) \
251 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
252
253 #define SET_EXPECT(func) \
254 do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
255
256 #define CHECK_EXPECT2(func) \
257 do { \
258 ok(expect_ ##func, "unexpected call " #func "\n"); \
259 called_ ## func = TRUE; \
260 }while(0)
261
262 #define CHECK_EXPECT(func) \
263 do { \
264 CHECK_EXPECT2(func); \
265 expect_ ## func = FALSE; \
266 }while(0)
267
268 #define CHECK_CALLED(func) \
269 do { \
270 ok(called_ ## func, "expected " #func "\n"); \
271 expect_ ## func = called_ ## func = FALSE; \
272 }while(0)
273
274 DEFINE_EXPECT(dispatch_invoke);
275
276 /* Internal representation of a BSTR */
277 typedef struct tagINTERNAL_BSTR
278 {
279 DWORD dwLen;
280 OLECHAR szString[1];
281 } INTERNAL_BSTR, *LPINTERNAL_BSTR;
282
283 typedef struct
284 {
285 IDispatch IDispatch_iface;
286 LONG ref;
287 VARTYPE vt;
288 BOOL bFailInvoke;
289 } DummyDispatch;
290
291 static inline DummyDispatch *impl_from_IDispatch(IDispatch *iface)
292 {
293 return CONTAINING_RECORD(iface, DummyDispatch, IDispatch_iface);
294 }
295
296 static ULONG WINAPI DummyDispatch_AddRef(IDispatch *iface)
297 {
298 DummyDispatch *This = impl_from_IDispatch(iface);
299 return InterlockedIncrement(&This->ref);
300 }
301
302 static ULONG WINAPI DummyDispatch_Release(IDispatch *iface)
303 {
304 DummyDispatch *This = impl_from_IDispatch(iface);
305 return InterlockedDecrement(&This->ref);
306 }
307
308 static HRESULT WINAPI DummyDispatch_QueryInterface(IDispatch *iface,
309 REFIID riid,
310 void** ppvObject)
311 {
312 *ppvObject = NULL;
313
314 if (IsEqualIID(riid, &IID_IDispatch) ||
315 IsEqualIID(riid, &IID_IUnknown))
316 {
317 *ppvObject = iface;
318 IDispatch_AddRef(iface);
319 }
320
321 return *ppvObject ? S_OK : E_NOINTERFACE;
322 }
323
324 static HRESULT WINAPI DummyDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
325 {
326 ok(0, "Unexpected call\n");
327 return E_NOTIMPL;
328 }
329
330 static HRESULT WINAPI DummyDispatch_GetTypeInfo(IDispatch *iface, UINT tinfo, LCID lcid, ITypeInfo **ti)
331 {
332 ok(0, "Unexpected call\n");
333 return E_NOTIMPL;
334 }
335
336 static HRESULT WINAPI DummyDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *names,
337 UINT cnames, LCID lcid, DISPID *dispid)
338 {
339 ok(0, "Unexpected call\n");
340 return E_NOTIMPL;
341 }
342
343 static HRESULT WINAPI DummyDispatch_Invoke(IDispatch *iface,
344 DISPID dispid, REFIID riid,
345 LCID lcid, WORD wFlags,
346 DISPPARAMS *params,
347 VARIANT *res,
348 EXCEPINFO *ei,
349 UINT *arg_err)
350 {
351 DummyDispatch *This = impl_from_IDispatch(iface);
352
353 CHECK_EXPECT(dispatch_invoke);
354
355 ok(dispid == DISPID_VALUE, "got dispid %d\n", dispid);
356 ok(IsEqualIID(riid, &IID_NULL), "go riid %s\n", wine_dbgstr_guid(riid));
357 ok(wFlags == DISPATCH_PROPERTYGET, "Flags wrong\n");
358
359 ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
360 ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
361 ok(params->cArgs == 0, "got %d\n", params->cArgs);
362 ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
363
364 ok(res != NULL, "got %p\n", res);
365 ok(V_VT(res) == VT_EMPTY, "got %d\n", V_VT(res));
366 ok(ei == NULL, "got %p\n", ei);
367 ok(arg_err == NULL, "got %p\n", arg_err);
368
369 if (This->bFailInvoke)
370 return E_OUTOFMEMORY;
371
372 V_VT(res) = This->vt;
373 if (This->vt == VT_UI1)
374 V_UI1(res) = 1;
375 else
376 memset(res, 0, sizeof(*res));
377
378 return S_OK;
379 }
380
381 static const IDispatchVtbl DummyDispatch_VTable =
382 {
383 DummyDispatch_QueryInterface,
384 DummyDispatch_AddRef,
385 DummyDispatch_Release,
386 DummyDispatch_GetTypeInfoCount,
387 DummyDispatch_GetTypeInfo,
388 DummyDispatch_GetIDsOfNames,
389 DummyDispatch_Invoke
390 };
391
392 static void init_test_dispatch(LONG ref, VARTYPE vt, DummyDispatch *dispatch)
393 {
394 dispatch->IDispatch_iface.lpVtbl = &DummyDispatch_VTable;
395 dispatch->ref = ref;
396 dispatch->vt = vt;
397 dispatch->bFailInvoke = FALSE;
398 }
399
400 /*
401 * VT_I1/VT_UI1
402 */
403
404 #undef CONV_TYPE
405 #define CONV_TYPE signed char
406 #undef EXPECTRES
407 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
408
409 static void test_VarI1FromI2(void)
410 {
411 CONVVARS(SHORT);
412 int i;
413
414 OVERFLOWRANGE(VarI1FromI2, -32768, -128);
415 CONVERTRANGE(VarI1FromI2, -128, 128);
416 OVERFLOWRANGE(VarI1FromI2, 129, 32768);
417 }
418
419 static void test_VarI1FromI4(void)
420 {
421 CONVVARS(LONG);
422 int i;
423
424 CONVERT(VarI1FromI4, -129); EXPECT_OVERFLOW;
425 CONVERTRANGE(VarI1FromI4, -128, 128);
426 CONVERT(VarI1FromI4, 128); EXPECT_OVERFLOW;
427 }
428
429 static void test_VarI1FromI8(void)
430 {
431 CONVVARS(LONG64);
432 int i;
433
434 CONVERT(VarI1FromI8, -129); EXPECT_OVERFLOW;
435 CONVERTRANGE(VarI1FromI8, -127, 128);
436 CONVERT(VarI1FromI8, 128); EXPECT_OVERFLOW;
437 }
438
439 static void test_VarI1FromUI1(void)
440 {
441 CONVVARS(BYTE);
442 int i;
443
444 CONVERTRANGE(VarI1FromUI1, 0, 127);
445 OVERFLOWRANGE(VarI1FromUI1, 128, 255);
446 }
447
448 static void test_VarI1FromUI2(void)
449 {
450 CONVVARS(USHORT);
451 int i;
452
453 CONVERTRANGE(VarI1FromUI2, 0, 127);
454 OVERFLOWRANGE(VarI1FromUI2, 128, 32768);
455 }
456
457 static void test_VarI1FromUI4(void)
458 {
459 CONVVARS(ULONG);
460 int i;
461
462 CONVERTRANGE(VarI1FromUI4, 0, 127);
463 CONVERT(VarI1FromUI4, 128); EXPECT_OVERFLOW;
464 }
465
466 static void test_VarI1FromUI8(void)
467 {
468 CONVVARS(ULONG64);
469 int i;
470
471 CONVERTRANGE(VarI1FromUI8, 0, 127);
472 CONVERT(VarI1FromUI8, 128); EXPECT_OVERFLOW;
473 }
474
475 static void test_VarI1FromBool(void)
476 {
477 CONVVARS(VARIANT_BOOL);
478 int i;
479
480 /* Note that conversions from bool wrap around! */
481 CONVERT(VarI1FromBool, -129); EXPECT(127);
482 CONVERTRANGE(VarI1FromBool, -128, 128);
483 CONVERT(VarI1FromBool, 128); EXPECT(-128);
484 }
485
486 static void test_VarI1FromR4(void)
487 {
488 CONVVARS(FLOAT);
489
490 CONVERT(VarI1FromR4, -129.0f); EXPECT_OVERFLOW;
491 CONVERT(VarI1FromR4, -128.51f); EXPECT_OVERFLOW;
492 CONVERT(VarI1FromR4, -128.5f); EXPECT(-128);
493 CONVERT(VarI1FromR4, -128.0f); EXPECT(-128);
494 CONVERT(VarI1FromR4, -1.0f); EXPECT(-1);
495 CONVERT(VarI1FromR4, 0.0f); EXPECT(0);
496 CONVERT(VarI1FromR4, 1.0f); EXPECT(1);
497 CONVERT(VarI1FromR4, 127.0f); EXPECT(127);
498 CONVERT(VarI1FromR4, 127.49f); EXPECT(127);
499 CONVERT(VarI1FromR4, 127.5f); EXPECT_OVERFLOW;
500 CONVERT(VarI1FromR4, 128.0f); EXPECT_OVERFLOW;
501
502 CONVERT(VarI1FromR4, -1.5f); EXPECT(-2);
503 CONVERT(VarI1FromR4, -0.6f); EXPECT(-1);
504 CONVERT(VarI1FromR4, -0.5f); EXPECT(0);
505 CONVERT(VarI1FromR4, -0.4f); EXPECT(0);
506 CONVERT(VarI1FromR4, 0.4f); EXPECT(0);
507 CONVERT(VarI1FromR4, 0.5f); EXPECT(0);
508 CONVERT(VarI1FromR4, 0.6f); EXPECT(1);
509 CONVERT(VarI1FromR4, 1.5f); EXPECT(2);
510 }
511
512 static void test_VarI1FromR8(void)
513 {
514 CONVVARS(DOUBLE);
515
516 CONVERT(VarI1FromR8, -129.0); EXPECT_OVERFLOW;
517 CONVERT(VarI1FromR8, -128.51); EXPECT_OVERFLOW;
518 CONVERT(VarI1FromR8, -128.5); EXPECT(-128);
519 CONVERT(VarI1FromR8, -128.0); EXPECT(-128);
520 CONVERT(VarI1FromR8, -1.0); EXPECT(-1);
521 CONVERT(VarI1FromR8, 0.0); EXPECT(0);
522 CONVERT(VarI1FromR8, 1.0); EXPECT(1);
523 CONVERT(VarI1FromR8, 127.0); EXPECT(127);
524 CONVERT(VarI1FromR8, 127.49); EXPECT(127);
525 CONVERT(VarI1FromR8, 127.5); EXPECT_OVERFLOW;
526 CONVERT(VarI1FromR8, 128.0); EXPECT_OVERFLOW;
527
528 CONVERT(VarI1FromR8, -1.5); EXPECT(-2);
529 CONVERT(VarI1FromR8, -0.6); EXPECT(-1);
530 CONVERT(VarI1FromR8, -0.5); EXPECT(0);
531 CONVERT(VarI1FromR8, -0.4); EXPECT(0);
532 CONVERT(VarI1FromR8, 0.4); EXPECT(0);
533 CONVERT(VarI1FromR8, 0.5); EXPECT(0);
534 CONVERT(VarI1FromR8, 0.6); EXPECT(1);
535 CONVERT(VarI1FromR8, 1.5); EXPECT(2);
536 }
537
538 static void test_VarI1FromDate(void)
539 {
540 CONVVARS(DATE);
541
542 CONVERT(VarI1FromDate, -129.0); EXPECT_OVERFLOW;
543 CONVERT(VarI1FromDate, -128.0); EXPECT(-128);
544 CONVERT(VarI1FromDate, -1.0); EXPECT(-1);
545 CONVERT(VarI1FromDate, 0.0); EXPECT(0);
546 CONVERT(VarI1FromDate, 1.0); EXPECT(1);
547 CONVERT(VarI1FromDate, 127.0); EXPECT(127);
548 CONVERT(VarI1FromDate, 128.0); EXPECT_OVERFLOW;
549
550 CONVERT(VarI1FromDate, -1.5); EXPECT(-2);
551 CONVERT(VarI1FromDate, -0.6); EXPECT(-1);
552 CONVERT(VarI1FromDate, -0.5); EXPECT(0);
553 CONVERT(VarI1FromDate, -0.4); EXPECT(0);
554 CONVERT(VarI1FromDate, 0.4); EXPECT(0);
555 CONVERT(VarI1FromDate, 0.5); EXPECT(0);
556 CONVERT(VarI1FromDate, 0.6); EXPECT(1);
557 CONVERT(VarI1FromDate, 1.5); EXPECT(2);
558 }
559
560 static void test_VarI1FromCy(void)
561 {
562 CONVVARS(CY);
563
564 CONVERT_CY(VarI1FromCy,-129); EXPECT_OVERFLOW;
565 CONVERT_CY(VarI1FromCy,-128); EXPECT(128);
566 CONVERT_CY(VarI1FromCy,-1); EXPECT(-1);
567 CONVERT_CY(VarI1FromCy,0); EXPECT(0);
568 CONVERT_CY(VarI1FromCy,1); EXPECT(1);
569 CONVERT_CY(VarI1FromCy,127); EXPECT(127);
570 CONVERT_CY(VarI1FromCy,128); EXPECT_OVERFLOW;
571
572 CONVERT_CY(VarI1FromCy,-1.5); EXPECT(-2);
573 CONVERT_CY(VarI1FromCy,-0.6); EXPECT(-1);
574 CONVERT_CY(VarI1FromCy,-0.5); EXPECT(0);
575 CONVERT_CY(VarI1FromCy,-0.4); EXPECT(0);
576 CONVERT_CY(VarI1FromCy,0.4); EXPECT(0);
577 CONVERT_CY(VarI1FromCy,0.5); EXPECT(0);
578 CONVERT_CY(VarI1FromCy,0.6); EXPECT(1);
579 CONVERT_CY(VarI1FromCy,1.5); EXPECT(2);
580 }
581
582 static void test_VarI1FromDec(void)
583 {
584 CONVVARS(DECIMAL);
585
586 CONVERT_BADDEC(VarI1FromDec);
587
588 CONVERT_DEC(VarI1FromDec,0,0x80,0,129); EXPECT_OVERFLOW;
589 CONVERT_DEC(VarI1FromDec,0,0x80,0,128); EXPECT(-128);
590 CONVERT_DEC(VarI1FromDec,0,0x80,0,1); EXPECT(-1);
591 CONVERT_DEC(VarI1FromDec,0,0,0,0); EXPECT(0);
592 CONVERT_DEC(VarI1FromDec,0,0,0,1); EXPECT(1);
593 CONVERT_DEC(VarI1FromDec,0,0,0,127); EXPECT(127);
594 CONVERT_DEC(VarI1FromDec,0,0,0,128); EXPECT_OVERFLOW;
595
596 CONVERT_DEC(VarI1FromDec,2,0x80,0,12800); EXPECT(-128);
597 CONVERT_DEC(VarI1FromDec,2,0,0,12700); EXPECT(127);
598 }
599
600 static void test_VarI1FromStr(void)
601 {
602 CONVVARS(LCID);
603 OLECHAR buff[128];
604
605 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
606
607 CONVERT_STR(VarI1FromStr,NULL, 0); EXPECT_MISMATCH;
608 CONVERT_STR(VarI1FromStr,"0", 0); EXPECT(0);
609 CONVERT_STR(VarI1FromStr,"-129", 0); EXPECT_OVERFLOW;
610 CONVERT_STR(VarI1FromStr,"-128", 0); EXPECT(-128);
611 CONVERT_STR(VarI1FromStr,"127", 0); EXPECT(127);
612 CONVERT_STR(VarI1FromStr,"128", 0); EXPECT_OVERFLOW;
613
614 CONVERT_STR(VarI1FromStr,"-1.5", LOCALE_NOUSEROVERRIDE); EXPECT(-2);
615 CONVERT_STR(VarI1FromStr,"-0.6", LOCALE_NOUSEROVERRIDE); EXPECT(-1);
616 CONVERT_STR(VarI1FromStr,"-0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
617 CONVERT_STR(VarI1FromStr,"-0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
618 CONVERT_STR(VarI1FromStr,"0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
619 CONVERT_STR(VarI1FromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
620 CONVERT_STR(VarI1FromStr,"0.6", LOCALE_NOUSEROVERRIDE); EXPECT(1);
621 CONVERT_STR(VarI1FromStr,"1.5", LOCALE_NOUSEROVERRIDE); EXPECT(2);
622 }
623
624 static void test_VarI1Copy(void)
625 {
626 COPYTEST(1, VT_I1, V_I1(&vSrc), V_I1(&vDst), V_I1REF(&vSrc), V_I1REF(&vDst), "%d");
627 }
628
629 static void test_VarI1ChangeTypeEx(void)
630 {
631 HRESULT hres;
632 signed char in;
633 VARIANTARG vSrc, vDst;
634
635 in = 1;
636
637 INITIAL_TYPETEST(VT_I1, V_I1, "%d");
638 COMMON_TYPETEST;
639 NEGATIVE_TYPETEST(VT_I1, V_I1, "%d", VT_UI1, V_UI1);
640 }
641
642 #undef CONV_TYPE
643 #define CONV_TYPE BYTE
644
645 static void test_VarUI1FromI1(void)
646 {
647 CONVVARS(signed char);
648 int i;
649
650 OVERFLOWRANGE(VarUI1FromI1, -128, 0);
651 CONVERTRANGE(VarUI1FromI1, 0, 128);
652 }
653
654 static void test_VarUI1FromI2(void)
655 {
656 CONVVARS(SHORT);
657 int i;
658
659 OVERFLOWRANGE(VarUI1FromI2, -32768, 0);
660 CONVERTRANGE(VarUI1FromI2, 0, 256);
661 OVERFLOWRANGE(VarUI1FromI2, 256, 32768);
662 }
663
664 static void test_VarUI1FromI4(void)
665 {
666 CONVVARS(LONG);
667 int i;
668
669 CONVERT(VarUI1FromI4, -1); EXPECT_OVERFLOW;
670 CONVERTRANGE(VarUI1FromI4, 0, 256);
671 CONVERT(VarUI1FromI4, 256); EXPECT_OVERFLOW;
672 }
673
674 static void test_VarUI1FromI8(void)
675 {
676 CONVVARS(LONG64);
677 int i;
678
679 CONVERT(VarUI1FromI8, -1); EXPECT_OVERFLOW;
680 CONVERTRANGE(VarUI1FromI8, 0, 256);
681 CONVERT(VarUI1FromI8, 256); EXPECT_OVERFLOW;
682 }
683
684 static void test_VarUI1FromUI2(void)
685 {
686 CONVVARS(USHORT);
687 int i;
688
689 CONVERTRANGE(VarUI1FromUI2, 0, 256);
690 OVERFLOWRANGE(VarUI1FromUI2, 256, 65536);
691 }
692
693 static void test_VarUI1FromUI4(void)
694 {
695 CONVVARS(ULONG);
696 int i;
697
698 CONVERTRANGE(VarUI1FromUI4, 0, 256);
699 CONVERT(VarUI1FromUI4, 256); EXPECT_OVERFLOW;
700 }
701
702 static void test_VarUI1FromUI8(void)
703 {
704 CONVVARS(ULONG64);
705 int i;
706
707 CONVERTRANGE(VarUI1FromUI8, 0, 256);
708 CONVERT(VarUI1FromUI8, 256); EXPECT_OVERFLOW;
709 }
710
711 static void test_VarUI1FromBool(void)
712 {
713 CONVVARS(VARIANT_BOOL);
714 int i;
715
716 /* Note that conversions from bool overflow! */
717 CONVERT(VarUI1FromBool, -1); EXPECT(255);
718 CONVERTRANGE(VarUI1FromBool, 0, 256);
719 CONVERT(VarUI1FromBool, 256); EXPECT(0);
720 }
721
722 static void test_VarUI1FromR4(void)
723 {
724 CONVVARS(FLOAT);
725
726 CONVERT(VarUI1FromR4, -1.0f); EXPECT_OVERFLOW;
727 CONVERT(VarUI1FromR4, -0.51f); EXPECT_OVERFLOW;
728 CONVERT(VarUI1FromR4, -0.5f); EXPECT(0);
729 CONVERT(VarUI1FromR4, 0.0f); EXPECT(0);
730 CONVERT(VarUI1FromR4, 1.0f); EXPECT(1);
731 CONVERT(VarUI1FromR4, 255.0f); EXPECT(255);
732 CONVERT(VarUI1FromR4, 255.49f); EXPECT(255);
733 CONVERT(VarUI1FromR4, 255.5f); EXPECT_OVERFLOW;
734 CONVERT(VarUI1FromR4, 256.0f); EXPECT_OVERFLOW;
735
736 /* Rounding */
737 CONVERT(VarUI1FromR4, -1.5f); EXPECT_OVERFLOW;
738 CONVERT(VarUI1FromR4, -0.6f); EXPECT_OVERFLOW;
739 CONVERT(VarUI1FromR4, -0.5f); EXPECT(0);
740 CONVERT(VarUI1FromR4, -0.4f); EXPECT(0);
741 CONVERT(VarUI1FromR4, 0.4f); EXPECT(0);
742 CONVERT(VarUI1FromR4, 0.5f); EXPECT(0);
743 CONVERT(VarUI1FromR4, 0.6f); EXPECT(1);
744 CONVERT(VarUI1FromR4, 1.5f); EXPECT(2);
745 }
746
747 static void test_VarUI1FromR8(void)
748 {
749 CONVVARS(DOUBLE);
750
751 CONVERT(VarUI1FromR8, -1.0); EXPECT_OVERFLOW;
752 CONVERT(VarUI1FromR8, -0.51); EXPECT_OVERFLOW;
753 CONVERT(VarUI1FromR8, -0.5); EXPECT(0);
754 CONVERT(VarUI1FromR8, 0.0); EXPECT(0);
755 CONVERT(VarUI1FromR8, 1.0); EXPECT(1);
756 CONVERT(VarUI1FromR8, 255.0); EXPECT(255);
757 CONVERT(VarUI1FromR8, 255.49); EXPECT(255);
758 CONVERT(VarUI1FromR8, 255.5); EXPECT_OVERFLOW;
759 CONVERT(VarUI1FromR8, 256.0); EXPECT_OVERFLOW;
760
761 /* Rounding */
762 CONVERT(VarUI1FromR8, -1.5); EXPECT_OVERFLOW;
763 CONVERT(VarUI1FromR8, -0.6); EXPECT_OVERFLOW;
764 CONVERT(VarUI1FromR8, -0.5); EXPECT(0);
765 CONVERT(VarUI1FromR8, -0.4); EXPECT(0);
766 CONVERT(VarUI1FromR8, 0.4); EXPECT(0);
767 CONVERT(VarUI1FromR8, 0.5); EXPECT(0);
768 CONVERT(VarUI1FromR8, 0.6); EXPECT(1);
769 CONVERT(VarUI1FromR8, 1.5); EXPECT(2);
770 }
771
772 static void test_VarUI1FromDate(void)
773 {
774 CONVVARS(DATE);
775
776 CONVERT(VarUI1FromDate, -1.0); EXPECT_OVERFLOW;
777 CONVERT(VarUI1FromDate, 0.0); EXPECT(0);
778 CONVERT(VarUI1FromDate, 1.0); EXPECT(1);
779 CONVERT(VarUI1FromDate, 255.0); EXPECT(255);
780 CONVERT(VarUI1FromDate, 256.0); EXPECT_OVERFLOW;
781
782 /* Rounding */
783 CONVERT(VarUI1FromDate, -1.5); EXPECT_OVERFLOW;
784 CONVERT(VarUI1FromDate, -0.6); EXPECT_OVERFLOW;
785 CONVERT(VarUI1FromDate, -0.5); EXPECT(0);
786 CONVERT(VarUI1FromDate, -0.4); EXPECT(0);
787 CONVERT(VarUI1FromDate, 0.4); EXPECT(0);
788 CONVERT(VarUI1FromDate, 0.5); EXPECT(0);
789 CONVERT(VarUI1FromDate, 0.6); EXPECT(1);
790 CONVERT(VarUI1FromDate, 1.5); EXPECT(2);
791 }
792
793 static void test_VarUI1FromCy(void)
794 {
795 CONVVARS(CY);
796
797 CONVERT_CY(VarUI1FromCy,-1); EXPECT_OVERFLOW;
798 CONVERT_CY(VarUI1FromCy,0); EXPECT(0);
799 CONVERT_CY(VarUI1FromCy,1); EXPECT(1);
800 CONVERT_CY(VarUI1FromCy,255); EXPECT(255);
801 CONVERT_CY(VarUI1FromCy,256); EXPECT_OVERFLOW;
802
803 /* Rounding */
804 CONVERT_CY(VarUI1FromCy,-1.5); EXPECT_OVERFLOW;
805 CONVERT_CY(VarUI1FromCy,-0.6); EXPECT_OVERFLOW;
806 CONVERT_CY(VarUI1FromCy,-0.5); EXPECT(0);
807 CONVERT_CY(VarUI1FromCy,-0.4); EXPECT(0);
808 CONVERT_CY(VarUI1FromCy,0.4); EXPECT(0);
809 CONVERT_CY(VarUI1FromCy,0.5); EXPECT(0);
810 CONVERT_CY(VarUI1FromCy,0.6); EXPECT(1);
811 CONVERT_CY(VarUI1FromCy,1.5); EXPECT(2);
812 }
813
814 static void test_VarUI1FromDec(void)
815 {
816 CONVVARS(DECIMAL);
817
818 CONVERT_BADDEC(VarUI1FromDec);
819
820 CONVERT_DEC(VarUI1FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
821 CONVERT_DEC(VarUI1FromDec,0,0,0,0); EXPECT(0);
822 CONVERT_DEC(VarUI1FromDec,0,0,0,1); EXPECT(1);
823 CONVERT_DEC(VarUI1FromDec,0,0,0,255); EXPECT(255);
824 CONVERT_DEC(VarUI1FromDec,0,0,0,256); EXPECT_OVERFLOW;
825
826 CONVERT_DEC(VarUI1FromDec,2,0x80,0,100); EXPECT_OVERFLOW;
827 CONVERT_DEC(VarUI1FromDec,2,0,0,25500); EXPECT(255);
828 }
829
830 static void test_VarUI1FromStr(void)
831 {
832 CONVVARS(LCID);
833 OLECHAR buff[128];
834
835 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
836
837 CONVERT_STR(VarUI1FromStr,NULL, 0); EXPECT_MISMATCH;
838 CONVERT_STR(VarUI1FromStr,"0", 0); EXPECT(0);
839 CONVERT_STR(VarUI1FromStr,"-1", 0); EXPECT_OVERFLOW;
840 CONVERT_STR(VarUI1FromStr,"255", 0); EXPECT(255);
841 CONVERT_STR(VarUI1FromStr,"256", 0); EXPECT_OVERFLOW;
842
843 /* Rounding */
844 CONVERT_STR(VarUI1FromStr,"-1.5", LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
845 CONVERT_STR(VarUI1FromStr,"-0.6", LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
846 CONVERT_STR(VarUI1FromStr,"-0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
847 CONVERT_STR(VarUI1FromStr,"-0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
848 CONVERT_STR(VarUI1FromStr,"0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
849 CONVERT_STR(VarUI1FromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
850 CONVERT_STR(VarUI1FromStr,"0.6", LOCALE_NOUSEROVERRIDE); EXPECT(1);
851 CONVERT_STR(VarUI1FromStr,"1.5", LOCALE_NOUSEROVERRIDE); EXPECT(2);
852 }
853
854 static void test_VarUI1FromDisp(void)
855 {
856 DummyDispatch dispatch;
857 CONVVARS(LCID);
858 VARIANTARG vSrc, vDst;
859
860 /* FIXME
861 * Conversions from IDispatch should get the default 'value' property
862 * from the IDispatch pointer and return it. The following tests this.
863 * However, I can't get these tests to return a valid value under native
864 * oleaut32, regardless of the value returned in response to the Invoke()
865 * call (early versions of oleaut32 call AddRef/Release, but not Invoke.
866 * I'm obviously missing something, as these conversions work fine
867 * when called through VBA on an object to get its default value property.
868 *
869 * Should this test be corrected so that it works under native it should be
870 * generalised and the remaining types checked as well.
871 */
872 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
873
874 VariantInit(&vSrc);
875 VariantInit(&vDst);
876
877 init_test_dispatch(1, VT_UI1, &dispatch);
878 V_VT(&vSrc) = VT_DISPATCH;
879 V_DISPATCH(&vSrc) = &dispatch.IDispatch_iface;
880
881 SET_EXPECT(dispatch_invoke);
882 out = 10;
883 hres = VarUI1FromDisp(&dispatch.IDispatch_iface, in, &out);
884 ok(broken(hres == DISP_E_BADVARTYPE) || hres == S_OK, "got 0x%08x\n", hres);
885 ok(broken(out == 10) || out == 1, "got %d\n", out);
886 CHECK_CALLED(dispatch_invoke);
887
888 SET_EXPECT(dispatch_invoke);
889 V_VT(&vDst) = VT_EMPTY;
890 V_UI1(&vDst) = 0;
891 hres = VariantChangeTypeEx(&vDst, &vSrc, in, 0, VT_UI1);
892 ok(hres == S_OK, "got 0x%08x\n", hres);
893 ok(V_VT(&vDst) == VT_UI1, "got %d\n", V_VT(&vDst));
894 ok(V_UI1(&vDst) == 1, "got %d\n", V_UI1(&vDst));
895 CHECK_CALLED(dispatch_invoke);
896
897 dispatch.bFailInvoke = TRUE;
898
899 SET_EXPECT(dispatch_invoke);
900 out = 10;
901 hres = VarUI1FromDisp(&dispatch.IDispatch_iface, in, &out);
902 ok(hres == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hres);
903 ok(out == 10, "got %d\n", out);
904 CHECK_CALLED(dispatch_invoke);
905
906 SET_EXPECT(dispatch_invoke);
907 V_VT(&vDst) = VT_EMPTY;
908 hres = VariantChangeTypeEx(&vDst, &vSrc, in, 0, VT_UI1);
909 ok(hres == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hres);
910 ok(V_VT(&vDst) == VT_EMPTY, "got %d\n", V_VT(&vDst));
911 CHECK_CALLED(dispatch_invoke);
912 }
913
914 static void test_VarUI1Copy(void)
915 {
916 COPYTEST(1, VT_UI1, V_UI1(&vSrc), V_UI1(&vDst), V_UI1REF(&vSrc), V_UI1REF(&vDst), "%d");
917 }
918
919 static void test_VarUI1ChangeTypeEx(void)
920 {
921 HRESULT hres;
922 BYTE in;
923 VARIANTARG vSrc, vDst;
924
925 in = 1;
926
927 INITIAL_TYPETEST(VT_UI1, V_UI1, "%d");
928 COMMON_TYPETEST;
929 NEGATIVE_TYPETEST(VT_UI1, V_UI1, "%d", VT_I1, V_I1);
930 }
931
932 /*
933 * VT_I2/VT_UI2
934 */
935
936 #undef CONV_TYPE
937 #define CONV_TYPE SHORT
938
939 static void test_VarI2FromI1(void)
940 {
941 CONVVARS(signed char);
942 int i;
943
944 CONVERTRANGE(VarI2FromI1, -128, 128);
945 }
946
947 static void test_VarI2FromI4(void)
948 {
949 CONVVARS(LONG);
950 int i;
951
952 CONVERT(VarI2FromI4, -32769); EXPECT_OVERFLOW;
953 CONVERTRANGE(VarI2FromI4, -32768, 32768);
954 CONVERT(VarI2FromI4, 32768); EXPECT_OVERFLOW;
955 }
956
957 static void test_VarI2FromI8(void)
958 {
959 CONVVARS(LONG64);
960
961 CONVERT(VarI2FromI8, -32769); EXPECT_OVERFLOW;
962 CONVERT(VarI2FromI8, -32768); EXPECT(-32768);
963 CONVERT(VarI2FromI8, 32767); EXPECT(32767);
964 CONVERT(VarI2FromI8, 32768); EXPECT_OVERFLOW;
965 }
966
967 static void test_VarI2FromUI1(void)
968 {
969 CONVVARS(BYTE);
970 int i;
971
972 CONVERTRANGE(VarI2FromUI1, 0, 256);
973 }
974
975 static void test_VarI2FromUI2(void)
976 {
977 CONVVARS(USHORT);
978 int i;
979
980 CONVERTRANGE(VarI2FromUI2, 0, 32768);
981 CONVERT(VarI2FromUI2, 32768); EXPECT_OVERFLOW;
982 }
983
984 static void test_VarI2FromUI4(void)
985 {
986 CONVVARS(ULONG);
987 int i;
988
989 CONVERTRANGE(VarI2FromUI4, 0, 32768);
990 CONVERT(VarI2FromUI4, 32768); EXPECT_OVERFLOW;
991 }
992
993 static void test_VarI2FromUI8(void)
994 {
995 CONVVARS(ULONG64);
996 int i;
997
998 CONVERTRANGE(VarI2FromUI8, 0, 32768);
999 CONVERT(VarI2FromUI8, 32768); EXPECT_OVERFLOW;
1000 }
1001
1002 static void test_VarI2FromBool(void)
1003 {
1004 CONVVARS(VARIANT_BOOL);
1005 int i;
1006
1007 CONVERTRANGE(VarI2FromBool, -32768, 32768);
1008 }
1009
1010 static void test_VarI2FromR4(void)
1011 {
1012 CONVVARS(FLOAT);
1013
1014 CONVERT(VarI2FromR4, -32769.0f); EXPECT_OVERFLOW;
1015 CONVERT(VarI2FromR4, -32768.51f); EXPECT_OVERFLOW;
1016 CONVERT(VarI2FromR4, -32768.5f); EXPECT(-32768);
1017 CONVERT(VarI2FromR4, -32768.0f); EXPECT(-32768);
1018 CONVERT(VarI2FromR4, -1.0f); EXPECT(-1);
1019 CONVERT(VarI2FromR4, 0.0f); EXPECT(0);
1020 CONVERT(VarI2FromR4, 1.0f); EXPECT(1);
1021 CONVERT(VarI2FromR4, 32767.0f); EXPECT(32767);
1022 CONVERT(VarI2FromR4, 32767.49f); EXPECT(32767);
1023 CONVERT(VarI2FromR4, 32767.5f); EXPECT_OVERFLOW;
1024 CONVERT(VarI2FromR4, 32768.0f); EXPECT_OVERFLOW;
1025
1026 /* Rounding */
1027 CONVERT(VarI2FromR4, -1.5f); EXPECT(-2);
1028 CONVERT(VarI2FromR4, -0.6f); EXPECT(-1);
1029 CONVERT(VarI2FromR4, -0.5f); EXPECT(0);
1030 CONVERT(VarI2FromR4, -0.4f); EXPECT(0);
1031 CONVERT(VarI2FromR4, 0.4f); EXPECT(0);
1032 CONVERT(VarI2FromR4, 0.5f); EXPECT(0);
1033 CONVERT(VarI2FromR4, 0.6f); EXPECT(1);
1034 CONVERT(VarI2FromR4, 1.5f); EXPECT(2);
1035 }
1036
1037 static void test_VarI2FromR8(void)
1038 {
1039 CONVVARS(DOUBLE);
1040
1041 CONVERT(VarI2FromR8, -32769.0); EXPECT_OVERFLOW;
1042 CONVERT(VarI2FromR8, -32768.51); EXPECT_OVERFLOW;
1043 CONVERT(VarI2FromR8, -32768.5); EXPECT(-32768);
1044 CONVERT(VarI2FromR8, -32768.0); EXPECT(-32768);
1045 CONVERT(VarI2FromR8, -1.0); EXPECT(-1);
1046 CONVERT(VarI2FromR8, 0.0); EXPECT(0);
1047 CONVERT(VarI2FromR8, 1.0); EXPECT(1);
1048 CONVERT(VarI2FromR8, 32767.0); EXPECT(32767);
1049 CONVERT(VarI2FromR8, 32767.49); EXPECT(32767);
1050 CONVERT(VarI2FromR8, 32767.5); EXPECT_OVERFLOW;
1051 CONVERT(VarI2FromR8, 32768.0); EXPECT_OVERFLOW;
1052
1053 /* Rounding */
1054 CONVERT(VarI2FromR8, -1.5); EXPECT(-2);
1055 CONVERT(VarI2FromR8, -0.6); EXPECT(-1);
1056 CONVERT(VarI2FromR8, -0.5); EXPECT(0);
1057 CONVERT(VarI2FromR8, -0.4); EXPECT(0);
1058 CONVERT(VarI2FromR8, 0.4); EXPECT(0);
1059 CONVERT(VarI2FromR8, 0.5); EXPECT(0);
1060 CONVERT(VarI2FromR8, 0.6); EXPECT(1);
1061 CONVERT(VarI2FromR8, 1.5); EXPECT(2);
1062 }
1063
1064 static void test_VarI2FromDate(void)
1065 {
1066 CONVVARS(DATE);
1067
1068 CONVERT(VarI2FromDate, -32769.0); EXPECT_OVERFLOW;
1069 CONVERT(VarI2FromDate, -32768.0); EXPECT(-32768);
1070 CONVERT(VarI2FromDate, -1.0); EXPECT(-1);
1071 CONVERT(VarI2FromDate, 0.0); EXPECT(0);
1072 CONVERT(VarI2FromDate, 1.0); EXPECT(1);
1073 CONVERT(VarI2FromDate, 32767.0); EXPECT(32767);
1074 CONVERT(VarI2FromDate, 32768.0); EXPECT_OVERFLOW;
1075
1076 /* Rounding */
1077 CONVERT(VarI2FromDate, -1.5); EXPECT(-2);
1078 CONVERT(VarI2FromDate, -0.6); EXPECT(-1);
1079 CONVERT(VarI2FromDate, -0.5); EXPECT(0);
1080 CONVERT(VarI2FromDate, -0.4); EXPECT(0);
1081 CONVERT(VarI2FromDate, 0.4); EXPECT(0);
1082 CONVERT(VarI2FromDate, 0.5); EXPECT(0);
1083 CONVERT(VarI2FromDate, 0.6); EXPECT(1);
1084 CONVERT(VarI2FromDate, 1.5); EXPECT(2);
1085 }
1086
1087 static void test_VarI2FromCy(void)
1088 {
1089 CONVVARS(CY);
1090
1091 CONVERT_CY(VarI2FromCy,-32769); EXPECT_OVERFLOW;
1092 CONVERT_CY(VarI2FromCy,-32768); EXPECT(32768);
1093 CONVERT_CY(VarI2FromCy,-1); EXPECT(-1);
1094 CONVERT_CY(VarI2FromCy,0); EXPECT(0);
1095 CONVERT_CY(VarI2FromCy,1); EXPECT(1);
1096 CONVERT_CY(VarI2FromCy,32767); EXPECT(32767);
1097 CONVERT_CY(VarI2FromCy,32768); EXPECT_OVERFLOW;
1098
1099 /* Rounding */
1100 CONVERT_CY(VarI2FromCy,-1.5); EXPECT(-2);
1101 CONVERT_CY(VarI2FromCy,-0.6); EXPECT(-1);
1102 CONVERT_CY(VarI2FromCy,-0.5); EXPECT(0);
1103 CONVERT_CY(VarI2FromCy,-0.4); EXPECT(0);
1104 CONVERT_CY(VarI2FromCy,0.4); EXPECT(0);
1105 CONVERT_CY(VarI2FromCy,0.5); EXPECT(0);
1106 CONVERT_CY(VarI2FromCy,0.6); EXPECT(1);
1107 CONVERT_CY(VarI2FromCy,1.5); EXPECT(2);
1108 }
1109
1110 static void test_VarI2FromDec(void)
1111 {
1112 CONVVARS(DECIMAL);
1113
1114 CONVERT_BADDEC(VarI2FromDec);
1115
1116 CONVERT_DEC(VarI2FromDec,0,0x80,0,32769); EXPECT_OVERFLOW;
1117 CONVERT_DEC(VarI2FromDec,0,0x80,0,32768); EXPECT(-32768);
1118 CONVERT_DEC(VarI2FromDec,0,0x80,0,1); EXPECT(-1);
1119 CONVERT_DEC(VarI2FromDec,0,0,0,0); EXPECT(0);
1120 CONVERT_DEC(VarI2FromDec,0,0,0,1); EXPECT(1);
1121 CONVERT_DEC(VarI2FromDec,0,0,0,32767); EXPECT(32767);
1122 CONVERT_DEC(VarI2FromDec,0,0,0,32768); EXPECT_OVERFLOW;
1123
1124 CONVERT_DEC(VarI2FromDec,2,0x80,0,3276800); EXPECT(-32768);
1125 CONVERT_DEC(VarI2FromDec,2,0,0,3276700); EXPECT(32767);
1126 CONVERT_DEC(VarI2FromDec,2,0,0,3276800); EXPECT_OVERFLOW;
1127 }
1128
1129 static void test_VarI2FromStr(void)
1130 {
1131 CONVVARS(LCID);
1132 OLECHAR buff[128];
1133
1134 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1135
1136 CONVERT_STR(VarI2FromStr,NULL, 0); EXPECT_MISMATCH;
1137 CONVERT_STR(VarI2FromStr,"0", 0); EXPECT(0);
1138 CONVERT_STR(VarI2FromStr,"-32769", 0); EXPECT_OVERFLOW;
1139 CONVERT_STR(VarI2FromStr,"-32768", 0); EXPECT(-32768);
1140 CONVERT_STR(VarI2FromStr,"32767", 0); EXPECT(32767);
1141 CONVERT_STR(VarI2FromStr,"32768", 0); EXPECT_OVERFLOW;
1142
1143 /* Rounding */
1144 CONVERT_STR(VarI2FromStr,"-1.5", LOCALE_NOUSEROVERRIDE); EXPECT(-2);
1145 CONVERT_STR(VarI2FromStr,"-0.6", LOCALE_NOUSEROVERRIDE); EXPECT(-1);
1146 CONVERT_STR(VarI2FromStr,"-0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1147 CONVERT_STR(VarI2FromStr,"-0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1148 CONVERT_STR(VarI2FromStr,"0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1149 CONVERT_STR(VarI2FromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1150 CONVERT_STR(VarI2FromStr,"0.6", LOCALE_NOUSEROVERRIDE); EXPECT(1);
1151 CONVERT_STR(VarI2FromStr,"1.5", LOCALE_NOUSEROVERRIDE); EXPECT(2);
1152 }
1153
1154 static void test_VarI2Copy(void)
1155 {
1156 COPYTEST(1, VT_I2, V_I2(&vSrc), V_I2(&vDst), V_I2REF(&vSrc), V_I2REF(&vDst), "%d");
1157 }
1158
1159 static void test_VarI2ChangeTypeEx(void)
1160 {
1161 HRESULT hres;
1162 SHORT in;
1163 VARIANTARG vSrc, vDst;
1164
1165 in = 1;
1166
1167 INITIAL_TYPETEST(VT_I2, V_I2, "%d");
1168 COMMON_TYPETEST;
1169 NEGATIVE_TYPETEST(VT_I2, V_I2, "%d", VT_UI2, V_UI2);
1170 }
1171
1172 #undef CONV_TYPE
1173 #define CONV_TYPE USHORT
1174
1175 static void test_VarUI2FromI1(void)
1176 {
1177 CONVVARS(signed char);
1178 int i;
1179
1180 OVERFLOWRANGE(VarUI2FromI1, -128, 0);
1181 CONVERTRANGE(VarUI2FromI1, 0, 128);
1182 }
1183
1184 static void test_VarUI2FromI2(void)
1185 {
1186 CONVVARS(SHORT);
1187 int i;
1188
1189 OVERFLOWRANGE(VarUI2FromI2, -32768, 0);
1190 CONVERTRANGE(VarUI2FromI2, 0, 32768);
1191 }
1192
1193 static void test_VarUI2FromI4(void)
1194 {
1195 CONVVARS(LONG);
1196 int i;
1197
1198 OVERFLOWRANGE(VarUI2FromI4, -32768, 0);
1199 CONVERT(VarUI2FromI4, 0); EXPECT(0);
1200 CONVERT(VarUI2FromI4, 65535); EXPECT(65535);
1201 CONVERT(VarUI2FromI4, 65536); EXPECT_OVERFLOW;
1202 }
1203
1204 static void test_VarUI2FromI8(void)
1205 {
1206 CONVVARS(LONG64);
1207 int i;
1208
1209 OVERFLOWRANGE(VarUI2FromI8, -32768, 0);
1210 CONVERT(VarUI2FromI8, 0); EXPECT(0);
1211 CONVERT(VarUI2FromI8, 65535); EXPECT(65535);
1212 CONVERT(VarUI2FromI8, 65536); EXPECT_OVERFLOW;
1213 }
1214
1215 static void test_VarUI2FromUI1(void)
1216 {
1217 CONVVARS(BYTE);
1218 int i;
1219
1220 CONVERTRANGE(VarUI2FromUI1, 0, 256);
1221 }
1222
1223 static void test_VarUI2FromUI4(void)
1224 {
1225 CONVVARS(ULONG);
1226
1227 CONVERT(VarUI2FromUI4, 0); EXPECT(0);
1228 CONVERT(VarUI2FromUI4, 65535); EXPECT(65535);
1229 CONVERT(VarUI2FromUI4, 65536); EXPECT_OVERFLOW;
1230 }
1231
1232 static void test_VarUI2FromUI8(void)
1233 {
1234 CONVVARS(ULONG64);
1235
1236 CONVERT(VarUI2FromUI8, 0); EXPECT(0);
1237 CONVERT(VarUI2FromUI8, 65535); EXPECT(65535);
1238 CONVERT(VarUI2FromUI8, 65536); EXPECT_OVERFLOW;
1239 }
1240
1241 static void test_VarUI2FromBool(void)
1242 {
1243 CONVVARS(VARIANT_BOOL);
1244 int i;
1245
1246 CONVERT(VarUI2FromBool, -1); EXPECT(65535); /* Wraps! */
1247 CONVERTRANGE(VarUI2FromBool, 0, 32768);
1248 }
1249
1250 static void test_VarUI2FromR4(void)
1251 {
1252 CONVVARS(FLOAT);
1253
1254 CONVERT(VarUI2FromR4, -1.0f); EXPECT_OVERFLOW;
1255 CONVERT(VarUI2FromR4, -0.51f); EXPECT_OVERFLOW;
1256 CONVERT(VarUI2FromR4, -0.5f); EXPECT(0);
1257 CONVERT(VarUI2FromR4, 0.0f); EXPECT(0);
1258 CONVERT(VarUI2FromR4, 1.0f); EXPECT(1);
1259 CONVERT(VarUI2FromR4, 65535.0f); EXPECT(65535);
1260 CONVERT(VarUI2FromR4, 65535.49f); EXPECT(65535);
1261 CONVERT(VarUI2FromR4, 65535.5f); EXPECT_OVERFLOW;
1262 CONVERT(VarUI2FromR4, 65536.0f); EXPECT_OVERFLOW;
1263
1264 /* Rounding */
1265 CONVERT(VarUI2FromR4, -1.5f); EXPECT_OVERFLOW;
1266 CONVERT(VarUI2FromR4, -0.6f); EXPECT_OVERFLOW;
1267 CONVERT(VarUI2FromR4, -0.5f); EXPECT(0);
1268 CONVERT(VarUI2FromR4, -0.4f); EXPECT(0);
1269 CONVERT(VarUI2FromR4, 0.4f); EXPECT(0);
1270 CONVERT(VarUI2FromR4, 0.5f); EXPECT(0);
1271 CONVERT(VarUI2FromR4, 0.6f); EXPECT(1);
1272 CONVERT(VarUI2FromR4, 1.5f); EXPECT(2);
1273 }
1274
1275 static void test_VarUI2FromR8(void)
1276 {
1277 CONVVARS(DOUBLE);
1278
1279 CONVERT(VarUI2FromR8, -1.0); EXPECT_OVERFLOW;
1280 CONVERT(VarUI2FromR8, -0.51); EXPECT_OVERFLOW;
1281 CONVERT(VarUI2FromR8, -0.5); EXPECT(0);
1282 CONVERT(VarUI2FromR8, 0.0); EXPECT(0);
1283 CONVERT(VarUI2FromR8, 1.0); EXPECT(1);
1284 CONVERT(VarUI2FromR8, 65535.0); EXPECT(65535);
1285 CONVERT(VarUI2FromR8, 65535.49); EXPECT(65535);
1286 CONVERT(VarUI2FromR8, 65535.5); EXPECT_OVERFLOW;
1287 CONVERT(VarUI2FromR8, 65536.0); EXPECT_OVERFLOW;
1288
1289 /* Rounding */
1290 CONVERT(VarUI2FromR8, -1.5); EXPECT_OVERFLOW;
1291 CONVERT(VarUI2FromR8, -0.6); EXPECT_OVERFLOW;
1292 CONVERT(VarUI2FromR8, -0.5); EXPECT(0);
1293 CONVERT(VarUI2FromR8, -0.4); EXPECT(0);
1294 CONVERT(VarUI2FromR8, 0.4); EXPECT(0);
1295 CONVERT(VarUI2FromR8, 0.5); EXPECT(0);
1296 CONVERT(VarUI2FromR8, 0.6); EXPECT(1);
1297 CONVERT(VarUI2FromR8, 1.5); EXPECT(2);
1298 }
1299
1300 static void test_VarUI2FromDate(void)
1301 {
1302 CONVVARS(DATE);
1303
1304 CONVERT(VarUI2FromDate, -1.0); EXPECT_OVERFLOW;
1305 CONVERT(VarUI2FromDate, 0.0); EXPECT(0);
1306 CONVERT(VarUI2FromDate, 1.0); EXPECT(1);
1307 CONVERT(VarUI2FromDate, 65535.0); EXPECT(65535);
1308 CONVERT(VarUI2FromDate, 65536.0); EXPECT_OVERFLOW;
1309
1310 /* Rounding */
1311 CONVERT(VarUI2FromDate, -1.5); EXPECT_OVERFLOW;
1312 CONVERT(VarUI2FromDate, -0.6); EXPECT_OVERFLOW;
1313 CONVERT(VarUI2FromDate, -0.5); EXPECT(0);
1314 CONVERT(VarUI2FromDate, -0.4); EXPECT(0);
1315 CONVERT(VarUI2FromDate, 0.4); EXPECT(0);
1316 CONVERT(VarUI2FromDate, 0.5); EXPECT(0);
1317 CONVERT(VarUI2FromDate, 0.6); EXPECT(1);
1318 CONVERT(VarUI2FromDate, 1.5); EXPECT(2);
1319 }
1320
1321 static void test_VarUI2FromCy(void)
1322 {
1323 CONVVARS(CY);
1324
1325 CONVERT_CY(VarUI2FromCy,-1); EXPECT_OVERFLOW;
1326 CONVERT_CY(VarUI2FromCy,0); EXPECT(0);
1327 CONVERT_CY(VarUI2FromCy,1); EXPECT(1);
1328 CONVERT_CY(VarUI2FromCy,65535); EXPECT(65535);
1329 CONVERT_CY(VarUI2FromCy,65536); EXPECT_OVERFLOW;
1330
1331 /* Rounding */
1332 CONVERT_CY(VarUI2FromCy,-1.5); EXPECT_OVERFLOW;
1333 CONVERT_CY(VarUI2FromCy,-0.6); EXPECT_OVERFLOW;
1334 CONVERT_CY(VarUI2FromCy,-0.5); EXPECT(0);
1335 CONVERT_CY(VarUI2FromCy,-0.4); EXPECT(0);
1336 CONVERT_CY(VarUI2FromCy,0.4); EXPECT(0);
1337 CONVERT_CY(VarUI2FromCy,0.5); EXPECT(0);
1338 CONVERT_CY(VarUI2FromCy,0.6); EXPECT(1);
1339 CONVERT_CY(VarUI2FromCy,1.5); EXPECT(2);
1340 }
1341
1342 static void test_VarUI2FromDec(void)
1343 {
1344 CONVVARS(DECIMAL);
1345
1346 CONVERT_BADDEC(VarUI2FromDec);
1347
1348 CONVERT_DEC(VarUI2FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
1349 CONVERT_DEC(VarUI2FromDec,0,0,0,0); EXPECT(0);
1350 CONVERT_DEC(VarUI2FromDec,0,0,0,1); EXPECT(1);
1351 CONVERT_DEC(VarUI2FromDec,0,0,0,65535); EXPECT(65535);
1352 CONVERT_DEC(VarUI2FromDec,0,0,0,65536); EXPECT_OVERFLOW;
1353
1354 CONVERT_DEC(VarUI2FromDec,2,0x80,0,100); EXPECT_OVERFLOW;
1355 CONVERT_DEC(VarUI2FromDec,2,0,0,6553500); EXPECT(65535);
1356 CONVERT_DEC(VarUI2FromDec,2,0,0,6553600); EXPECT_OVERFLOW;
1357 }
1358
1359 static void test_VarUI2FromStr(void)
1360 {
1361 CONVVARS(LCID);
1362 OLECHAR buff[128];
1363
1364 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1365
1366 CONVERT_STR(VarUI2FromStr,NULL, 0); EXPECT_MISMATCH;
1367 CONVERT_STR(VarUI2FromStr,"0", 0); EXPECT(0);
1368 CONVERT_STR(VarUI2FromStr,"-1", 0); EXPECT_OVERFLOW;
1369 CONVERT_STR(VarUI2FromStr,"65535", 0); EXPECT(65535);
1370 CONVERT_STR(VarUI2FromStr,"65536", 0); EXPECT_OVERFLOW;
1371
1372 /* Rounding */
1373 CONVERT_STR(VarUI2FromStr,"-1.5", LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
1374 CONVERT_STR(VarUI2FromStr,"-0.6", LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
1375 CONVERT_STR(VarUI2FromStr,"-0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1376 CONVERT_STR(VarUI2FromStr,"-0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1377 CONVERT_STR(VarUI2FromStr,"0.4", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1378 CONVERT_STR(VarUI2FromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECT(0);
1379 CONVERT_STR(VarUI2FromStr,"0.6", LOCALE_NOUSEROVERRIDE); EXPECT(1);
1380 CONVERT_STR(VarUI2FromStr,"1.5", LOCALE_NOUSEROVERRIDE); EXPECT(2);
1381 }
1382
1383 static void test_VarUI2Copy(void)
1384 {
1385 COPYTEST(1, VT_UI2, V_UI2(&vSrc), V_UI2(&vDst), V_UI2REF(&vSrc), V_UI2REF(&vDst), "%d");
1386 }
1387
1388 static void test_VarUI2ChangeTypeEx(void)
1389 {
1390 HRESULT hres;
1391 USHORT in;
1392 VARIANTARG vSrc, vDst;
1393
1394 in = 1;
1395
1396 INITIAL_TYPETEST(VT_UI2, V_UI2, "%d");
1397 COMMON_TYPETEST;
1398 NEGATIVE_TYPETEST(VT_UI2, V_UI2, "%d", VT_I2, V_I2);
1399 }
1400
1401 /*
1402 * VT_I4/VT_UI4
1403 */
1404
1405 #undef CONV_TYPE
1406 #define CONV_TYPE LONG
1407
1408 static void test_VarI4FromI1(void)
1409 {
1410 CONVVARS(signed char);
1411 int i;
1412
1413 CONVERTRANGE(VarI4FromI1, -128, 128);
1414 }
1415
1416 static void test_VarI4FromI2(void)
1417 {
1418 CONVVARS(SHORT);
1419 int i;
1420
1421 CONVERTRANGE(VarI4FromI2, -32768, 32768);
1422 }
1423
1424 static void test_VarI4FromI8(void)
1425 {
1426 CONVVARS(LONG64);
1427
1428 CONVERT(VarI4FromI8, -1); EXPECT(-1);
1429 CONVERT(VarI4FromI8, 0); EXPECT(0);
1430 CONVERT(VarI4FromI8, 1); EXPECT(1);
1431
1432 CONVERT_I8(VarI4FromI8, -1, 2147483647ul); EXPECT_OVERFLOW;
1433 CONVERT_I8(VarI4FromI8, -1, 2147483648ul); EXPECT(-2147483647 - 1);
1434 CONVERT_I8(VarI4FromI8, 0, 2147483647ul); EXPECT(2147483647);
1435 CONVERT_I8(VarI4FromI8, 0, 2147483648ul); EXPECT_OVERFLOW;
1436 }
1437
1438 static void test_VarI4FromUI1(void)
1439 {
1440 CONVVARS(BYTE);
1441 int i;
1442
1443 CONVERTRANGE(VarI4FromUI1, 0, 256);
1444 }
1445
1446 static void test_VarI4FromUI2(void)
1447 {
1448 CONVVARS(USHORT);
1449 int i;
1450
1451 CONVERTRANGE(VarI4FromUI2, 0, 65536);
1452 }
1453
1454 static void test_VarI4FromUI4(void)
1455 {
1456 CONVVARS(ULONG);
1457
1458 CONVERT(VarI4FromUI4, 0); EXPECT(0);
1459 CONVERT(VarI4FromUI4, 1); EXPECT(1);
1460 CONVERT(VarI4FromUI4, 2147483647); EXPECT(2147483647);
1461 CONVERT(VarI4FromUI4, 2147483648ul); EXPECT_OVERFLOW;
1462 }
1463
1464 static void test_VarI4FromUI8(void)
1465 {
1466 CONVVARS(ULONG64);
1467
1468 CONVERT(VarI4FromUI8, 0); EXPECT(0);
1469 CONVERT(VarI4FromUI8, 1); EXPECT(1);
1470 CONVERT(VarI4FromUI8, 2147483647); EXPECT(2147483647);
1471 CONVERT(VarI4FromUI8, 2147483648ul); EXPECT_OVERFLOW;
1472 }
1473
1474 static void test_VarI4FromBool(void)
1475 {
1476 CONVVARS(VARIANT_BOOL);
1477 int i;
1478
1479 CONVERTRANGE(VarI4FromBool, -32768, 32768);
1480 }
1481
1482 static void test_VarI4FromR4(void)
1483 {
1484 CONVVARS(FLOAT);
1485
1486 /* min/max values are not exactly representable in a float */
1487 CONVERT(VarI4FromR4, -1.0f); EXPECT(-1);
1488 CONVERT(VarI4FromR4, 0.0f); EXPECT(0);
1489 CONVERT(VarI4FromR4, 1.0f); EXPECT(1);
1490
1491 CONVERT(VarI4FromR4, -1.5f); EXPECT(-2);
1492 CONVERT(VarI4FromR4, -0.6f); EXPECT(-1);
1493 CONVERT(VarI4FromR4, -0.5f); EXPECT(0);
1494 CONVERT(VarI4FromR4, -0.4f); EXPECT(0);
1495 CONVERT(VarI4FromR4, 0.4f); EXPECT(0);
1496 CONVERT(VarI4FromR4, 0.5f); EXPECT(0);
1497 CONVERT(VarI4FromR4, 0.6f); EXPECT(1);
1498 CONVERT(VarI4FromR4, 1.5f); EXPECT(2);
1499 }
1500
1501 static void test_VarI4FromR8(void)
1502 {
1503 CONVVARS(DOUBLE);
1504
1505 CONVERT(VarI4FromR8, -2147483649.0); EXPECT_OVERFLOW;
1506 CONVERT(VarI4FromR8, -2147483648.51); EXPECT_OVERFLOW;
1507 CONVERT(VarI4FromR8, -2147483648.5); EXPECT(-2147483647 - 1);
1508 CONVERT(VarI4FromR8, -2147483648.0); EXPECT(-2147483647 - 1);
1509 CONVERT(VarI4FromR8, -1.0); EXPECT(-1);
1510 CONVERT(VarI4FromR8, 0.0); EXPECT(0);
1511 CONVERT(VarI4FromR8, 1.0); EXPECT(1);
1512 CONVERT(VarI4FromR8, 2147483647.0); EXPECT(2147483647);
1513 CONVERT(VarI4FromR8, 2147483647.49); EXPECT(2147483647);
1514 CONVERT(VarI4FromR8, 2147483647.5); EXPECT_OVERFLOW;
1515 CONVERT(VarI4FromR8, 2147483648.0); EXPECT_OVERFLOW;
1516
1517 CONVERT(VarI4FromR8, -1.5); EXPECT(-2);
1518 CONVERT(VarI4FromR8, -0.6); EXPECT(-1);
1519 CONVERT(VarI4FromR8, -0.5); EXPECT(0);
1520 CONVERT(VarI4FromR8, -0.4); EXPECT(0);
1521 CONVERT(VarI4FromR8, 0.4); EXPECT(0);
1522 CONVERT(VarI4FromR8, 0.5); EXPECT(0);
1523 CONVERT(VarI4FromR8, 0.6); EXPECT(1);
1524 CONVERT(VarI4FromR8, 1.5); EXPECT(2);
1525 }
1526
1527 static void test_VarI4FromDate(void)
1528 {
1529 CONVVARS(DATE);
1530
1531 CONVERT(VarI4FromDate, -2147483649.0); EXPECT_OVERFLOW;
1532 CONVERT(VarI4FromDate, -2147483648.0); EXPECT(-2147483647 - 1);
1533 CONVERT(VarI4FromDate, -1.0); EXPECT(-1);
1534 CONVERT(VarI4FromDate, 0.0); EXPECT(0);
1535 CONVERT(VarI4FromDate, 1.0); EXPECT(1);
1536 CONVERT(VarI4FromDate, 2147483647.0); EXPECT(2147483647);
1537 CONVERT(VarI4FromDate, 2147483648.0); EXPECT_OVERFLOW;
1538
1539 CONVERT(VarI4FromDate, -1.5); EXPECT(-2);
1540 CONVERT(VarI4FromDate, -0.6); EXPECT(-1);
1541 CONVERT(VarI4FromDate, -0.5); EXPECT(0);
1542 CONVERT(VarI4FromDate, -0.4); EXPECT(0);
1543 CONVERT(VarI4FromDate, 0.4); EXPECT(0);
1544 CONVERT(VarI4FromDate, 0.5); EXPECT(0);
1545 CONVERT(VarI4FromDate, 0.6); EXPECT(1);
1546 CONVERT(VarI4FromDate, 1.5); EXPECT(2);
1547 }
1548
1549 static void test_VarI4FromCy(void)
1550 {
1551 CONVVARS(CY);
1552
1553 CONVERT_CY(VarI4FromCy,-1); EXPECT(-1);
1554 CONVERT_CY(VarI4FromCy,0); EXPECT(0);
1555 CONVERT_CY(VarI4FromCy,1); EXPECT(1);
1556
1557 CONVERT_CY64(VarI4FromCy,-1,2147483647ul); EXPECT_OVERFLOW;
1558 CONVERT_CY64(VarI4FromCy,-1,2147483648ul); EXPECT(-2147483647 - 1);
1559 CONVERT_CY64(VarI4FromCy,0,2147483647ul); EXPECT(2147483647ul);
1560 CONVERT_CY64(VarI4FromCy,0,2147483648ul); EXPECT_OVERFLOW;
1561
1562 CONVERT_CY(VarI4FromCy,-1.5); EXPECT(-2);
1563 CONVERT_CY(VarI4FromCy,-0.6); EXPECT(-1);
1564 CONVERT_CY(VarI4FromCy,-0.5); EXPECT(0);
1565 CONVERT_CY(VarI4FromCy,-0.4); EXPECT(0);
1566 CONVERT_CY(VarI4FromCy,0.4); EXPECT(0);
1567 CONVERT_CY(VarI4FromCy,0.5); EXPECT(0);
1568 CONVERT_CY(VarI4FromCy,0.6); EXPECT(1);
1569 CONVERT_CY(VarI4FromCy,1.5); EXPECT(2);
1570 }
1571
1572 static void test_VarI4FromDec(void)
1573 {
1574 CONVVARS(DECIMAL);
1575
1576 CONVERT_BADDEC(VarI4FromDec);
1577
1578 CONVERT_DEC(VarI4FromDec,0,0x80,0,1); EXPECT(-1);
1579 CONVERT_DEC(VarI4FromDec,0,0,0,0); EXPECT(0);
1580 CONVERT_DEC(VarI4FromDec,0,0,0,1); EXPECT(1);
1581
1582 CONVERT_DEC64(VarI4FromDec,0,0x80,0,0,2147483649ul); EXPECT_OVERFLOW;
1583 CONVERT_DEC64(VarI4FromDec,0,0x80,0,0,2147483648ul); EXPECT(-2147483647 - 1);
1584 CONVERT_DEC64(VarI4FromDec,0,0,0,0,2147483647ul); EXPECT(2147483647ul);
1585 CONVERT_DEC64(VarI4FromDec,0,0,0,0,2147483648ul); EXPECT_OVERFLOW;
1586
1587 CONVERT_DEC64(VarI4FromDec,2,0x80,0,50,100); EXPECT_OVERFLOW;
1588 CONVERT_DEC64(VarI4FromDec,2,0x80,0,50,0); EXPECT(-2147483647 - 1);
1589 CONVERT_DEC64(VarI4FromDec,2,0,0,49,4294967196ul); EXPECT(2147483647);
1590 CONVERT_DEC64(VarI4FromDec,2,0,0,50,0); EXPECT_OVERFLOW;
1591 }
1592
1593 static void test_VarI4FromStr(void)
1594 {
1595 CONVVARS(LCID);
1596 OLECHAR buff[128];
1597
1598 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1599
1600 CONVERT_STR(VarI4FromStr,NULL,0); EXPECT_MISMATCH;
1601 CONVERT_STR(VarI4FromStr,"0",0); EXPECT(0);
1602 CONVERT_STR(VarI4FromStr,"-2147483649",0); EXPECT_OVERFLOW;
1603 CONVERT_STR(VarI4FromStr,"-2147483648",0); EXPECT(-2147483647 -1);
1604 CONVERT_STR(VarI4FromStr,"2147483647",0); EXPECT(2147483647);
1605 CONVERT_STR(VarI4FromStr,"2147483648",0); EXPECT_OVERFLOW;
1606
1607 /* Rounding */
1608 CONVERT_STR(VarI4FromStr,"-1.5",LOCALE_NOUSEROVERRIDE); EXPECT(-2);
1609 CONVERT_STR(VarI4FromStr,"-0.6",LOCALE_NOUSEROVERRIDE); EXPECT(-1);
1610 CONVERT_STR(VarI4FromStr,"-0.5",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1611 CONVERT_STR(VarI4FromStr,"-0.4",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1612 CONVERT_STR(VarI4FromStr,"0.4",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1613 CONVERT_STR(VarI4FromStr,"0.5",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1614 CONVERT_STR(VarI4FromStr,"0.6",LOCALE_NOUSEROVERRIDE); EXPECT(1);
1615 CONVERT_STR(VarI4FromStr,"1.5",LOCALE_NOUSEROVERRIDE); EXPECT(2);
1616 }
1617
1618 static void test_VarI4Copy(void)
1619 {
1620 COPYTEST(1, VT_I4, V_I4(&vSrc), V_I4(&vDst), V_I4REF(&vSrc), V_I4REF(&vDst), "%d");
1621 }
1622
1623 static void test_VarI4ChangeTypeEx(void)
1624 {
1625 HRESULT hres;
1626 LONG in;
1627 VARIANTARG vSrc, vDst;
1628
1629 in = 1;
1630
1631 INITIAL_TYPETEST(VT_I4, V_I4, "%d");
1632 COMMON_TYPETEST;
1633 NEGATIVE_TYPETEST(VT_I4, V_I4, "%d", VT_UI4, V_UI4);
1634 }
1635
1636 #undef CONV_TYPE
1637 #define CONV_TYPE ULONG
1638 #undef EXPECTRES
1639 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%u")
1640
1641 static void test_VarUI4FromI1(void)
1642 {
1643 CONVVARS(signed char);
1644 int i;
1645
1646 OVERFLOWRANGE(VarUI4FromI1, -127, 0);
1647 CONVERTRANGE(VarUI4FromI1, 0, 128);
1648 }
1649
1650 static void test_VarUI4FromI2(void)
1651 {
1652 CONVVARS(SHORT);
1653 int i;
1654
1655 OVERFLOWRANGE(VarUI4FromI2, -32768, 0);
1656 CONVERTRANGE(VarUI4FromI2, 0, 32768);
1657 }
1658
1659 static void test_VarUI4FromUI2(void)
1660 {
1661 CONVVARS(USHORT);
1662 int i;
1663
1664 CONVERTRANGE(VarUI4FromUI2, 0, 65536);
1665 }
1666
1667 static void test_VarUI4FromI8(void)
1668 {
1669 CONVVARS(LONG64);
1670
1671 CONVERT(VarUI4FromI8, -1); EXPECT_OVERFLOW;
1672 CONVERT(VarUI4FromI8, 0); EXPECT(0);
1673 CONVERT(VarUI4FromI8, 1); EXPECT(1);
1674 CONVERT(VarUI4FromI8, 4294967295ul); EXPECT(4294967295ul);
1675 CONVERT_I8(VarUI4FromI8, 1, 0); EXPECT_OVERFLOW;
1676 }
1677
1678 static void test_VarUI4FromUI1(void)
1679 {
1680 CONVVARS(BYTE);
1681 int i;
1682
1683 CONVERTRANGE(VarUI4FromUI1, 0, 256);
1684 }
1685
1686 static void test_VarUI4FromI4(void)
1687 {
1688 CONVVARS(int);
1689
1690 CONVERT(VarUI4FromI4, -1); EXPECT_OVERFLOW;
1691 CONVERT(VarUI4FromI4, 0); EXPECT(0);
1692 CONVERT(VarUI4FromI4, 1); EXPECT(1);
1693 CONVERT(VarUI4FromI4, 2147483647); EXPECT(2147483647);
1694 }
1695
1696 static void test_VarUI4FromUI8(void)
1697 {
1698 CONVVARS(ULONG64);
1699
1700 CONVERT(VarUI4FromUI8, 0); EXPECT(0);
1701 CONVERT(VarUI4FromUI8, 1); EXPECT(1);
1702 CONVERT(VarUI4FromI8, 4294967295ul); EXPECT(4294967295ul);
1703 CONVERT_I8(VarUI4FromI8, 1, 0); EXPECT_OVERFLOW;
1704 }
1705
1706 static void test_VarUI4FromBool(void)
1707 {
1708 CONVVARS(VARIANT_BOOL);
1709 int i;
1710
1711 CONVERTRANGE(VarUI4FromBool, -32768, 32768);
1712 }
1713
1714 static void test_VarUI4FromR4(void)
1715 {
1716 CONVVARS(FLOAT);
1717
1718 /* We can't test max values as they are not exactly representable in a float */
1719 CONVERT(VarUI4FromR4, -1.0f); EXPECT_OVERFLOW;
1720 CONVERT(VarUI4FromR4, -0.51f); EXPECT_OVERFLOW;
1721 CONVERT(VarUI4FromR4, -0.5f); EXPECT(0);
1722 CONVERT(VarUI4FromR4, 0.0f); EXPECT(0);
1723 CONVERT(VarUI4FromR4, 1.0f); EXPECT(1);
1724
1725 CONVERT(VarUI4FromR4, -1.5f); EXPECT_OVERFLOW;
1726 CONVERT(VarUI4FromR4, -0.6f); EXPECT_OVERFLOW;
1727 CONVERT(VarUI4FromR4, -0.5f); EXPECT(0);
1728 CONVERT(VarUI4FromR4, -0.4f); EXPECT(0);
1729 CONVERT(VarUI4FromR4, 0.4f); EXPECT(0);
1730 CONVERT(VarUI4FromR4, 0.5f); EXPECT(0);
1731 CONVERT(VarUI4FromR4, 0.6f); EXPECT(1);
1732 CONVERT(VarUI4FromR4, 1.5f); EXPECT(2);
1733
1734 }
1735
1736 static void test_VarUI4FromR8(void)
1737 {
1738 CONVVARS(DOUBLE);
1739
1740 CONVERT(VarUI4FromR8, -1.0); EXPECT_OVERFLOW;
1741 CONVERT(VarUI4FromR4, -0.51f); EXPECT_OVERFLOW;
1742 CONVERT(VarUI4FromR4, -0.5f); EXPECT(0);
1743 CONVERT(VarUI4FromR8, 0.0); EXPECT(0);
1744 CONVERT(VarUI4FromR8, 1.0); EXPECT(1);
1745 CONVERT(VarUI4FromR8, 4294967295.0); EXPECT(4294967295ul);
1746 CONVERT(VarUI4FromR8, 4294967295.49); EXPECT(4294967295ul);
1747 CONVERT(VarUI4FromR8, 4294967295.5); EXPECT_OVERFLOW;
1748 CONVERT(VarUI4FromR8, 4294967296.0); EXPECT_OVERFLOW;
1749
1750 CONVERT(VarUI4FromR8, -1.5); EXPECT_OVERFLOW;
1751 CONVERT(VarUI4FromR8, -0.6); EXPECT_OVERFLOW;
1752 CONVERT(VarUI4FromR8, -0.5); EXPECT(0);
1753 CONVERT(VarUI4FromR8, -0.4); EXPECT(0);
1754 CONVERT(VarUI4FromR8, 0.4); EXPECT(0);
1755 CONVERT(VarUI4FromR8, 0.5); EXPECT(0);
1756 CONVERT(VarUI4FromR8, 0.6); EXPECT(1);
1757 CONVERT(VarUI4FromR8, 1.5); EXPECT(2);
1758 }
1759
1760 static void test_VarUI4FromDate(void)
1761 {
1762 CONVVARS(DOUBLE);
1763
1764 CONVERT(VarUI4FromDate, -1.0); EXPECT_OVERFLOW;
1765 CONVERT(VarUI4FromDate, 0.0); EXPECT(0);
1766 CONVERT(VarUI4FromDate, 1.0); EXPECT(1);
1767 CONVERT(VarUI4FromDate, 4294967295.0); EXPECT(4294967295ul);
1768 CONVERT(VarUI4FromDate, 4294967296.0); EXPECT_OVERFLOW;
1769
1770 CONVERT(VarUI4FromDate, -1.5); EXPECT_OVERFLOW;
1771 CONVERT(VarUI4FromDate, -0.6); EXPECT_OVERFLOW;
1772 CONVERT(VarUI4FromDate, -0.5); EXPECT(0);
1773 CONVERT(VarUI4FromDate, -0.4); EXPECT(0);
1774 CONVERT(VarUI4FromDate, 0.4); EXPECT(0);
1775 CONVERT(VarUI4FromDate, 0.5); EXPECT(0);
1776 CONVERT(VarUI4FromDate, 0.6); EXPECT(1);
1777 CONVERT(VarUI4FromDate, 1.5); EXPECT(2);
1778 }
1779
1780 static void test_VarUI4FromCy(void)
1781 {
1782 CONVVARS(CY);
1783
1784 CONVERT_CY(VarUI4FromCy,-1); EXPECT_OVERFLOW;
1785 CONVERT_CY(VarUI4FromCy,0); EXPECT(0);
1786 CONVERT_CY(VarUI4FromCy,1); EXPECT(1);
1787 CONVERT_CY64(VarUI4FromCy,0,4294967295ul); EXPECT(4294967295ul);
1788 CONVERT_CY64(VarUI4FromCy,1,0); EXPECT_OVERFLOW;
1789
1790 CONVERT_CY(VarUI4FromCy,-1.5); EXPECT_OVERFLOW;
1791 CONVERT_CY(VarUI4FromCy,-0.6); EXPECT_OVERFLOW;
1792 CONVERT_CY(VarUI4FromCy,-0.5); EXPECT(0);
1793 CONVERT_CY(VarUI4FromCy,-0.4); EXPECT(0);
1794 CONVERT_CY(VarUI4FromCy,0.4); EXPECT(0);
1795 CONVERT_CY(VarUI4FromCy,0.5); EXPECT(0);
1796 CONVERT_CY(VarUI4FromCy,0.6); EXPECT(1);
1797 CONVERT_CY(VarUI4FromCy,1.5); EXPECT(2);
1798 }
1799
1800 static void test_VarUI4FromDec(void)
1801 {
1802 CONVVARS(DECIMAL);
1803
1804 CONVERT_BADDEC(VarUI4FromDec);
1805
1806 CONVERT_DEC(VarUI4FromDec,0,0x80,0,1); EXPECT_OVERFLOW;
1807 CONVERT_DEC(VarUI4FromDec,0,0,0,0); EXPECT(0);
1808 CONVERT_DEC(VarUI4FromDec,0,0,0,1); EXPECT(1);
1809 CONVERT_DEC64(VarUI4FromDec,0,0,0,0,4294967295ul); EXPECT(4294967295ul);
1810 CONVERT_DEC64(VarUI4FromDec,0,0,0,1,0); EXPECT_OVERFLOW;
1811
1812 CONVERT_DEC64(VarUI4FromDec,2,0,0,99,4294967196ul); EXPECT(4294967295ul);
1813 CONVERT_DEC64(VarUI4FromDec,2,0,0,100,0); EXPECT_OVERFLOW;
1814 }
1815
1816 static void test_VarUI4FromStr(void)
1817 {
1818 CONVVARS(LCID);
1819 OLECHAR buff[128];
1820
1821 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
1822
1823 CONVERT_STR(VarUI4FromStr,NULL,0); EXPECT_MISMATCH;
1824 CONVERT_STR(VarUI4FromStr,"-1",0); EXPECT_OVERFLOW;
1825 CONVERT_STR(VarUI4FromStr,"0",0); EXPECT(0);
1826 CONVERT_STR(VarUI4FromStr,"4294967295",0); EXPECT(4294967295ul);
1827 CONVERT_STR(VarUI4FromStr,"4294967296",0); EXPECT_OVERFLOW;
1828
1829 /* Rounding */
1830 CONVERT_STR(VarUI4FromStr,"-1.5",LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
1831 CONVERT_STR(VarUI4FromStr,"-0.6",LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
1832 CONVERT_STR(VarUI4FromStr,"-0.5",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1833 CONVERT_STR(VarUI4FromStr,"-0.4",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1834 CONVERT_STR(VarUI4FromStr,"0.4",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1835 CONVERT_STR(VarUI4FromStr,"0.5",LOCALE_NOUSEROVERRIDE); EXPECT(0);
1836 CONVERT_STR(VarUI4FromStr,"0.6",LOCALE_NOUSEROVERRIDE); EXPECT(1);
1837 CONVERT_STR(VarUI4FromStr,"1.5",LOCALE_NOUSEROVERRIDE); EXPECT(2);
1838 }
1839
1840 static void test_VarUI4Copy(void)
1841 {
1842 COPYTEST(1u, VT_UI4, V_UI4(&vSrc), V_UI4(&vDst), V_UI4REF(&vSrc), V_UI4REF(&vDst), "%u");
1843 }
1844
1845 static void test_VarUI4ChangeTypeEx(void)
1846 {
1847 HRESULT hres;
1848 ULONG in;
1849 VARIANTARG vSrc, vDst;
1850
1851 in = 1;
1852
1853 INITIAL_TYPETEST(VT_UI4, V_UI4, "%u");
1854 COMMON_TYPETEST;
1855 NEGATIVE_TYPETEST(VT_UI4, V_UI4, "%u", VT_I4, V_I4);
1856 }
1857
1858 /*
1859 * VT_I8/VT_UI8
1860 */
1861
1862 #undef CONV_TYPE
1863 #define CONV_TYPE LONG64
1864
1865 #define EXPECTI8(x) \
1866 ok((hres == S_OK && out == (CONV_TYPE)(x)), \
1867 "expected " #x "(%u,%u), got (%u,%u); hres=0x%08x\n", \
1868 (ULONG)((LONG64)(x) >> 32), (ULONG)((x) & 0xffffffff), \
1869 (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)
1870
1871 #define EXPECTI864(x,y) \
1872 ok(hres == S_OK && (out >> 32) == (CONV_TYPE)(x) && (out & 0xffffffff) == (CONV_TYPE)(y), \
1873 "expected " #x "(%u,%u), got (%u,%u); hres=0x%08x\n", \
1874 (ULONG)(x), (ULONG)(y), \
1875 (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)
1876
1877 static void test_VarI8FromI1(void)
1878 {
1879 CONVVARS(signed char);
1880 int i;
1881
1882 for (i = -128; i < 128; i++)
1883 {
1884 CONVERT(VarI8FromI1,i); EXPECTI8(i);
1885 }
1886 }
1887
1888 static void test_VarI8FromUI1(void)
1889 {
1890 CONVVARS(BYTE);
1891 int i;
1892
1893 for (i = 0; i < 256; i++)
1894 {
1895 CONVERT(VarI8FromUI1,i); EXPECTI8(i);
1896 }
1897 }
1898
1899 static void test_VarI8FromI2(void)
1900 {
1901 CONVVARS(SHORT);
1902 int i;
1903
1904 for (i = -32768; i < 32768; i++)
1905 {
1906 CONVERT(VarI8FromI2,i); EXPECTI8(i);
1907 }
1908 }
1909
1910 static void test_VarI8FromUI2(void)
1911 {
1912 CONVVARS(USHORT);
1913 int i;
1914
1915 for (i = -0; i < 65535; i++)
1916 {
1917 CONVERT(VarI8FromUI2,i); EXPECTI8(i);
1918 }
1919 }
1920
1921 static void test_VarI8FromUI4(void)
1922 {
1923 CONVVARS(ULONG);
1924
1925 CONVERT(VarI8FromUI4, 0); EXPECTI8(0);
1926 CONVERT(VarI8FromUI4, 1); EXPECTI8(1);
1927 CONVERT(VarI8FromUI4, 4294967295ul); EXPECTI8(4294967295ul);
1928 }
1929
1930 static void test_VarI8FromR4(void)
1931 {
1932 CONVVARS(FLOAT);
1933
1934 CONVERT(VarI8FromR4, -128.0f); EXPECTI8(-128);
1935 CONVERT(VarI8FromR4, -1.0f); EXPECTI8(-1);
1936 CONVERT(VarI8FromR4, 0.0f); EXPECTI8(0);
1937 CONVERT(VarI8FromR4, 1.0f); EXPECTI8(1);
1938 CONVERT(VarI8FromR4, 127.0f); EXPECTI8(127);
1939
1940 CONVERT(VarI8FromR4, -1.5f); EXPECTI8(-2);
1941 CONVERT(VarI8FromR4, -0.6f); EXPECTI8(-1);
1942 CONVERT(VarI8FromR4, -0.5f); EXPECTI8(0);
1943 CONVERT(VarI8FromR4, -0.4f); EXPECTI8(0);
1944 CONVERT(VarI8FromR4, 0.4f); EXPECTI8(0);
1945 CONVERT(VarI8FromR4, 0.5f); EXPECTI8(0);
1946 CONVERT(VarI8FromR4, 0.6f); EXPECTI8(1);
1947 CONVERT(VarI8FromR4, 1.5f); EXPECTI8(2);
1948 }
1949
1950 static void test_VarI8FromR8(void)
1951 {
1952 CONVVARS(DOUBLE);
1953
1954 CONVERT(VarI8FromR8, -128.0); EXPECTI8(-128);
1955 CONVERT(VarI8FromR8, -1.0); EXPECTI8(-1);
1956 CONVERT(VarI8FromR8, 0.0); EXPECTI8(0);
1957 CONVERT(VarI8FromR8, 1.0); EXPECTI8(1);
1958 CONVERT(VarI8FromR8, 127.0); EXPECTI8(127);
1959
1960 CONVERT(VarI8FromR8, -1.5); EXPECTI8(-2);
1961 CONVERT(VarI8FromR8, -0.6); EXPECTI8(-1);
1962 CONVERT(VarI8FromR8, -0.5); EXPECTI8(0);
1963 CONVERT(VarI8FromR8, -0.4); EXPECTI8(0);
1964 CONVERT(VarI8FromR8, 0.4); EXPECTI8(0);
1965 CONVERT(VarI8FromR8, 0.5); EXPECTI8(0);
1966 CONVERT(VarI8FromR8, 0.6); EXPECTI8(1);
1967 CONVERT(VarI8FromR8, 1.5); EXPECTI8(2);
1968 }
1969
1970 static void test_VarI8FromDate(void)
1971 {
1972 CONVVARS(DATE);
1973
1974 CONVERT(VarI8FromDate, -128.0); EXPECTI8(-128);
1975 CONVERT(VarI8FromDate, -1.0); EXPECTI8(-1);
1976 CONVERT(VarI8FromDate, 0.0); EXPECTI8(0);
1977 CONVERT(VarI8FromDate, 1.0); EXPECTI8(1);
1978 CONVERT(VarI8FromDate, 127.0); EXPECTI8(127);
1979
1980 CONVERT(VarI8FromDate, -1.5); EXPECTI8(-2);
1981 CONVERT(VarI8FromDate, -0.6); EXPECTI8(-1);
1982 CONVERT(VarI8FromDate, -0.5); EXPECTI8(0);
1983 CONVERT(VarI8FromDate, -0.4); EXPECTI8(0);
1984 CONVERT(VarI8FromDate, 0.4); EXPECTI8(0);
1985 CONVERT(VarI8FromDate, 0.5); EXPECTI8(0);
1986 CONVERT(VarI8FromDate, 0.6); EXPECTI8(1);
1987 CONVERT(VarI8FromDate, 1.5); EXPECTI8(2);
1988 }
1989
1990 static void test_VarI8FromBool(void)
1991 {
1992 CONVVARS(VARIANT_BOOL);
1993 int i;
1994
1995 for (i = -32768; i < 32768; i++)
1996 {
1997 CONVERT(VarI8FromBool,i); EXPECTI8(i);
1998 }
1999 }
2000
2001 static void test_VarI8FromUI8(void)
2002 {
2003 CONVVARS(ULONG64);
2004
2005 CONVERT(VarI8FromUI8, 0); EXPECTI8(0);
2006 CONVERT(VarI8FromUI8, 1); EXPECTI8(1);
2007 CONVERT_I8(VarI8FromUI8, 0x7fffffff, 0xffffffff); EXPECTI864(0x7fffffff, 0xffffffff);
2008 CONVERT_I8(VarI8FromUI8, 0x80000000, 0); EXPECT_OVERFLOW;
2009 }
2010
2011 static void test_VarI8FromCy(void)
2012 {
2013 CONVVARS(CY);
2014
2015 CONVERT_CY(VarI8FromCy,-128); EXPECTI8(-129);
2016 CONVERT_CY(VarI8FromCy,-1); EXPECTI8(-2);
2017 CONVERT_CY(VarI8FromCy,0); EXPECTI8(0);
2018 CONVERT_CY(VarI8FromCy,1); EXPECTI8(1);
2019 CONVERT_CY(VarI8FromCy,127); EXPECTI8(127);
2020
2021 CONVERT_CY(VarI8FromCy,-1.5); EXPECTI8(-2);
2022 CONVERT_CY(VarI8FromCy,-0.6); EXPECTI8(-1);
2023 CONVERT_CY(VarI8FromCy,-0.5); EXPECTI8(-1);
2024 CONVERT_CY(VarI8FromCy,-0.4); EXPECTI8(-1);
2025 CONVERT_CY(VarI8FromCy,0.4); EXPECTI8(0);
2026 CONVERT_CY(VarI8FromCy,0.5); EXPECTI8(0);
2027 CONVERT_CY(VarI8FromCy,0.6); EXPECTI8(1);
2028 CONVERT_CY(VarI8FromCy,1.5); EXPECTI8(2);
2029 }
2030
2031 static void test_VarI8FromDec(void)
2032 {
2033 CONVVARS(DECIMAL);
2034
2035 CONVERT_BADDEC(VarI8FromDec);
2036
2037 CONVERT_DEC(VarI8FromDec,0,0x80,0,128); EXPECTI8(-128);
2038 CONVERT_DEC(VarI8FromDec,0,0x80,0,1); EXPECTI8(-1);
2039 CONVERT_DEC(VarI8FromDec,0,0,0,0); EXPECTI8(0);
2040 CONVERT_DEC(VarI8FromDec,0,0,0,1); EXPECTI8(1);
2041 CONVERT_DEC(VarI8FromDec,0,0,0,127); EXPECTI8(127);
2042
2043 CONVERT_DEC(VarI8FromDec,2,0x80,0,12700); EXPECTI8(-127);
2044 CONVERT_DEC(VarI8FromDec,2,0,0,12700); EXPECTI8(127);
2045 }
2046
2047 static void test_VarI8FromStr(void)
2048 {
2049 CONVVARS(LCID);
2050 OLECHAR buff[128];
2051
2052 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2053
2054 CONVERT_STR(VarI8FromStr,NULL,0); EXPECT_MISMATCH;
2055 CONVERT_STR(VarI8FromStr,"0",0); EXPECTI8(0);
2056 CONVERT_STR(VarI8FromStr,"-1",0); EXPECTI8(-1);
2057 CONVERT_STR(VarI8FromStr,"2147483647",0); EXPECTI8(2147483647);
2058
2059 CONVERT_STR(VarI8FromStr,"-1.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(-2);
2060 CONVERT_STR(VarI8FromStr,"-0.6",LOCALE_NOUSEROVERRIDE); EXPECTI8(-1);
2061 CONVERT_STR(VarI8FromStr,"-0.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2062 CONVERT_STR(VarI8FromStr,"-0.4",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2063 CONVERT_STR(VarI8FromStr,"0.4",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2064 CONVERT_STR(VarI8FromStr,"0.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2065 CONVERT_STR(VarI8FromStr,"0.6",LOCALE_NOUSEROVERRIDE); EXPECTI8(1);
2066 CONVERT_STR(VarI8FromStr,"1.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(2);
2067 }
2068
2069 static void test_VarI8Copy(void)
2070 {
2071 HRESULT hres;
2072 VARIANTARG vSrc, vDst;
2073 LONGLONG in = 1;
2074
2075 if (!has_i8)
2076 {
2077 win_skip("I8 and UI8 data types are not available\n");
2078 return;
2079 }
2080
2081 VariantInit(&vSrc);
2082 VariantInit(&vDst);
2083 V_VT(&vSrc) = VT_I8;
2084 V_I8(&vSrc) = in;
2085 hres = VariantCopy(&vDst, &vSrc);
2086 ok(hres == S_OK && V_VT(&vDst) == VT_I8 && V_I8(&vDst) == in,
2087 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2088 hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_I8(&vDst) >> 32), (UINT)V_I8(&vDst) );
2089 V_VT(&vSrc) = VT_I8|VT_BYREF;
2090 V_I8REF(&vSrc) = &in;
2091 hres = VariantCopy(&vDst, &vSrc);
2092 ok(hres == S_OK && V_VT(&vDst) == (VT_I8|VT_BYREF) && V_I8REF(&vDst) == &in,
2093 "ref hres 0x%X, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, V_I8REF(&vDst));
2094 hres = VariantCopyInd(&vDst, &vSrc);
2095 ok(hres == S_OK && V_VT(&vDst) == VT_I8 && V_I8(&vDst) == in,
2096 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2097 hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_I8(&vDst) >> 32), (UINT)V_I8(&vDst) );
2098 }
2099
2100 static void test_VarI8ChangeTypeEx(void)
2101 {
2102 HRESULT hres;
2103 LONG64 in;
2104 VARIANTARG vSrc, vDst;
2105
2106 if (!has_i8)
2107 {
2108 win_skip("I8 and UI8 data types are not available\n");
2109 return;
2110 }
2111
2112 in = 1;
2113
2114 INITIAL_TYPETESTI8(VT_I8, V_I8);
2115 COMMON_TYPETEST;
2116 }
2117
2118 /* Adapt the test macros to UI8 */
2119 #undef CONV_TYPE
2120 #define CONV_TYPE ULONG64
2121
2122 static void test_VarUI8FromI1(void)
2123 {
2124 CONVVARS(signed char);
2125 int i;
2126
2127 for (i = -128; i < 128; i++)
2128 {
2129 CONVERT(VarUI8FromI1,i);
2130 if (i < 0)
2131 EXPECT_OVERFLOW;
2132 else
2133 EXPECTI8(i);
2134 }
2135 }
2136
2137 static void test_VarUI8FromUI1(void)
2138 {
2139 CONVVARS(BYTE);
2140 int i;
2141
2142 for (i = 0; i < 256; i++)
2143 {
2144 CONVERT(VarUI8FromUI1,i); EXPECTI8(i);
2145 }
2146 }
2147
2148 static void test_VarUI8FromI2(void)
2149 {
2150 CONVVARS(SHORT);
2151 int i;
2152
2153 for (i = -32768; i < 32768; i++)
2154 {
2155 CONVERT(VarUI8FromI2,i);
2156 if (i < 0)
2157 EXPECT_OVERFLOW;
2158 else
2159 EXPECTI8(i);
2160 }
2161 }
2162
2163 static void test_VarUI8FromUI2(void)
2164 {
2165 CONVVARS(USHORT);
2166 int i;
2167
2168 for (i = 0; i < 65535; i++)
2169 {
2170 CONVERT(VarUI8FromUI2,i); EXPECTI8(i);
2171 }
2172 }
2173
2174 static void test_VarUI8FromUI4(void)
2175 {
2176 CONVVARS(ULONG);
2177
2178 CONVERT(VarUI8FromUI4, 0); EXPECTI8(0);
2179 CONVERT(VarUI8FromUI4, 0xffffffff); EXPECTI8(0xffffffff);
2180 }
2181
2182 static void test_VarUI8FromR4(void)
2183 {
2184 CONVVARS(FLOAT);
2185
2186 CONVERT(VarUI8FromR4, -1.0f); EXPECT_OVERFLOW;
2187 CONVERT(VarUI8FromR4, 0.0f); EXPECTI8(0);
2188 CONVERT(VarUI8FromR4, 1.0f); EXPECTI8(1);
2189 CONVERT(VarUI8FromR4, 255.0f); EXPECTI8(255);
2190
2191 CONVERT(VarUI8FromR4, -1.5f); EXPECT_OVERFLOW;
2192 CONVERT(VarUI8FromR4, -0.6f); EXPECT_OVERFLOW;
2193 CONVERT(VarUI8FromR4, -0.5f); EXPECTI8(0);
2194 CONVERT(VarUI8FromR4, -0.4f); EXPECTI8(0);
2195 CONVERT(VarUI8FromR4, 0.4f); EXPECTI8(0);
2196 CONVERT(VarUI8FromR4, 0.5f); EXPECTI8(0);
2197 CONVERT(VarUI8FromR4, 0.6f); EXPECTI8(1);
2198 CONVERT(VarUI8FromR4, 1.5f); EXPECTI8(2);
2199 }
2200
2201 static void test_VarUI8FromR8(void)
2202 {
2203 CONVVARS(DOUBLE);
2204
2205 CONVERT(VarUI8FromR8, -1.0); EXPECT_OVERFLOW;
2206 CONVERT(VarUI8FromR8, 0.0); EXPECTI8(0);
2207 CONVERT(VarUI8FromR8, 1.0); EXPECTI8(1);
2208 CONVERT(VarUI8FromR8, 255.0); EXPECTI8(255);
2209
2210 CONVERT(VarUI8FromR8, -1.5); EXPECT_OVERFLOW;
2211 CONVERT(VarUI8FromR8, -0.6); EXPECT_OVERFLOW;
2212 CONVERT(VarUI8FromR8, -0.5); EXPECTI8(0);
2213 CONVERT(VarUI8FromR8, -0.4); EXPECTI8(0);
2214 CONVERT(VarUI8FromR8, 0.4); EXPECTI8(0);
2215 CONVERT(VarUI8FromR8, 0.5); EXPECTI8(0);
2216 CONVERT(VarUI8FromR8, 0.6); EXPECTI8(1);
2217 CONVERT(VarUI8FromR8, 1.5); EXPECTI8(2);
2218 }
2219
2220 static void test_VarUI8FromDate(void)
2221 {
2222 CONVVARS(DATE);
2223
2224 CONVERT(VarUI8FromDate, -1.0); EXPECT_OVERFLOW;
2225 CONVERT(VarUI8FromDate, 0.0); EXPECTI8(0);
2226 CONVERT(VarUI8FromDate, 1.0); EXPECTI8(1);
2227 CONVERT(VarUI8FromDate, 255.0); EXPECTI8(255);
2228
2229 CONVERT(VarUI8FromDate, -1.5); EXPECT_OVERFLOW;
2230 CONVERT(VarUI8FromDate, -0.6); EXPECT_OVERFLOW;
2231 CONVERT(VarUI8FromDate, -0.5); EXPECTI8(0);
2232 CONVERT(VarUI8FromDate, -0.4); EXPECTI8(0);
2233 CONVERT(VarUI8FromDate, 0.4); EXPECTI8(0);
2234 CONVERT(VarUI8FromDate, 0.5); EXPECTI8(0);
2235 CONVERT(VarUI8FromDate, 0.6); EXPECTI8(1);
2236 CONVERT(VarUI8FromDate, 1.5); EXPECTI8(2);
2237 }
2238
2239 static void test_VarUI8FromBool(void)
2240 {
2241 CONVVARS(VARIANT_BOOL);
2242 int i;
2243
2244 for (i = -32768; i < 32768; i++)
2245 {
2246 CONVERT(VarUI8FromBool, i); EXPECTI8(i);
2247 }
2248 }
2249
2250 static void test_VarUI8FromI8(void)
2251 {
2252 CONVVARS(LONG64);
2253
2254 CONVERT(VarUI8FromI8, -1); EXPECT_OVERFLOW;
2255 CONVERT(VarUI8FromI8, 0); EXPECTI8(0);
2256 CONVERT(VarUI8FromI8, 1); EXPECTI8(1);
2257 }
2258
2259 static void test_VarUI8FromCy(void)
2260 {
2261 CONVVARS(CY);
2262
2263 CONVERT_CY(VarUI8FromCy,-1); EXPECT_OVERFLOW;
2264 CONVERT_CY(VarUI8FromCy,0); EXPECTI8(0);
2265 CONVERT_CY(VarUI8FromCy,1); EXPECTI8(1);
2266 CONVERT_CY(VarUI8FromCy,255); EXPECTI8(255);
2267
2268 CONVERT_CY(VarUI8FromCy,-1.5); EXPECT_OVERFLOW;
2269 CONVERT_CY(VarUI8FromCy,-0.6); EXPECT_OVERFLOW;
2270 CONVERT_CY(VarUI8FromCy,-0.5); EXPECTI8(0);
2271 CONVERT_CY(VarUI8FromCy,-0.4); EXPECTI8(0);
2272 CONVERT_CY(VarUI8FromCy,0.4); EXPECTI8(0);
2273 CONVERT_CY(VarUI8FromCy,0.5); EXPECTI8(0);
2274 CONVERT_CY(VarUI8FromCy,0.6); EXPECTI8(1);
2275 CONVERT_CY(VarUI8FromCy,1.5); EXPECTI8(2);
2276 }
2277
2278 static void test_VarUI8FromDec(void)
2279 {
2280 CONVVARS(DECIMAL);
2281
2282 CONVERT_BADDEC(VarUI8FromDec);
2283
2284 /* This returns 1 under native; Wine fixes this bug and returns overflow */
2285 if (0)
2286 {
2287 CONVERT_DEC(VarUI8FromDec,0,0x80,0,1);
2288 }
2289
2290 CONVERT_DEC(VarUI8FromDec,0,0,0,0); EXPECTI8(0);
2291 CONVERT_DEC(VarUI8FromDec,0,0,0,1); EXPECTI8(1);
2292 CONVERT_DEC(VarUI8FromDec,0,0,0,255); EXPECTI8(255);
2293
2294 CONVERT_DEC(VarUI8FromDec,2,0x80,0,100); EXPECT_OVERFLOW;
2295 CONVERT_DEC(VarUI8FromDec,2,0,0,25500); EXPECTI8(255);
2296 }
2297
2298 static void test_VarUI8FromStr(void)
2299 {
2300 CONVVARS(LCID);
2301 OLECHAR buff[128];
2302
2303 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2304
2305 CONVERT_STR(VarUI8FromStr,NULL,0); EXPECT_MISMATCH;
2306 CONVERT_STR(VarUI8FromStr,"0",0); EXPECTI8(0);
2307 CONVERT_STR(VarUI8FromStr,"-1",0); EXPECT_OVERFLOW;
2308 CONVERT_STR(VarUI8FromStr,"2147483647",0); EXPECTI8(2147483647);
2309 CONVERT_STR(VarUI8FromStr,"18446744073709551614",0); EXPECTI864(0xFFFFFFFF,0xFFFFFFFE);
2310 CONVERT_STR(VarUI8FromStr,"18446744073709551615",0); EXPECTI864(0xFFFFFFFF,0xFFFFFFFF);
2311 CONVERT_STR(VarUI8FromStr,"18446744073709551616",0); EXPECT_OVERFLOW;
2312
2313 CONVERT_STR(VarUI8FromStr,"-1.5",LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
2314 CONVERT_STR(VarUI8FromStr,"-0.6",LOCALE_NOUSEROVERRIDE); EXPECT_OVERFLOW;
2315 CONVERT_STR(VarUI8FromStr,"-0.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2316 CONVERT_STR(VarUI8FromStr,"-0.4",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2317 CONVERT_STR(VarUI8FromStr,"0.4",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2318 CONVERT_STR(VarUI8FromStr,"0.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(0);
2319 CONVERT_STR(VarUI8FromStr,"0.6",LOCALE_NOUSEROVERRIDE); EXPECTI8(1);
2320 CONVERT_STR(VarUI8FromStr,"1.5",LOCALE_NOUSEROVERRIDE); EXPECTI8(2);
2321 }
2322
2323 static void test_VarUI8Copy(void)
2324 {
2325 HRESULT hres;
2326 VARIANTARG vSrc, vDst;
2327 ULONGLONG in = 1;
2328
2329 if (!has_i8)
2330 {
2331 win_skip("I8 and UI8 data types are not available\n");
2332 return;
2333 }
2334
2335 VariantInit(&vSrc);
2336 VariantInit(&vDst);
2337 V_VT(&vSrc) = VT_UI8;
2338 V_UI8(&vSrc) = in;
2339 hres = VariantCopy(&vDst, &vSrc);
2340 ok(hres == S_OK && V_VT(&vDst) == VT_UI8 && V_UI8(&vDst) == in,
2341 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2342 hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_UI8(&vDst) >> 32), (UINT)V_UI8(&vDst) );
2343 V_VT(&vSrc) = VT_UI8|VT_BYREF;
2344 V_UI8REF(&vSrc) = &in;
2345 hres = VariantCopy(&vDst, &vSrc);
2346 ok(hres == S_OK && V_VT(&vDst) == (VT_UI8|VT_BYREF) && V_UI8REF(&vDst) == &in,
2347 "ref hres 0x%X, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, V_UI8REF(&vDst));
2348 hres = VariantCopyInd(&vDst, &vSrc);
2349 ok(hres == S_OK && V_VT(&vDst) == VT_UI8 && V_UI8(&vDst) == in,
2350 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2351 hres, V_VT(&vDst), (UINT)(in >> 32), (UINT)in, (UINT)(V_UI8(&vDst) >> 32), (UINT)V_UI8(&vDst) );
2352 }
2353
2354 static void test_VarUI8ChangeTypeEx(void)
2355 {
2356 HRESULT hres;
2357 ULONG64 in;
2358 VARIANTARG vSrc, vDst;
2359
2360 if (!has_i8)
2361 {
2362 win_skip("I8 and UI8 data types are not available\n");
2363 return;
2364 }
2365
2366 in = 1;
2367
2368 INITIAL_TYPETESTI8(VT_UI8, V_UI8);
2369 COMMON_TYPETEST;
2370 }
2371
2372 /*
2373 * VT_R4
2374 */
2375
2376 #undef CONV_TYPE
2377 #define CONV_TYPE float
2378 #undef EXPECTRES
2379 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%15.15f")
2380
2381 static void test_VarR4FromI1(void)
2382 {
2383 CONVVARS(signed char);
2384 int i;
2385
2386 CONVERTRANGE(VarR4FromI1, -128, 128);
2387 }
2388
2389 static void test_VarR4FromUI1(void)
2390 {
2391 CONVVARS(BYTE);
2392 int i;
2393
2394 CONVERTRANGE(VarR4FromUI1, 0, 256);
2395 }
2396
2397 static void test_VarR4FromI2(void)
2398 {
2399 CONVVARS(SHORT);
2400 int i;
2401
2402 CONVERTRANGE(VarR4FromI2, -32768, 32768);
2403 }
2404
2405 static void test_VarR4FromUI2(void)
2406 {
2407 CONVVARS(USHORT);
2408 int i;
2409
2410 CONVERTRANGE(VarR4FromUI2, 0, 65536);
2411 }
2412
2413 static void test_VarR4FromI4(void)
2414 {
2415 CONVVARS(int);
2416
2417 CONVERT(VarR4FromI4, -2147483647-1); EXPECT(-2147483648.0f);
2418 CONVERT(VarR4FromI4, -1); EXPECT(-1.0f);
2419 CONVERT(VarR4FromI4, 0); EXPECT(0.0f);
2420 CONVERT(VarR4FromI4, 1); EXPECT(1.0f);
2421 CONVERT(VarR4FromI4, 2147483647); EXPECT(2147483647.0f);
2422 }
2423
2424 static void test_VarR4FromUI4(void)
2425 {
2426 CONVVARS(unsigned int);
2427
2428 CONVERT(VarR4FromUI4, 0); EXPECT(0.0f);
2429 CONVERT(VarR4FromUI4, 1); EXPECT(1.0f);
2430 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2431 CONVERT(VarR4FromUI4, 0xffffffff); EXPECT(4294967296.0f);
2432 #endif
2433 }
2434
2435 static void test_VarR4FromR8(void)
2436 {
2437 CONVVARS(FLOAT);
2438
2439 CONVERT(VarR4FromR8, -1.0); EXPECT(-1.0f);
2440 CONVERT(VarR4FromR8, 0.0); EXPECT(0.0f);
2441 CONVERT(VarR4FromR8, 1.0); EXPECT(1.0f);
2442 CONVERT(VarR4FromR8, 1.5); EXPECT(1.5f);
2443
2444 /* Skip rounding tests - no rounding is done */
2445 }
2446
2447 static void test_VarR4FromBool(void)
2448 {
2449 CONVVARS(VARIANT_BOOL);
2450
2451 CONVERT(VarR4FromBool, VARIANT_TRUE); EXPECT(VARIANT_TRUE * 1.0f);
2452 CONVERT(VarR4FromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0f);
2453 }
2454
2455 static void test_VarR4FromCy(void)
2456 {
2457 CONVVARS(CY);
2458
2459 CONVERT_CY(VarR4FromCy,-32768); EXPECT(-32768.0f);
2460 CONVERT_CY(VarR4FromCy,-1); EXPECT(-1.0f);
2461 CONVERT_CY(VarR4FromCy,0); EXPECT(0.0f);
2462 CONVERT_CY(VarR4FromCy,1); EXPECT(1.0f);
2463 CONVERT_CY(VarR4FromCy,32768); EXPECT(32768.0f);
2464
2465 CONVERT_CY(VarR4FromCy,-1.5); EXPECT(-1.5f);
2466 CONVERT_CY(VarR4FromCy,-0.6); EXPECT(-0.6f);
2467 CONVERT_CY(VarR4FromCy,-0.5); EXPECT(-0.5f);
2468 CONVERT_CY(VarR4FromCy,-0.4); EXPECT(-0.4f);
2469 CONVERT_CY(VarR4FromCy,0.4); EXPECT(0.4f);
2470 CONVERT_CY(VarR4FromCy,0.5); EXPECT(0.5f);
2471 CONVERT_CY(VarR4FromCy,0.6); EXPECT(0.6f);
2472 CONVERT_CY(VarR4FromCy,1.5); EXPECT(1.5f);
2473 }
2474
2475 static void test_VarR4FromI8(void)
2476 {
2477 CONVVARS(LONG64);
2478
2479 CONVERT(VarR4FromI8, -1); EXPECT(-1.0f);
2480 CONVERT(VarR4FromI8, 0); EXPECT(0.0f);
2481 CONVERT(VarR4FromI8, 1); EXPECT(1.0f);
2482 }
2483
2484 static void test_VarR4FromUI8(void)
2485 {
2486 CONVVARS(ULONG64);
2487
2488 CONVERT(VarR4FromUI8, 0); EXPECT(0.0f);
2489 CONVERT(VarR4FromUI8, 1); EXPECT(1.0f);
2490 }
2491
2492 static void test_VarR4FromDec(void)
2493 {
2494 CONVVARS(DECIMAL);
2495
2496 CONVERT_BADDEC(VarR4FromDec);
2497
2498 CONVERT_DEC(VarR4FromDec,0,0x80,0,32768); EXPECT(-32768.0f);
2499 CONVERT_DEC(VarR4FromDec,0,0x80,0,1); EXPECT(-1.0f);
2500 CONVERT_DEC(VarR4FromDec,0,0,0,0); EXPECT(0.0f);
2501 CONVERT_DEC(VarR4FromDec,0,0,0,1); EXPECT(1.0f);
2502 CONVERT_DEC(VarR4FromDec,0,0,0,32767); EXPECT(32767.0f);
2503
2504 CONVERT_DEC(VarR4FromDec,2,0x80,0,3276800); EXPECT(-32768.0f);
2505 CONVERT_DEC(VarR4FromDec,2,0,0,3276700); EXPECT(32767.0f);
2506 CONVERT_DEC(VarR4FromDec,10,0,0,3276700); EXPECT(0.00032767f);
2507
2508 CONVERT_DEC(VarR4FromDec,0,0,1,0); EXPECT(18446744073709551616.0f);
2509 }
2510
2511 static void test_VarR4FromDate(void)
2512 {
2513 CONVVARS(DATE);
2514
2515 CONVERT(VarR4FromDate, -1.0); EXPECT(-1.0f);
2516 CONVERT(VarR4FromDate, 0.0); EXPECT(0.0f);
2517 CONVERT(VarR4FromDate, 1.0); EXPECT(1.0f);
2518 }
2519
2520 static void test_VarR4FromStr(void)
2521 {
2522 CONVVARS(LCID);
2523 OLECHAR buff[128];
2524
2525 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2526
2527 CONVERT_STR(VarR4FromStr,NULL,0); EXPECT_MISMATCH;
2528 CONVERT_STR(VarR4FromStr,"-1", 0); EXPECT(-1.0f);
2529 CONVERT_STR(VarR4FromStr,"0", 0); EXPECT(0.0f);
2530 CONVERT_STR(VarR4FromStr,"1", 0); EXPECT(1.0f);
2531
2532 CONVERT_STR(VarR4FromStr,"-1.5",LOCALE_NOUSEROVERRIDE); EXPECT(-1.5f);
2533 CONVERT_STR(VarR4FromStr,"-0.6",LOCALE_NOUSEROVERRIDE); EXPECT(-0.6f);
2534 CONVERT_STR(VarR4FromStr,"-0.5",LOCALE_NOUSEROVERRIDE); EXPECT(-0.5f);
2535 CONVERT_STR(VarR4FromStr,"-0.4",LOCALE_NOUSEROVERRIDE); EXPECT(-0.4f);
2536 CONVERT_STR(VarR4FromStr,"0.4",LOCALE_NOUSEROVERRIDE); EXPECT(0.4f);
2537 CONVERT_STR(VarR4FromStr,"0.5",LOCALE_NOUSEROVERRIDE); EXPECT(0.5f);
2538 CONVERT_STR(VarR4FromStr,"0.6",LOCALE_NOUSEROVERRIDE); EXPECT(0.6f);
2539 CONVERT_STR(VarR4FromStr,"1.5",LOCALE_NOUSEROVERRIDE); EXPECT(1.5f);
2540 }
2541
2542 static void test_VarR4Copy(void)
2543 {
2544 COPYTEST(77665544.0f, VT_R4, V_R4(&vSrc), V_R4(&vDst), V_R4REF(&vSrc),V_R4REF(&vDst), "%15.15f");
2545 }
2546
2547 static void test_VarR4ChangeTypeEx(void)
2548 {
2549 #ifdef HAS_UINT64_TO_FLOAT
2550 HRESULT hres;
2551 float in;
2552 VARIANTARG vSrc, vDst;
2553
2554 in = 1.0f;
2555
2556 INITIAL_TYPETEST(VT_R4, V_R4, "%f");
2557 COMMON_TYPETEST;
2558 #endif
2559 }
2560
2561 /*
2562 * VT_R8
2563 */
2564
2565 #undef CONV_TYPE
2566 #define CONV_TYPE double
2567
2568 static void test_VarR8FromI1(void)
2569 {
2570 CONVVARS(signed char);
2571 int i;
2572
2573 CONVERTRANGE(VarR8FromI1, -128, 128);
2574 }
2575
2576 static void test_VarR8FromUI1(void)
2577 {
2578 CONVVARS(BYTE);
2579 int i;
2580
2581 CONVERTRANGE(VarR8FromUI1, 0, 256);
2582 }
2583
2584 static void test_VarR8FromI2(void)
2585 {
2586 CONVVARS(SHORT);
2587 int i;
2588
2589 CONVERTRANGE(VarR8FromI2, -32768, 32768);
2590 }
2591
2592 static void test_VarR8FromUI2(void)
2593 {
2594 CONVVARS(USHORT);
2595 int i;
2596
2597 CONVERTRANGE(VarR8FromUI2, 0, 65536);
2598 }
2599
2600 static void test_VarR8FromI4(void)
2601 {
2602 CONVVARS(int);
2603
2604 CONVERT(VarR8FromI4, -2147483647-1); EXPECT(-2147483648.0);
2605 CONVERT(VarR8FromI4, -1); EXPECT(-1.0);
2606 CONVERT(VarR8FromI4, 0); EXPECT(0.0);
2607 CONVERT(VarR8FromI4, 1); EXPECT(1.0);
2608 CONVERT(VarR8FromI4, 0x7fffffff); EXPECT(2147483647.0);
2609 }
2610
2611 static void test_VarR8FromUI4(void)
2612 {
2613 CONVVARS(unsigned int);
2614
2615 CONVERT(VarR8FromUI4, 0); EXPECT(0.0);
2616 CONVERT(VarR8FromUI4, 1); EXPECT(1.0);
2617 CONVERT(VarR8FromUI4, 0xffffffff); EXPECT(4294967295.0);
2618 }
2619
2620 static void test_VarR8FromR4(void)
2621 {
2622 CONVVARS(FLOAT);
2623
2624 CONVERT(VarR8FromR4, -1.0f); EXPECT(-1.0);
2625 CONVERT(VarR8FromR4, 0.0f); EXPECT(0.0);
2626 CONVERT(VarR8FromR4, 1.0f); EXPECT(1.0);
2627 CONVERT(VarR8FromR4, 1.5f); EXPECT(1.5);
2628
2629 /* Skip rounding tests - no rounding is done */
2630 }
2631
2632 static void test_VarR8FromBool(void)
2633 {
2634 CONVVARS(VARIANT_BOOL);
2635
2636 CONVERT(VarR8FromBool, VARIANT_TRUE); EXPECT(VARIANT_TRUE * 1.0);
2637 CONVERT(VarR8FromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0);
2638 }
2639
2640 static void test_VarR8FromCy(void)
2641 {
2642 CONVVARS(CY);
2643
2644 CONVERT_CY(VarR8FromCy,-32769); EXPECT(-32769.0);
2645 CONVERT_CY(VarR8FromCy,-32768); EXPECT(-32768.0);
2646 CONVERT_CY(VarR8FromCy,-1); EXPECT(-1.0);
2647 CONVERT_CY(VarR8FromCy,0); EXPECT(0.0);
2648 CONVERT_CY(VarR8FromCy,1); EXPECT(1.0);
2649 CONVERT_CY(VarR8FromCy,32767); EXPECT(32767.0);
2650 CONVERT_CY(VarR8FromCy,32768); EXPECT(32768.0);
2651
2652 CONVERT_CY(VarR8FromCy,-1.5); EXPECT(-1.5);
2653 CONVERT_CY(VarR8FromCy,-0.6); EXPECT(-0.6);
2654 CONVERT_CY(VarR8FromCy,-0.5); EXPECT(-0.5);
2655 CONVERT_CY(VarR8FromCy,-0.4); EXPECT(-0.4);
2656 CONVERT_CY(VarR8FromCy,0.4); EXPECT(0.4);
2657 CONVERT_CY(VarR8FromCy,0.5); EXPECT(0.5);
2658 CONVERT_CY(VarR8FromCy,0.6); EXPECT(0.6);
2659 CONVERT_CY(VarR8FromCy,1.5); EXPECT(1.5);
2660 }
2661
2662 static void test_VarR8FromI8(void)
2663 {
2664 CONVVARS(LONG64);
2665
2666 CONVERT(VarR8FromI8, -1); EXPECT(-1.0);
2667 CONVERT(VarR8FromI8, 0); EXPECT(0.0);
2668 CONVERT(VarR8FromI8, 1); EXPECT(1.0);
2669 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2670 CONVERT_I8(VarR8FromI8, 0x7fffffff,0xffffffff); EXPECT(9223372036854775808.0);
2671 #endif
2672 }
2673
2674 static void test_VarR8FromUI8(void)
2675 {
2676 CONVVARS(ULONG64);
2677
2678 CONVERT(VarR8FromUI8, 0); EXPECT(0.0);
2679 CONVERT(VarR8FromUI8, 1); EXPECT(1.0);
2680 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2681 CONVERT_I8(VarR8FromUI8, 0x80000000,0); EXPECT(9223372036854775808.0);
2682 #endif
2683 }
2684
2685 static void test_VarR8FromDec(void)
2686 {
2687 CONVVARS(DECIMAL);
2688
2689 CONVERT_BADDEC(VarR8FromDec);
2690
2691 CONVERT_DEC(VarR8FromDec,0,0x80,0,32768); EXPECT(-32768.0);
2692 CONVERT_DEC(VarR8FromDec,0,0x80,0,1); EXPECT(-1.0);
2693 CONVERT_DEC(VarR8FromDec,0,0,0,0); EXPECT(0.0);
2694 CONVERT_DEC(VarR8FromDec,0,0,0,1); EXPECT(1.0);
2695 CONVERT_DEC(VarR8FromDec,0,0,0,32767); EXPECT(32767.0);
2696
2697 CONVERT_DEC(VarR8FromDec,2,0x80,0,3276800); EXPECT(-32768.0);
2698 CONVERT_DEC(VarR8FromDec,2,0,0,3276700); EXPECT(32767.0);
2699
2700 CONVERT_DEC(VarR8FromDec,0,0,1,0); EXPECT(18446744073709551616.0);
2701 }
2702
2703 static void test_VarR8FromDate(void)
2704 {
2705 CONVVARS(DATE);
2706
2707 CONVERT(VarR8FromDate, -1.0); EXPECT(-1.0);
2708 CONVERT(VarR8FromDate, -0.0); EXPECT(0.0);
2709 CONVERT(VarR8FromDate, 1.0); EXPECT(1.0);
2710 }
2711
2712 static void test_VarR8FromStr(void)
2713 {
2714 CONVVARS(LCID);
2715 OLECHAR buff[128];
2716
2717 in = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2718
2719 CONVERT_STR(VarR8FromStr,NULL,0); EXPECT_MISMATCH;
2720 CONVERT_STR(VarR8FromStr,"",0); EXPECT_MISMATCH;
2721 CONVERT_STR(VarR8FromStr," ",0); EXPECT_MISMATCH;
2722
2723 CONVERT_STR(VarR8FromStr,"0",LOCALE_NOUSEROVERRIDE); EXPECT(0.0);
2724 CONVERT_STR(VarR8FromStr,"-1.5",LOCALE_NOUSEROVERRIDE); EXPECT(-1.5);
2725 CONVERT_STR(VarR8FromStr,"-0.6",LOCALE_NOUSEROVERRIDE); EXPECT(-0.6);
2726 CONVERT_STR(VarR8FromStr,"-0.5",LOCALE_NOUSEROVERRIDE); EXPECT(-0.5);
2727 CONVERT_STR(VarR8FromStr,"-0.4",LOCALE_NOUSEROVERRIDE); EXPECT(-0.4);
2728 CONVERT_STR(VarR8FromStr,"0.4",LOCALE_NOUSEROVERRIDE); EXPECT(0.4);
2729 CONVERT_STR(VarR8FromStr,"0.5",LOCALE_NOUSEROVERRIDE); EXPECT(0.5);
2730 CONVERT_STR(VarR8FromStr,"0.6",LOCALE_NOUSEROVERRIDE); EXPECT(0.6);
2731 CONVERT_STR(VarR8FromStr,"1.5",LOCALE_NOUSEROVERRIDE); EXPECT(1.5);
2732 CONVERT_STR(VarR8FromStr,"1e-94938484",LOCALE_NOUSEROVERRIDE); EXPECT(0);
2733
2734 /* We already have exhaustive tests for number parsing, so skip those tests here */
2735 }
2736
2737 static void test_VarR8Copy(void)
2738 {
2739 COPYTEST(77665544.0, VT_R8, V_R8(&vSrc), V_R8(&vDst), V_R8REF(&vSrc),V_R8REF(&vDst), "%16.16g");
2740 }
2741
2742 static void test_VarR8ChangeTypeEx(void)
2743 {
2744 #ifdef HAS_UINT64_TO_FLOAT
2745 HRESULT hres;
2746 double in;
2747 VARIANTARG vSrc, vDst;
2748
2749 in = 1.0;
2750
2751 INITIAL_TYPETEST(VT_R8, V_R8, "%g");
2752 COMMON_TYPETEST;
2753 #endif
2754 }
2755
2756 #define MATHRND(l, r) left = l; right = r; hres = VarR8Round(left, right, &out)
2757
2758 static void test_VarR8Round(void)
2759 {
2760 HRESULT hres;
2761 double left = 0.0, out;
2762 int right;
2763
2764 MATHRND(0.5432, 5); EXPECT(0.5432);
2765 MATHRND(0.5432, 4); EXPECT(0.5432);
2766 MATHRND(0.5432, 3); EXPECT(0.543);
2767 MATHRND(0.5432, 2); EXPECT(0.54);
2768 MATHRND(0.5432, 1); EXPECT(0.5);
2769 MATHRND(0.5532, 0); EXPECT(1);
2770 MATHRND(0.5532, -1); EXPECT_INVALID;
2771
2772 MATHRND(0.5568, 5); EXPECT(0.5568);
2773 MATHRND(0.5568, 4); EXPECT(0.5568);
2774 MATHRND(0.5568, 3); EXPECT(0.557);
2775 MATHRND(0.5568, 2); EXPECT(0.56);
2776 MATHRND(0.5568, 1); EXPECT(0.6);
2777 MATHRND(0.5568, 0); EXPECT(1);
2778 MATHRND(0.5568, -1); EXPECT_INVALID;
2779
2780 MATHRND(0.4999, 0); EXPECT(0);
2781 MATHRND(0.5000, 0); EXPECT(0);
2782 MATHRND(0.5001, 0); EXPECT(1);
2783 MATHRND(1.4999, 0); EXPECT(1);
2784 MATHRND(1.5000, 0); EXPECT(2);
2785 MATHRND(1.5001, 0); EXPECT(2);
2786 }
2787
2788 /*
2789 * VT_DATE
2790 */
2791
2792 #undef CONV_TYPE
2793 #define CONV_TYPE DATE
2794
2795 static void test_VarDateFromI1(void)
2796 {
2797 CONVVARS(signed char);
2798 int i;
2799
2800 CONVERTRANGE(VarDateFromI1, -128, 128);
2801 }
2802
2803 static void test_VarDateFromUI1(void)
2804 {
2805 CONVVARS(BYTE);
2806 int i;
2807
2808 CONVERTRANGE(VarDateFromUI1, 0, 256);
2809 }
2810
2811 static void test_VarDateFromI2(void)
2812 {
2813 CONVVARS(SHORT);
2814 int i;
2815
2816 CONVERTRANGE(VarDateFromI2, -32768, 32768);
2817 }
2818
2819 static void test_VarDateFromUI2(void)
2820 {
2821 CONVVARS(USHORT);
2822 int i;
2823
2824 CONVERTRANGE(VarDateFromUI2, 0, 65536);
2825 }
2826
2827 static void test_VarDateFromI4(void)
2828 {
2829 CONVVARS(int);
2830
2831 CONVERT(VarDateFromI4, DATE_MIN-1);
2832 if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
2833 EXPECT_OVERFLOW;
2834 CONVERT(VarDateFromI4, DATE_MIN); EXPECT(DATE_MIN);
2835 CONVERT(VarDateFromI4, -1); EXPECT(-1.0);
2836 CONVERT(VarDateFromI4, 0); EXPECT(0.0);
2837 CONVERT(VarDateFromI4, 1); EXPECT(1.0);
2838 CONVERT(VarDateFromI4, DATE_MAX); EXPECT(DATE_MAX);
2839 CONVERT(VarDateFromI4, DATE_MAX+1);
2840 if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
2841 EXPECT_OVERFLOW;
2842 }
2843
2844 static void test_VarDateFromUI4(void)
2845 {
2846 CONVVARS(unsigned int);
2847
2848 CONVERT(VarDateFromUI4, 0); EXPECT(0.0);
2849 CONVERT(VarDateFromUI4, 1); EXPECT(1.0);
2850 CONVERT(VarDateFromUI4, DATE_MAX); EXPECT(DATE_MAX);
2851 CONVERT(VarDateFromUI4, DATE_MAX+1);
2852 if (hres != DISP_E_TYPEMISMATCH) /* Early versions return this, incorrectly */
2853 EXPECT_OVERFLOW;
2854 }
2855
2856 static void test_VarDateFromR4(void)
2857 {
2858 CONVVARS(FLOAT);
2859
2860 CONVERT(VarDateFromR4, -1.0f); EXPECT(-1.0);
2861 CONVERT(VarDateFromR4, 0.0f); EXPECT(0.0);
2862 CONVERT(VarDateFromR4, 1.0f); EXPECT(1.0);
2863 CONVERT(VarDateFromR4, 1.5f); EXPECT(1.5);
2864 }
2865
2866 static void test_VarDateFromR8(void)
2867 {
2868 CONVVARS(double);
2869
2870 CONVERT(VarDateFromR8, -1.0f); EXPECT(-1.0);
2871 CONVERT(VarDateFromR8, 0.0f); EXPECT(0.0);
2872 CONVERT(VarDateFromR8, 1.0f); EXPECT(1.0);
2873 CONVERT(VarDateFromR8, 1.5f); EXPECT(1.5);
2874 }
2875
2876 static void test_VarDateFromBool(void)
2877 {
2878 CONVVARS(VARIANT_BOOL);
2879
2880 CONVERT(VarDateFromBool, VARIANT_TRUE); EXPECT(VARIANT_TRUE * 1.0);
2881 CONVERT(VarDateFromBool, VARIANT_FALSE); EXPECT(VARIANT_FALSE * 1.0);
2882 }
2883
2884 static void test_VarDateFromCy(void)
2885 {
2886 CONVVARS(CY);
2887
2888 CONVERT_CY(VarDateFromCy,-32769); EXPECT(-32769.0);
2889 CONVERT_CY(VarDateFromCy,-32768); EXPECT(-32768.0);
2890 CONVERT_CY(VarDateFromCy,-1); EXPECT(-1.0);
2891 CONVERT_CY(VarDateFromCy,0); EXPECT(0.0);
2892 CONVERT_CY(VarDateFromCy,1); EXPECT(1.0);
2893 CONVERT_CY(VarDateFromCy,32767); EXPECT(32767.0);
2894 CONVERT_CY(VarDateFromCy,32768); EXPECT(32768.0);
2895
2896 CONVERT_CY(VarDateFromCy,-1.5); EXPECT(-1.5);
2897 CONVERT_CY(VarDateFromCy,-0.6); EXPECT(-0.6);
2898 CONVERT_CY(VarDateFromCy,-0.5); EXPECT(-0.5);
2899 CONVERT_CY(VarDateFromCy,-0.4); EXPECT(-0.4);
2900 CONVERT_CY(VarDateFromCy,0.4); EXPECT(0.4);
2901 CONVERT_CY(VarDateFromCy,0.5); EXPECT(0.5);
2902 CONVERT_CY(VarDateFromCy,0.6); EXPECT(0.6);
2903 CONVERT_CY(VarDateFromCy,1.5); EXPECT(1.5);
2904 }
2905
2906 static void test_VarDateFromI8(void)
2907 {
2908 CONVVARS(LONG64);
2909
2910 CONVERT(VarDateFromI8, DATE_MIN-1); EXPECT_OVERFLOW;
2911 CONVERT(VarDateFromI8, DATE_MIN); EXPECT(DATE_MIN);
2912 CONVERT(VarDateFromI8, -1); EXPECT(-1.0);
2913 CONVERT(VarDateFromI8, 0); EXPECT(0.0);
2914 CONVERT(VarDateFromI8, 1); EXPECT(1.0);
2915 CONVERT(VarDateFromI8, DATE_MAX); EXPECT(DATE_MAX);
2916 CONVERT(VarDateFromI8, DATE_MAX+1); EXPECT_OVERFLOW;
2917 }
2918
2919 static void test_VarDateFromUI8(void)
2920 {
2921 CONVVARS(ULONG64);
2922
2923 CONVERT(VarDateFromUI8, 0); EXPECT(0.0);
2924 CONVERT(VarDateFromUI8, 1); EXPECT(1.0);
2925 CONVERT(VarDateFromUI8, DATE_MAX); EXPECT(DATE_MAX);
2926 CONVERT(VarDateFromUI8, DATE_MAX+1); EXPECT_OVERFLOW;
2927 }
2928
2929 static void test_VarDateFromDec(void)
2930 {
2931 CONVVARS(DECIMAL);
2932
2933 CONVERT_BADDEC(VarDateFromDec);
2934
2935 CONVERT_DEC(VarDateFromDec,0,0x80,0,32768); EXPECT(-32768.0);
2936 CONVERT_DEC(VarDateFromDec,0,0x80,0,1); EXPECT(-1.0);
2937 CONVERT_DEC(VarDateFromDec,0,0,0,0); EXPECT(0.0);
2938 CONVERT_DEC(VarDateFromDec,0,0,0,1); EXPECT(1.0);
2939 CONVERT_DEC(VarDateFromDec,0,0,0,32767); EXPECT(32767.0);
2940
2941 CONVERT_DEC(VarDateFromDec,2,0x80,0,3276800); EXPECT(-32768.0);
2942 CONVERT_DEC(VarDateFromDec,2,0,0,3276700); EXPECT(32767.0);
2943 }
2944
2945 #define DFS(str) \
2946 buff[0] = '\0'; out = 0.0; \
2947 if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,ARRAY_SIZE(buff)); \
2948 hres = VarDateFromStr(str ? buff : NULL,lcid,LOCALE_NOUSEROVERRIDE,&out)
2949
2950 #define MKRELDATE(day,mth) st.wMonth = mth; st.wDay = day; \
2951 SystemTimeToVariantTime(&st,&relative)
2952
2953 static const char * const BadDateStrings[] =
2954 {
2955 "True", "False", /* Plain text */
2956 "0.", ".0", "-1.1", "1.1-", /* Partial specifications */
2957 "1;2;3", "1*2*3", "1@2@3", "1#2#3", "(1:2)","<1:2>","1|2|3", /* Bad chars */
2958 "0", "1", /* 1 element */
2959 "0.60", "24.00", "0:60", "24:00", "1 2 am", "1 am 2", /* 2 elements */
2960 "1.5 2", "1 5.2", "2 32 3", "1 2 am 3", /* 3 elements */
2961 "1 2.3 4", "1.2.3 4", "1 2.3.4", "1.2 3.4", "1.2.3.4", "1 2 3 4",
2962 "1 am 2 3.4", "1 2 am 3.4", "1.2 3 am 4", "1.2 3 4 am", /* 4 elements */
2963 "1.2.3.4.5", "1.2.3.4 5", "1.2.3 4.5", "1.2 3.4.5", "1.2 3.4 5", "1.2 3 4.5",
2964 "1 2.3.4.5", "1 2.3.4 5", "1 2.3 4.5", "1 2.3 4 5", "1 2 3.4 5", "1 2 3 4 5",
2965 "1.2.3 4 am 5", "1.2.3 4 5 am", "1.2 3 am 4 5",
2966 "1.2 3 4 am 5", "1.2 3 4 5 am", "1 am 2 3.4.5", "1 2 am 3.4.5",
2967 "1 am 2 3 4.5", "1 2 am 3 4.5", "1 2 3 am 4.5", /* 5 elements */
2968 /* 6 elements */
2969 "1.2.3.4.5.6", "1.2.3.4.5 6", "1.2.3.4 5.6", "1.2.3.4 5 6", "1.2.3 4.5.6",
2970 "1.2.3 4.5 6", "1.2.3 4 5.6", "1.2 3.4.5.6", "1.2 3.4.5 6", "1.2 3.4 5.6",
2971 "1.2 3.4 5 6", "1.2 3 4.5.6", "1.2 3 4.5 6", "1.2 3 4 5.6", "1.2 3 4 5 6",
2972 "1 2.3.4.5.6", "1 2.3.4.5 6", "1 2.3.4 5.6", "1 2.3.4 5 6", "1 2.3 4.5.6",
2973 #if 0
2974 /* following throws an exception on winME */
2975 "1 2.3 4.5 6", "1 2.3 4 5.6", "1 2.3 4 5 6", "1 2 3.4.5.6", "1 2 3.4.5 6",
2976 #endif
2977 "1 2 3.4 5.6", "1 2 3.4 5 6", "1 2 3 4.5 6", "1 2 3 4 5.6", "1 2 3 4 5 6",
2978 #if 0
2979 /* following throws an exception on winME */
2980 "1.2.3 4 am 5 6", "1.2.3 4 5 am 6", "1.2.3 4 5 6 am", "1 am 2 3 4.5.6",
2981 #endif
2982 "1 2 am 3 4.5.6", "1 2 3 am 4.5.6"
2983 };
2984
2985 static void test_VarDateFromStr(void)
2986 {
2987 LCID lcid;
2988 DATE out, relative;
2989 HRESULT hres;
2990 SYSTEMTIME st;
2991 OLECHAR buff[128];
2992 size_t i;
2993 OLECHAR with_ideographic_spaceW[] = { '6','/','3','0','/','2','0','1','1',0x3000,
2994 '1',':','2','0',':','3','4',0 };
2995
2996 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
2997
2998 /* Some date formats are relative, so we need to find the current year */
2999 GetSystemTime(&st);
3000 st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
3001 DFS(NULL); EXPECT_MISMATCH;
3002
3003 /* Floating point number are not recognised */
3004 DFS("0.0");
3005 if (hres == S_OK)
3006 EXPECT_DBL(0.0); /* Very old versions accept this string */
3007 else
3008 EXPECT_MISMATCH;
3009
3010 /* 1 element - can only be a time, and only if it has am/pm */
3011 DFS("1 am"); EXPECT_DBL(0.04166666666666666);
3012 /* 2 elements */
3013 /* A decimal point is treated as a time separator.
3014 * The following are converted as hours/minutes.
3015 */
3016 DFS("0.1"); EXPECT_DBL(0.0006944444444444445);
3017 DFS("0.40"); EXPECT_DBL(0.02777777777777778);
3018 DFS("2.5"); EXPECT_DBL(0.08680555555555555);
3019 /* A colon acts as a decimal point */
3020 DFS("0:1"); EXPECT_DBL(0.0006944444444444445);
3021 DFS("0:20"); EXPECT_DBL(0.01388888888888889);
3022 DFS("0:40"); EXPECT_DBL(0.02777777777777778);
3023 DFS("3:5"); EXPECT_DBL(0.1284722222222222);
3024 /* Check the am/pm limits */
3025 DFS("00:00 AM"); EXPECT_DBL(0.0);
3026 DFS("00:00 a"); EXPECT_DBL(0.0);
3027 DFS("12:59 AM"); EXPECT_DBL(0.04097222222222222);
3028 DFS("12:59 A"); EXPECT_DBL(0.04097222222222222);
3029 DFS("00:00 pm"); EXPECT_DBL(0.5);
3030 DFS("00:00 p"); EXPECT_DBL(0.5);
3031 DFS("12:59 pm"); EXPECT_DBL(0.5409722222222222);
3032 DFS("12:59 p"); EXPECT_DBL(0.5409722222222222);
3033 /* AM/PM is ignored if hours > 12 */
3034 DFS("13:00 AM"); EXPECT_DBL(0.5416666666666666);
3035 DFS("13:00 PM"); EXPECT_DBL(0.5416666666666666);
3036
3037 /* Space, dash and slash all indicate a date format. */
3038 /* If both numbers are valid month values => month/day of current year */
3039 DFS("1 2"); MKRELDATE(2,1); EXPECT_DBL(relative);
3040 DFS("2 1"); MKRELDATE(1,2); EXPECT_DBL(relative);
3041 /* one number not valid month, is a valid day, other number valid month:
3042 * that number becomes the day.
3043 */
3044 DFS("14 1"); MKRELDATE(14,1); EXPECT_DBL(relative);
3045 DFS("1 14"); EXPECT_DBL(relative);
3046 /* If the numbers can't be day/month, they are assumed to be year/month */
3047 DFS("30 2"); EXPECT_DBL(10990.0);
3048 DFS("2 30"); EXPECT_DBL(10990.0);
3049 DFS("32 49"); EXPECT_MISMATCH; /* Can't be any format */
3050 DFS("0 49"); EXPECT_MISMATCH; /* Can't be any format */
3051 /* If a month name is given the other number is the day */
3052 DFS("Jan 2"); MKRELDATE(2,1); EXPECT_DBL(relative);
3053 DFS("2 Jan"); EXPECT_DBL(relative);
3054 /* Unless it can't be, in which case it becomes the year */
3055 DFS("Jan 35"); EXPECT_DBL(12785.0);
3056 DFS("35 Jan"); EXPECT_DBL(12785.0);
3057 DFS("Jan-35"); EXPECT_DBL(12785.0);
3058 DFS("35-Jan"); EXPECT_DBL(12785.0);
3059 DFS("Jan/35"); EXPECT_DBL(12785.0);
3060 DFS("35/Jan"); EXPECT_DBL(12785.0);
3061 /* 3 elements */
3062 /* 3 numbers and time separator => h:m:s */
3063 DFS("0.1.0"); EXPECT_DBL(0.0006944444444444445);
3064 DFS("1.5.2"); EXPECT_DBL(0.04516203703703704);
3065 /* 3 numbers => picks date giving preference to lcid format */
3066 DFS("1 2 3"); EXPECT_DBL(37623.0);
3067 DFS("14 2 3"); EXPECT_DBL(41673.0);
3068 DFS("2 14 3"); EXPECT_DBL(37666.0);
3069 DFS("2 3 14"); EXPECT_DBL(41673.0);
3070 DFS("32 2 3"); EXPECT_DBL(11722.0);
3071 DFS("2 3 32"); EXPECT_DBL(11722.0);
3072 DFS("1 2 29"); EXPECT_DBL(47120.0);
3073 /* After 30, two digit dates are expected to be in the 1900's */
3074 DFS("1 2 30"); EXPECT_DBL(10960.0);
3075 DFS("1 2 31"); EXPECT_DBL(11325.0);
3076 DFS("3 am 1 2"); MKRELDATE(2,1); relative += 0.125; EXPECT_DBL(relative);
3077 DFS("1 2 3 am"); EXPECT_DBL(relative);
3078
3079 /* 4 elements -interpreted as 2 digit date & time */
3080 DFS("1.2 3 4"); MKRELDATE(4,3); relative += 0.04305555556; EXPECT_DBL(relative);
3081 DFS("3 4 1.2"); EXPECT_DBL(relative);
3082 /* 5 elements - interpreted as 2 & 3 digit date/times */
3083 DFS("1.2.3 4 5"); MKRELDATE(5,4); relative += 0.04309027778; EXPECT_DBL(relative);
3084 DFS("1.2 3 4 5"); EXPECT_DBL(38415.04305555556);
3085 #if 0
3086 /* following throws an exception on winME */
3087 DFS("1 2 3.4.5"); MKRELDATE(2,1); relative += 0.12783564815; EXPECT_DBL(relative);
3088 #endif
3089 DFS("1 2 3 4.5"); EXPECT_DBL(37623.17013888889);
3090 /* 6 elements - interpreted as 3 digit date/times */
3091 DFS("1.2.3 4 5 6"); EXPECT_DBL(38812.04309027778);
3092 DFS("1 2 3 4.5.6"); EXPECT_DBL(37623.17020833334);
3093
3094 for (i = 0; i < ARRAY_SIZE(BadDateStrings); i++)
3095 {
3096 DFS(BadDateStrings[i]); EXPECT_MISMATCH;
3097 }
3098
3099 /* Some normal-ish strings */
3100 DFS("2 January, 1970"); EXPECT_DBL(25570.0);
3101 DFS("2 January 1970"); EXPECT_DBL(25570.0);
3102 DFS("2 Jan 1970"); EXPECT_DBL(25570.0);
3103 DFS("2/Jan/1970"); EXPECT_DBL(25570.0);
3104 DFS("2-Jan-1970"); EXPECT_DBL(25570.0);
3105 DFS("1 2 1970"); EXPECT_DBL(25570.0);
3106 DFS("1/2/1970"); EXPECT_DBL(25570.0);
3107 DFS("1-2-1970"); EXPECT_DBL(25570.0);
3108 DFS("13-1-1970"); EXPECT_DBL(25581.0);
3109 DFS("1970-1-13"); EXPECT_DBL(25581.0);
3110 DFS("6/30/2011 01:20:34"); EXPECT_DBL(40724.05594907407);
3111 DFS("6/30/2011 01:20:34 AM"); EXPECT_DBL(40724.05594907407);
3112 DFS("6/30/2011 01:20:34 PM"); EXPECT_DBL(40724.55594907407);
3113 DFS("2013-05-14 02:04:12"); EXPECT_DBL(41408.08625000001);
3114 DFS("2013-05-14 02:04:12.017000000"); EXPECT_MISMATCH;
3115 /* Native fails "1999 January 3, 9AM". I consider that a bug in native */
3116
3117 /* test a data with ideographic space */
3118 out = 0.0;
3119 hres = VarDateFromStr(with_ideographic_spaceW, lcid, LOCALE_NOUSEROVERRIDE, &out);
3120 EXPECT_DBL(40724.05594907407);
3121
3122 /* test a non-english data string */
3123 DFS("02.01.1970"); EXPECT_MISMATCH;
3124 DFS("02.01.1970 00:00:00"); EXPECT_MISMATCH;
3125 lcid = MAKELCID(MAKELANGID(LANG_GERMAN,SUBLANG_GERMAN),SORT_DEFAULT);
3126 DFS("02.01.1970"); EXPECT_DBL(25570.0);
3127 DFS("02.13.1970"); EXPECT_DBL(25612.0);
3128 DFS("02-13-1970"); EXPECT_DBL(25612.0);
3129 DFS("2020-01-11"); EXPECT_DBL(43841.0);
3130 DFS("2173-10-14"); EXPECT_DBL(100000.0);
3131
3132 DFS("02.01.1970 00:00:00"); EXPECT_DBL(25570.0);
3133 lcid = MAKELCID(MAKELANGID(LANG_SPANISH,SUBLANG_SPANISH),SORT_DEFAULT);
3134 DFS("02.01.1970"); EXPECT_MISMATCH;
3135 DFS("02.01.1970 00:00:00"); EXPECT_MISMATCH;
3136 }
3137
3138 static void test_VarDateCopy(void)
3139 {
3140 COPYTEST(77665544.0, VT_DATE, V_DATE(&vSrc), V_DATE(&vDst), V_DATEREF(&vSrc),
3141 V_DATEREF(&vDst), "%16.16g");
3142 }
3143
3144 static const char* wtoascii(LPWSTR lpszIn)
3145 {
3146 static char buff[256];
3147 WideCharToMultiByte(CP_ACP, 0, lpszIn, -1, buff, sizeof(buff), NULL, NULL);
3148 return buff;
3149 }
3150
3151 static void test_VarDateChangeTypeEx(void)
3152 {
3153 static const WCHAR sz25570[] = {
3154 '1','/','2','/','1','9','7','0','\0' };
3155 static const WCHAR sz25570_2[] = {
3156 '1','/','2','/','7','0','\0' };
3157 static const WCHAR sz25570Nls[] = {
3158 '1','/','2','/','1','9','7','0',' ','1','2',':','0','0',':','0','0',' ','A','M','\0' };
3159 HRESULT hres;
3160 DATE in;
3161 VARIANTARG vSrc, vDst;
3162 LCID lcid;
3163
3164 in = 1.0;
3165
3166 #ifdef HAS_UINT64_TO_FLOAT
3167 INITIAL_TYPETEST(VT_DATE, V_DATE, "%g");
3168 COMMON_TYPETEST;
3169 #endif
3170
3171 V_VT(&vDst) = VT_EMPTY;
3172 V_VT(&vSrc) = VT_DATE;
3173 V_DATE(&vSrc) = 25570.0;
3174 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
3175
3176 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, VARIANT_NOUSEROVERRIDE, VT_BSTR);
3177 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && V_BSTR(&vDst) &&
3178 (!lstrcmpW(V_BSTR(&vDst), sz25570) || !lstrcmpW(V_BSTR(&vDst), sz25570_2)),
3179 "hres=0x%X, type=%d (should be VT_BSTR), *bstr=%s\n",
3180 hres, V_VT(&vDst), V_BSTR(&vDst) ? wtoascii(V_BSTR(&vDst)) : "?");
3181 VariantClear(&vDst);
3182
3183 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
3184 if (has_locales)
3185 {
3186 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, VARIANT_NOUSEROVERRIDE|VARIANT_USE_NLS, VT_BSTR);
3187 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && V_BSTR(&vDst) && !lstrcmpW(V_BSTR(&vDst), sz25570Nls),
3188 "hres=0x%X, type=%d (should be VT_BSTR), *bstr=%s\n",
3189 hres, V_VT(&vDst), V_BSTR(&vDst) ? wtoascii(V_BSTR(&vDst)) : "?");
3190 VariantClear(&vDst);
3191 }
3192 }
3193
3194 /*
3195 * VT_CY
3196 */
3197
3198 #undef CONV_TYPE
3199 #define CONV_TYPE CY
3200
3201 #define EXPECTCY(x) \
3202 ok((hres == S_OK && out.int64 == (LONGLONG)(x*CY_MULTIPLIER)), \
3203 "expected " #x "*CY_MULTIPLIER, got (%8x %8x); hres=0x%08x\n", S(out).Hi, S(out).Lo, hres)
3204
3205 #define EXPECTCY64(x,y) \
3206 ok(hres == S_OK && S(out).Hi == (LONG)x && S(out).Lo == y, \
3207 "expected " #x " " #y " (%u,%u), got (%u,%u); hres=0x%08x\n", \
3208 (ULONG)(x), (ULONG)(y), S(out).Hi, S(out).Lo, hres)
3209
3210 static void test_VarCyFromI1(void)
3211 {
3212 CONVVARS(signed char);
3213 int i;
3214
3215 for (i = -128; i < 128; i++)
3216 {
3217 CONVERT(VarCyFromI1,i); EXPECTCY(i);
3218 }
3219 }
3220
3221 static void test_VarCyFromUI1(void)
3222 {
3223 CONVVARS(BYTE);
3224 int i;
3225
3226 for (i = 0; i < 256; i++)
3227 {
3228 CONVERT(VarCyFromUI1,i); EXPECTCY(i);
3229 }
3230 }
3231
3232 static void test_VarCyFromI2(void)
3233 {
3234 CONVVARS(SHORT);
3235 int i;
3236
3237 for (i = -16384; i < 16384; i++)
3238 {
3239 CONVERT(VarCyFromI2,i); EXPECTCY(i);
3240 }
3241 }
3242
3243 static void test_VarCyFromUI2(void)
3244 {
3245 CONVVARS(int);
3246 int i;
3247
3248 for (i = 0; i < 32768; i++)
3249 {
3250 CONVERT(VarCyFromUI2,i); EXPECTCY(i);
3251 }
3252 }
3253
3254 static void test_VarCyFromI4(void)
3255 {
3256 CONVVARS(int);
3257
3258 CONVERT(VarCyFromI4, -1); EXPECTCY(-1);
3259 CONVERT(VarCyFromI4, 0); EXPECTCY(0);
3260 CONVERT(VarCyFromI4, 1); EXPECTCY(1);
3261 CONVERT(VarCyFromI4, 0x7fffffff); EXPECTCY64(0x1387, 0xffffd8f0);
3262 CONVERT(VarCyFromI4, 0x80000000); EXPECTCY64(0xffffec78, 0);
3263 }
3264
3265 static void test_VarCyFromUI4(void)
3266 {
3267 CONVVARS(unsigned int);
3268
3269 CONVERT(VarCyFromUI4, 0); EXPECTCY(0);
3270 CONVERT(VarCyFromUI4, 1); EXPECTCY(1);
3271 CONVERT(VarCyFromUI4, 0x80000000); EXPECTCY64(5000, 0);
3272 }
3273
3274 static void test_VarCyFromR4(void)
3275 {
3276 CONVVARS(FLOAT);
3277
3278 CONVERT(VarCyFromR4, -1.0f); EXPECTCY(-1);
3279 CONVERT(VarCyFromR4, 0.0f); EXPECTCY(0);
3280 CONVERT(VarCyFromR4, 1.0f); EXPECTCY(1);
3281 CONVERT(VarCyFromR4, 1.5f); EXPECTCY(1.5);
3282
3283 CONVERT(VarCyFromR4, -1.5f); EXPECTCY(-1.5);
3284 CONVERT(VarCyFromR4, -0.6f); EXPECTCY(-0.6);
3285 CONVERT(VarCyFromR4, -0.5f); EXPECTCY(-0.5);
3286 CONVERT(VarCyFromR4, -0.4f); EXPECTCY(-0.4);
3287 CONVERT(VarCyFromR4, 0.4f); EXPECTCY(0.4);
3288 CONVERT(VarCyFromR4, 0.5f); EXPECTCY(0.5);
3289 CONVERT(VarCyFromR4, 0.6f); EXPECTCY(0.6);
3290 CONVERT(VarCyFromR4, 1.5f); EXPECTCY(1.5);
3291 CONVERT(VarCyFromR4, 1.00009f); EXPECTCY(1.0001);
3292 CONVERT(VarCyFromR4, -1.00001f); EXPECTCY(-1);
3293 CONVERT(VarCyFromR4, -1.00005f); EXPECTCY(-1);
3294 CONVERT(VarCyFromR4, -0.00009f); EXPECTCY(-0.0001);
3295 CONVERT(VarCyFromR4, -0.00005f); EXPECTCY(0);
3296 CONVERT(VarCyFromR4, -0.00001f); EXPECTCY(0);
3297 CONVERT(VarCyFromR4, 0.00001f); EXPECTCY(0);
3298 CONVERT(VarCyFromR4, 0.00005f); EXPECTCY(0);
3299 CONVERT(VarCyFromR4, 0.00009f); EXPECTCY(0.0001);
3300 CONVERT(VarCyFromR4, -1.00001f); EXPECTCY(-1);
3301 CONVERT(VarCyFromR4, -1.00005f); EXPECTCY(-1);
3302 CONVERT(VarCyFromR4, -1.00009f); EXPECTCY(-1.0001);
3303 }
3304
3305 static void test_VarCyFromR8(void)
3306 {
3307 CONVVARS(DOUBLE);
3308
3309 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3310 /* Test our rounding is exactly the same. This fails if the special x86
3311 * code is taken out of VarCyFromR8.
3312 */
3313 CONVERT(VarCyFromR8, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
3314 #endif
3315
3316 CONVERT(VarCyFromR8, -4611686018427388416.1); EXPECT_OVERFLOW;
3317 CONVERT(VarCyFromR8, -1.0); EXPECTCY(-1);
3318 CONVERT(VarCyFromR8, -0.0); EXPECTCY(0);
3319 CONVERT(VarCyFromR8, 1.0); EXPECTCY(1);
3320 CONVERT(VarCyFromR8, 4611686018427387648.0); EXPECT_OVERFLOW;
3321
3322 /* Rounding */
3323 CONVERT(VarCyFromR8, -1.5f); EXPECTCY(-1.5);
3324 CONVERT(VarCyFromR8, -0.6f); EXPECTCY(-0.6);
3325 CONVERT(VarCyFromR8, -0.5f); EXPECTCY(-0.5);
3326 CONVERT(VarCyFromR8, -0.4f); EXPECTCY(-0.4);
3327 CONVERT(VarCyFromR8, 0.4f); EXPECTCY(0.4);
3328 CONVERT(VarCyFromR8, 0.5f); EXPECTCY(0.5);
3329 CONVERT(VarCyFromR8, 0.6f); EXPECTCY(0.6);
3330 CONVERT(VarCyFromR8, 1.5f); EXPECTCY(1.5);
3331 CONVERT(VarCyFromR8, 1.00009f); EXPECTCY(1.0001);
3332 CONVERT(VarCyFromR8, -1.00001f); EXPECTCY(-1);
3333 CONVERT(VarCyFromR8, -1.00005f); EXPECTCY(-1);
3334 CONVERT(VarCyFromR8, -0.00009f); EXPECTCY(-0.0001);
3335 CONVERT(VarCyFromR8, -0.00005f); EXPECTCY(0);
3336 CONVERT(VarCyFromR8, -0.00001f); EXPECTCY(0);
3337 CONVERT(VarCyFromR8, 0.00001f); EXPECTCY(0);
3338 CONVERT(VarCyFromR8, 0.00005f); EXPECTCY(0);
3339 CONVERT(VarCyFromR8, 0.00009f); EXPECTCY(0.0001);
3340 CONVERT(VarCyFromR8, -1.00001f); EXPECTCY(-1);
3341 CONVERT(VarCyFromR8, -1.00005f); EXPECTCY(-1);
3342 CONVERT(VarCyFromR8, -1.00009f); EXPECTCY(-1.0001);
3343 }
3344
3345 static void test_VarCyFromBool(void)
3346 {
3347 CONVVARS(VARIANT_BOOL);
3348 int i;
3349
3350 for (i = -32768; i < 32768; i++)
3351 {
3352 CONVERT(VarCyFromBool, i); EXPECTCY(i);
3353 }
3354 }
3355
3356 static void test_VarCyFromI8(void)
3357 {
3358 CONVVARS(LONG64);
3359
3360 CONVERT_I8(VarCyFromI8, -214749, 2728163227ul); EXPECT_OVERFLOW;
3361 CONVERT_I8(VarCyFromI8, -214749, 2728163228ul); EXPECTCY64(2147483648ul,15808);
3362 CONVERT(VarCyFromI8, -1); EXPECTCY(-1);
3363 CONVERT(VarCyFromI8, 0); EXPECTCY(0);
3364 CONVERT(VarCyFromI8, 1); EXPECTCY(1);
3365 CONVERT_I8(VarCyFromI8, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3366 CONVERT_I8(VarCyFromI8, 214748, 1566804069); EXPECT_OVERFLOW;
3367 }
3368
3369 static void test_VarCyFromUI8(void)
3370 {
3371 CONVVARS(ULONG64);
3372
3373 CONVERT(VarCyFromUI8, 0); EXPECTCY(0);
3374 CONVERT(VarCyFromUI8, 1); EXPECTCY(1);
3375 CONVERT_I8(VarCyFromUI8, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3376 CONVERT_I8(VarCyFromUI8, 214748, 1566804069); EXPECTCY64(2147483647ul, 4294961488ul);
3377 CONVERT_I8(VarCyFromUI8, 214748, 1566804070); EXPECT_OVERFLOW;
3378 CONVERT_I8(VarCyFromUI8, 214749, 1566804068); EXPECT_OVERFLOW;
3379 }
3380
3381 static void test_VarCyFromDec(void)
3382 {
3383 CONVVARS(DECIMAL);
3384
3385 CONVERT_BADDEC(VarCyFromDec);
3386
3387 CONVERT_DEC(VarCyFromDec,0,0x80,0,1); EXPECTCY(-1);
3388 CONVERT_DEC(VarCyFromDec,0,0,0,0); EXPECTCY(0);
3389 CONVERT_DEC(VarCyFromDec,0,0,0,1); EXPECTCY(1);
3390
3391 CONVERT_DEC64(VarCyFromDec,0,0,0,214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3392 CONVERT_DEC64(VarCyFromDec,0,0,0,214748, 1566804069); EXPECTCY64(2147483647ul, 4294961488ul);
3393 CONVERT_DEC64(VarCyFromDec,0,0,0,214748, 1566804070); EXPECT_OVERFLOW;
3394 CONVERT_DEC64(VarCyFromDec,0,0,0,214749, 1566804068); EXPECT_OVERFLOW;
3395
3396 CONVERT_DEC(VarCyFromDec,2,0,0,100); EXPECTCY(1);
3397 CONVERT_DEC(VarCyFromDec,2,0x80,0,100); EXPECTCY(-1);
3398 CONVERT_DEC(VarCyFromDec,2,0x80,0,1); EXPECTCY(-0.01);
3399 CONVERT_DEC(VarCyFromDec,2,0,0,1); EXPECTCY(0.01);
3400 CONVERT_DEC(VarCyFromDec,2,0x80,0,1); EXPECTCY(-0.01);
3401 CONVERT_DEC(VarCyFromDec,2,0,0,999); EXPECTCY(9.99);
3402 CONVERT_DEC(VarCyFromDec,2,0x80,0,999); EXPECTCY(-9.99);
3403 CONVERT_DEC(VarCyFromDec,2,0,0,1500); EXPECTCY(15);
3404 CONVERT_DEC(VarCyFromDec,2,0x80,0,1500); EXPECTCY(-15);
3405 }
3406
3407 static void test_VarCyFromDate(void)
3408 {
3409 CONVVARS(DATE);
3410
3411 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3412 CONVERT(VarCyFromR8, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
3413 #endif
3414
3415 CONVERT(VarCyFromDate, -1.0); EXPECTCY(-1);
3416 CONVERT(VarCyFromDate, -0.0); EXPECTCY(0);
3417 CONVERT(VarCyFromDate, 1.0); EXPECTCY(1);
3418 CONVERT(VarCyFromDate, -4611686018427388416.1); EXPECT_OVERFLOW;
3419 CONVERT(VarCyFromDate, 4611686018427387648.0); EXPECT_OVERFLOW;
3420
3421 /* Rounding */
3422 CONVERT(VarCyFromDate, -1.5f); EXPECTCY(-1.5);
3423 CONVERT(VarCyFromDate, -0.6f); EXPECTCY(-0.6);
3424 CONVERT(VarCyFromDate, -0.5f); EXPECTCY(-0.5);
3425 CONVERT(VarCyFromDate, -0.4f); EXPECTCY(-0.4);
3426 CONVERT(VarCyFromDate, 0.4f); EXPECTCY(0.4);
3427 CONVERT(VarCyFromDate, 0.5f); EXPECTCY(0.5);
3428 CONVERT(VarCyFromDate, 0.6f); EXPECTCY(0.6);
3429 CONVERT(VarCyFromDate, 1.5f); EXPECTCY(1.5);
3430 CONVERT(VarCyFromDate, 1.00009f); EXPECTCY(1.0001);
3431 CONVERT(VarCyFromDate, -1.00001f); EXPECTCY(-1);
3432 CONVERT(VarCyFromDate, -1.00005f); EXPECTCY(-1);
3433 CONVERT(VarCyFromDate, -0.00009f); EXPECTCY(-0.0001);
3434 CONVERT(VarCyFromDate, -0.00005f); EXPECTCY(0);
3435 CONVERT(VarCyFromDate, -0.00001f); EXPECTCY(0);
3436 CONVERT(VarCyFromDate, 0.00001f); EXPECTCY(0);
3437 CONVERT(VarCyFromDate, 0.00005f); EXPECTCY(0);
3438 CONVERT(VarCyFromDate, 0.00009f); EXPECTCY(0.0001);
3439 CONVERT(VarCyFromDate, -1.00001f); EXPECTCY(-1);
3440 CONVERT(VarCyFromDate, -1.00005f); EXPECTCY(-1);
3441 CONVERT(VarCyFromDate, -1.00009f); EXPECTCY(-1.0001);
3442 }
3443
3444 #define MATHVARS1 HRESULT hres; double left = 0.0; CY cyLeft, out
3445 #define MATHVARS2 MATHVARS1; double right = 0.0; CY cyRight
3446 #define MATH1(func, l) left = (double)l; VarCyFromR8(left, &cyLeft); hres = func(cyLeft, &out)
3447 #define MATH2(func, l, r) left = (double)l; right = (double)r; \
3448 VarCyFromR8(left, &cyLeft); VarCyFromR8(right, &cyRight); \
3449 hres = func(cyLeft, cyRight, &out)
3450
3451 static void test_VarCyAdd(void)
3452 {
3453 MATHVARS2;
3454
3455 MATH2(VarCyAdd, 0.5, 0.5); EXPECTCY(1);
3456 MATH2(VarCyAdd, 0.5, -0.4); EXPECTCY(0.1);
3457 MATH2(VarCyAdd, 0.5, -0.6); EXPECTCY(-0.1);
3458 MATH2(VarCyAdd, -0.5, -0.5); EXPECTCY(-1);
3459 MATH2(VarCyAdd, -922337203685476.0, -922337203685476.0); EXPECT_OVERFLOW;
3460 MATH2(VarCyAdd, -922337203685476.0, 922337203685476.0); EXPECTCY(0);
3461 MATH2(VarCyAdd, 922337203685476.0, -922337203685476.0); EXPECTCY(0);
3462 MATH2(VarCyAdd, 922337203685476.0, 922337203685476.0); EXPECT_OVERFLOW;
3463 }
3464
3465 static void test_VarCyMul(void)
3466 {
3467 MATHVARS2;
3468
3469 MATH2(VarCyMul, 534443.0, 0.0); EXPECTCY(0);
3470 MATH2(VarCyMul, 0.5, 0.5); EXPECTCY(0.25);
3471 MATH2(VarCyMul, 0.5, -0.4); EXPECTCY(-0.2);
3472 MATH2(VarCyMul, 0.5, -0.6); EXPECTCY(-0.3);
3473 MATH2(VarCyMul, -0.5, -0.5); EXPECTCY(0.25);
3474 MATH2(VarCyMul, 922337203685476.0, 20000); EXPECT_OVERFLOW;
3475 }
3476
3477 static void test_VarCySub(void)
3478 {
3479 MATHVARS2;
3480
3481 MATH2(VarCySub, 0.5, 0.5); EXPECTCY(0);
3482 MATH2(VarCySub, 0.5, -0.4); EXPECTCY(0.9);
3483 MATH2(VarCySub, 0.5, -0.6); EXPECTCY(1.1);
3484 MATH2(VarCySub, -0.5, -0.5); EXPECTCY(0);
3485 MATH2(VarCySub, -922337203685476.0, -922337203685476.0); EXPECTCY(0);
3486 MATH2(VarCySub, -922337203685476.0, 922337203685476.0); EXPECT_OVERFLOW;
3487 MATH2(VarCySub, 922337203685476.0, -922337203685476.0); EXPECT_OVERFLOW;
3488 MATH2(VarCySub, 922337203685476.0, 922337203685476.0); EXPECTCY(0);
3489 }
3490
3491 static void test_VarCyAbs(void)
3492 {
3493 MATHVARS1;
3494
3495 MATH1(VarCyAbs, 0.5); EXPECTCY(0.5);
3496 MATH1(VarCyAbs, -0.5); EXPECTCY(0.5);
3497 MATH1(VarCyAbs, 922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3498 MATH1(VarCyAbs, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3499 }
3500
3501 static void test_VarCyNeg(void)
3502 {
3503 MATHVARS1;
3504
3505 MATH1(VarCyNeg, 0.5); EXPECTCY(-0.5);
3506 MATH1(VarCyNeg, -0.5); EXPECTCY(0.5);
3507 MATH1(VarCyNeg, 922337203685476.0); EXPECTCY64(2147483648ul,15808);
3508 MATH1(VarCyNeg, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3509 }
3510
3511 #define MATHMULI4(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
3512 hres = VarCyMulI4(cyLeft, right, &out)
3513
3514 static void test_VarCyMulI4(void)
3515 {
3516 MATHVARS1;
3517 LONG right;
3518
3519 MATHMULI4(534443.0, 0); EXPECTCY(0);
3520 MATHMULI4(0.5, 1); EXPECTCY(0.5);
3521 MATHMULI4(0.5, 2); EXPECTCY(1);
3522 MATHMULI4(922337203685476.0, 1); EXPECTCY64(2147483647ul,4294951488ul);
3523 MATHMULI4(922337203685476.0, 2); EXPECT_OVERFLOW;
3524 }
3525
3526 #define MATHMULI8(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
3527 hres = VarCyMulI8(cyLeft, right, &out)
3528
3529 static void test_VarCyMulI8(void)
3530 {
3531 MATHVARS1;
3532 LONG64 right;
3533
3534 MATHMULI8(534443.0, 0); EXPECTCY(0);
3535 MATHMULI8(0.5, 1); EXPECTCY(0.5);
3536 MATHMULI8(0.5, 2); EXPECTCY(1);
3537 MATHMULI8(922337203685476.0, 1); EXPECTCY64(2147483647ul,4294951488ul);
3538 MATHMULI8(922337203685476.0, 2); EXPECT_OVERFLOW;
3539 }
3540
3541 #define MATHCMP(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); VarCyFromR8(right, &cyRight); \
3542 hres = VarCyCmp(cyLeft, cyRight)
3543
3544 static void test_VarCyCmp(void)
3545 {
3546 HRESULT hres;
3547 double left = 0.0, right = 0.0;
3548 CY cyLeft, cyRight;
3549
3550 MATHCMP(-1.0, -1.0); EXPECT_EQ;
3551 MATHCMP(-1.0, 0.0); EXPECT_LT;
3552 MATHCMP(-1.0, 1.0); EXPECT_LT;
3553 MATHCMP(-1.0, 2.0); EXPECT_LT;
3554 MATHCMP(0.0, 1.0); EXPECT_LT;
3555 MATHCMP(0.0, 0.0); EXPECT_EQ;
3556 MATHCMP(0.0, -1.0); EXPECT_GT;
3557 MATHCMP(1.0, -1.0); EXPECT_GT;
3558 MATHCMP(1.0, 0.0); EXPECT_GT;
3559 MATHCMP(1.0, 1.0); EXPECT_EQ;
3560 MATHCMP(1.0, 2.0); EXPECT_LT;
3561 }
3562
3563 #define MATHCMPR8(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
3564 hres = VarCyCmpR8(cyLeft, right);
3565
3566 static void test_VarCyCmpR8(void)
3567 {
3568 HRESULT hres;
3569 double left = 0.0;
3570 CY cyLeft;
3571 double right;
3572
3573 MATHCMPR8(-1.0, -1.0); EXPECT_EQ;
3574 MATHCMPR8(-1.0, 0.0); EXPECT_LT;
3575 MATHCMPR8(-1.0, 1.0); EXPECT_LT;
3576 MATHCMPR8(-1.0, 2.0); EXPECT_LT;
3577 MATHCMPR8(0.0, 1.0); EXPECT_LT;
3578 MATHCMPR8(0.0, 0.0); EXPECT_EQ;
3579 MATHCMPR8(0.0, -1.0); EXPECT_GT;
3580 MATHCMPR8(1.0, -1.0); EXPECT_GT;
3581 MATHCMPR8(1.0, 0.0); EXPECT_GT;
3582 MATHCMPR8(1.0, 1.0); EXPECT_EQ;
3583 MATHCMPR8(1.0, 2.0); EXPECT_LT;
3584 }
3585
3586 #undef MATHRND
3587 #define MATHRND(l, r) left = l; right = r; VarCyFromR8(left, &cyLeft); \
3588 hres = VarCyRound(cyLeft, right, &out)
3589
3590 static void test_VarCyRound(void)
3591 {
3592 MATHVARS1;
3593 int right;
3594
3595 MATHRND(0.5432, 5); EXPECTCY(0.5432);
3596 MATHRND(0.5432, 4); EXPECTCY(0.5432);
3597 MATHRND(0.5432, 3); EXPECTCY(0.543);
3598 MATHRND(0.5432, 2); EXPECTCY(0.54);
3599 MATHRND(0.5432, 1); EXPECTCY(0.5);
3600 MATHRND(0.5532, 0); EXPECTCY(1);
3601 MATHRND(0.5532, -1); EXPECT_INVALID;
3602
3603 MATHRND(0.5568, 5); EXPECTCY(0.5568);
3604 MATHRND(0.5568, 4); EXPECTCY(0.5568);
3605 MATHRND(0.5568, 3); EXPECTCY(0.557);
3606 MATHRND(0.5568, 2); EXPECTCY(0.56);
3607 MATHRND(0.5568, 1); EXPECTCY(0.6);
3608 MATHRND(0.5568, 0); EXPECTCY(1);
3609 MATHRND(0.5568, -1); EXPECT_INVALID;
3610
3611 MATHRND(0.4999, 0); EXPECTCY(0);
3612 MATHRND(0.5000, 0); EXPECTCY(0);
3613 MATHRND(0.5001, 0); EXPECTCY(1);
3614 MATHRND(1.4999, 0); EXPECTCY(1);
3615 MATHRND(1.5000, 0); EXPECTCY(2);
3616 MATHRND(1.5001, 0); EXPECTCY(2);
3617 }
3618
3619 #define MATHFIX(l) left = l; VarCyFromR8(left, &cyLeft); \
3620 hres = VarCyFix(cyLeft, &out)
3621
3622 static void test_VarCyFix(void)
3623 {
3624 MATHVARS1;
3625
3626 MATHFIX(-1.0001); EXPECTCY(-1);
3627 MATHFIX(-1.4999); EXPECTCY(-1);
3628 MATHFIX(-1.5001); EXPECTCY(-1);
3629 MATHFIX(-1.9999); EXPECTCY(-1);
3630 MATHFIX(-0.0001); EXPECTCY(0);
3631 MATHFIX(-0.4999); EXPECTCY(0);
3632 MATHFIX(-0.5001); EXPECTCY(0);
3633 MATHFIX(-0.9999); EXPECTCY(0);
3634 MATHFIX(0.0001); EXPECTCY(0);
3635 MATHFIX(0.4999); EXPECTCY(0);
3636 MATHFIX(0.5001); EXPECTCY(0);
3637 MATHFIX(0.9999); EXPECTCY(0);
3638 MATHFIX(1.0001); EXPECTCY(1);
3639 MATHFIX(1.4999); EXPECTCY(1);
3640 MATHFIX(1.5001); EXPECTCY(1);
3641 MATHFIX(1.9999); EXPECTCY(1);
3642 }
3643
3644 #define MATHINT(l) left = l; VarCyFromR8(left, &cyLeft); \
3645 hres = VarCyInt(cyLeft, &out)
3646
3647 static void test_VarCyInt(void)
3648 {
3649 MATHVARS1;
3650
3651 MATHINT(-1.0001); EXPECTCY(-2);
3652 MATHINT(-1.4999); EXPECTCY(-2);
3653 MATHINT(-1.5001); EXPECTCY(-2);
3654 MATHINT(-1.9999); EXPECTCY(-2);
3655 MATHINT(-0.0001); EXPECTCY(-1);
3656 MATHINT(-0.4999); EXPECTCY(-1);
3657 MATHINT(-0.5001); EXPECTCY(-1);
3658 MATHINT(-0.9999); EXPECTCY(-1);
3659 MATHINT(0.0001); EXPECTCY(0);
3660 MATHINT(0.4999); EXPECTCY(0);
3661 MATHINT(0.5001); EXPECTCY(0);
3662 MATHINT(0.9999); EXPECTCY(0);
3663 MATHINT(1.0001); EXPECTCY(1);
3664 MATHINT(1.4999); EXPECTCY(1);
3665 MATHINT(1.5001); EXPECTCY(1);
3666 MATHINT(1.9999); EXPECTCY(1);
3667 }
3668
3669 /*
3670 * VT_DECIMAL
3671 */
3672
3673 #undef CONV_TYPE
3674 #define CONV_TYPE DECIMAL
3675
3676 #define EXPECTDEC(scl, sgn, hi, lo) ok(hres == S_OK && \
3677 S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
3678 out.Hi32 == (ULONG)(hi) && U1(out).Lo64 == (ULONG64)(lo), \
3679 "expected (%d,%d,%d,(%x %x)), got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
3680 scl, sgn, hi, (LONG)((LONG64)(lo) >> 32), (LONG)((lo) & 0xffffffff), S(U(out)).scale, \
3681 S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
3682
3683 #define EXPECTDEC64(scl, sgn, hi, mid, lo) ok(hres == S_OK && \
3684 S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
3685 out.Hi32 == (ULONG)(hi) && S1(U1(out)).Mid32 == (ULONG)(mid) && \
3686 S1(U1(out)).Lo32 == (ULONG)(lo), \
3687 "expected (%d,%d,%d,(%x %x)), got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
3688 scl, sgn, hi, (LONG)(mid), (LONG)(lo), S(U(out)).scale, \
3689 S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
3690
3691 /* expect either a positive or negative zero */
3692 #define EXPECTDECZERO() ok(hres == S_OK && S(U(out)).scale == 0 && \
3693 (S(U(out)).sign == 0 || S(U(out)).sign == 0x80) && out.Hi32 == 0 && U1(out).Lo64 == 0, \
3694 "expected zero, got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
3695 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
3696
3697 #define EXPECTDECI if (i < 0) EXPECTDEC(0, 0x80, 0, -i); else EXPECTDEC(0, 0, 0, i)
3698
3699 static void test_VarDecFromI1(void)
3700 {
3701 CONVVARS(signed char);
3702 int i;
3703
3704 for (i = -128; i < 128; i++)
3705 {
3706 CONVERT(VarDecFromI1,i); EXPECTDECI;
3707 }
3708 }
3709
3710 static void test_VarDecFromI2(void)
3711 {
3712 CONVVARS(SHORT);
3713 int i;
3714
3715 for (i = -32768; i < 32768; i++)
3716 {
3717 CONVERT(VarDecFromI2,i); EXPECTDECI;
3718 }
3719 }
3720
3721 static void test_VarDecFromI4(void)
3722 {
3723 CONVVARS(LONG);
3724 int i;
3725
3726 for (i = -32768; i < 32768; i++)
3727 {
3728 CONVERT(VarDecFromI4,i); EXPECTDECI;
3729 }
3730 }
3731
3732 static void test_VarDecFromI8(void)
3733 {
3734 CONVVARS(LONG64);
3735 int i;
3736
3737 for (i = -32768; i < 32768; i++)
3738 {
3739 CONVERT(VarDecFromI8,i); EXPECTDECI;
3740 }
3741 }
3742
3743 static void test_VarDecFromUI1(void)
3744 {
3745 CONVVARS(BYTE);
3746 int i;
3747
3748 for (i = 0; i < 256; i++)
3749 {
3750 CONVERT(VarDecFromUI1,i); EXPECTDECI;
3751 }
3752 }
3753
3754 static void test_VarDecFromUI2(void)
3755 {
3756 CONVVARS(USHORT);
3757 int i;
3758
3759 for (i = 0; i < 65536; i++)
3760 {
3761 CONVERT(VarDecFromUI2,i); EXPECTDECI;
3762 }
3763 }
3764
3765 static void test_VarDecFromUI4(void)
3766 {
3767 CONVVARS(ULONG);
3768 int i;
3769
3770 for (i = 0; i < 65536; i++)
3771 {
3772 CONVERT(VarDecFromUI4,i); EXPECTDECI;
3773 }
3774 }
3775
3776 static void test_VarDecFromUI8(void)
3777 {
3778 CONVVARS(ULONG64);
3779 int i;
3780
3781 for (i = 0; i < 65536; i++)
3782 {
3783 CONVERT(VarDecFromUI8,i); EXPECTDECI;
3784 }
3785 }
3786
3787 static void test_VarDecFromBool(void)
3788 {
3789 CONVVARS(SHORT);
3790 int i;
3791
3792 /* Test all possible type values. Note that the result is reduced to 0 or -1 */
3793 for (i = -32768; i < 0; i++)
3794 {
3795 CONVERT(VarDecFromBool,i);
3796 if (i)
3797 EXPECTDEC(0,0x80,0,1);
3798 else
3799 EXPECTDEC(0,0,0,0);
3800 }
3801 }
3802
3803 static void test_VarDecFromR4(void)
3804 {
3805 CONVVARS(float);
3806
3807 CONVERT(VarDecFromR4,-0.6f); EXPECTDEC(1,0x80,0,6);
3808 CONVERT(VarDecFromR4,-0.5f); EXPECTDEC(1,0x80,0,5);
3809 CONVERT(VarDecFromR4,-0.4f); EXPECTDEC(1,0x80,0,4);
3810 CONVERT(VarDecFromR4,0.0f); EXPECTDEC(0,0,0,0);
3811 CONVERT(VarDecFromR4,0.4f); EXPECTDEC(1,0,0,4);
3812 CONVERT(VarDecFromR4,0.5f); EXPECTDEC(1,0,0,5);
3813 CONVERT(VarDecFromR4,0.6f); EXPECTDEC(1,0,0,6);
3814 }
3815
3816 static void test_VarDecFromR8(void)
3817 {
3818 CONVVARS(double);
3819
3820 CONVERT(VarDecFromR8,-0.6); EXPECTDEC(1,0x80,0,6);
3821 CONVERT(VarDecFromR8,-0.5); EXPECTDEC(1,0x80,0,5);
3822 CONVERT(VarDecFromR8,-0.4); EXPECTDEC(1,0x80,0,4);
3823 CONVERT(VarDecFromR8,0.0); EXPECTDEC(0,0,0,0);
3824 CONVERT(VarDecFromR8,0.4); EXPECTDEC(1,0,0,4);
3825 CONVERT(VarDecFromR8,0.5); EXPECTDEC(1,0,0,5);
3826 CONVERT(VarDecFromR8,0.6); EXPECTDEC(1,0,0,6);
3827 }
3828
3829 static void test_VarDecFromDate(void)
3830 {
3831 CONVVARS(DATE);
3832
3833 CONVERT(VarDecFromDate,-0.6); EXPECTDEC(1,0x80,0,6);
3834 CONVERT(VarDecFromDate,-0.5); EXPECTDEC(1,0x80,0,5);
3835 CONVERT(VarDecFromDate,-0.4); EXPECTDEC(1,0x80,0,4);
3836 CONVERT(VarDecFromDate,0.0); EXPECTDEC(0,0,0,0);
3837 CONVERT(VarDecFromDate,0.4); EXPECTDEC(1,0,0,4);
3838 CONVERT(VarDecFromDate,0.5); EXPECTDEC(1,0,0,5);
3839 CONVERT(VarDecFromDate,0.6); EXPECTDEC(1,0,0,6);
3840 }
3841
3842 static void test_VarDecFromStr(void)
3843 {
3844 CONVVARS(LCID);
3845 OLECHAR buff[128];
3846
3847 in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
3848
3849 CONVERT_STR(VarDecFromStr,NULL,0); EXPECT_MISMATCH;
3850 CONVERT_STR(VarDecFromStr,"-1", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0x80,0,1);
3851 CONVERT_STR(VarDecFromStr,"0", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,0,0);
3852 CONVERT_STR(VarDecFromStr,"1", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,0,1);
3853 CONVERT_STR(VarDecFromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECTDEC(1,0,0,5);
3854 CONVERT_STR(VarDecFromStr,"4294967296", LOCALE_NOUSEROVERRIDE); EXPECTDEC64(0,0,0,1,0);
3855 CONVERT_STR(VarDecFromStr,"18446744073709551616", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,1,0);
3856 CONVERT_STR(VarDecFromStr,"4294967296.0", LOCALE_NOUSEROVERRIDE); EXPECTDEC64(0,0,0,1,0);
3857 CONVERT_STR(VarDecFromStr,"18446744073709551616.0", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,1,0);
3858 }
3859
3860 static void test_VarDecFromCy(void)
3861 {
3862 CONVVARS(CY);
3863
3864 CONVERT_CY(VarDecFromCy, -1); EXPECTDEC(4,0x80,0,10000);
3865 CONVERT_CY(VarDecFromCy, 0); EXPECTDEC(4,0,0,0);
3866 CONVERT_CY(VarDecFromCy, 1); EXPECTDEC(4,0,0,10000);
3867 CONVERT_CY(VarDecFromCy, 0.5); EXPECTDEC(4,0,0,5000);
3868 }
3869
3870 #undef MATHVARS1
3871 #define MATHVARS1 HRESULT hres; DECIMAL l, out
3872 #undef MATHVARS2
3873 #define MATHVARS2 MATHVARS1; DECIMAL r
3874 #undef MATH1
3875 #define MATH1(func) hres = func(&l, &out)
3876 #undef MATH2
3877 #define MATH2(func) hres = func(&l, &r, &out)
3878 #undef MATH3
3879 #define MATH3(func) hres = func(&l, r)
3880
3881 static void test_VarDecAbs(void)
3882 {
3883 MATHVARS1;
3884
3885 SETDEC(l,0,0x80,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
3886 SETDEC(l,0,0,0,0); MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
3887 SETDEC(l,0,0x80,0,0); MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
3888 SETDEC(l,0,0,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
3889
3890 /* Doesn't check for invalid input */
3891 SETDEC(l,0,0x7f,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0x7f,0,1);
3892 SETDEC(l,0,0x80,29,1); MATH1(VarDecAbs); EXPECTDEC(0,0,29,1);
3893 }
3894
3895 static void test_VarDecNeg(void)
3896 {
3897 MATHVARS1;
3898
3899 SETDEC(l,0,0x80,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0,0,1);
3900 SETDEC(l,0,0,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,0); /* '-0'! */
3901 SETDEC(l,0,0x80,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0,0,0);
3902 SETDEC(l,0,0,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,1);
3903
3904 /* Doesn't check for invalid input */
3905 SETDEC(l,0,0x7f,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0xff,0,1);
3906 SETDEC(l,0,0x80,29,1); MATH1(VarDecNeg); EXPECTDEC(0,0,29,1);
3907 SETDEC(l,0,0,29,1); MATH1(VarDecNeg); EXPECTDEC(0,0x80,29,1);
3908 }
3909
3910 static void test_VarDecAdd(void)
3911 {
3912 MATHVARS2;
3913
3914 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0);
3915 SETDEC(l,0,0,0,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
3916 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
3917
3918 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
3919 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,2);
3920 SETDEC(l,0,0,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDECZERO();
3921 SETDEC(l,0,0,0,1); SETDEC(r,0,0x80,0,2); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
3922
3923 SETDEC(l,0,0x80,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
3924 SETDEC(l,0,0x80,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDECZERO();
3925 SETDEC(l,0,0x80,0,1); SETDEC(r,0,0,0,2); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
3926 SETDEC(l,0,0x80,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,2);
3927 SETDEC(l,0,0x80,0,2); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
3928
3929 SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0xfffffffe);
3930 SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,(ULONG64)1 << 32);
3931 SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,(ULONG64)1 << 32);
3932
3933 SETDEC64(l,0,0,0,0xffffffff,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC64(0,0,0,0xffffffff,1);
3934 SETDEC64(l,0,0,0,0xffffffff,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
3935 EXPECTDEC64(0,0,0,0xfffffffe,0xffffffff);
3936
3937 SETDEC64(l,0,0,0,0xffffffff,0xffffffff); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,1,0);
3938 SETDEC64(l,0,0,0,0xffffffff,0xffffffff); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
3939 EXPECTDEC64(0,0,0,0xffffffff,0xfffffffe);
3940
3941 SETDEC(l,0,0,0xffffffff,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0xffffffff,1);
3942 SETDEC(l,0,0,0xffffffff,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
3943 EXPECTDEC64(0,0,0xfffffffe,0xffffffff,0xffffffff);
3944
3945 SETDEC64(l,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
3946 EXPECTDEC64(0,0,0xffffffff,0xffffffff,0xfffffffe);
3947 SETDEC64(l,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,0,0,0,1); MATH2(VarDecAdd);
3948 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
3949 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
3950
3951 SETDEC64(l,1,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,1,0,0,1); MATH2(VarDecAdd);
3952 todo_wine EXPECTDEC64(0,0,0x19999999,0x99999999,0x9999999A);
3953
3954 SETDEC64(l,0,0,0xe22ea493,0xb30310a7,0x70000000);SETDEC64(r,0,0,0xe22ea493,0xb30310a7,0x70000000); MATH2(VarDecAdd);
3955 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
3956 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
3957
3958 SETDEC64(l,1,0,0xe22ea493,0xb30310a7,0x70000000);SETDEC64(r,1,0,0xe22ea493,0xb30310a7,0x70000000); MATH2(VarDecAdd);
3959 todo_wine EXPECTDEC64(0,0,0x2d3c8750,0xbd670354,0xb0000000);
3960
3961 SETDEC(l,3,128,0,123456); SETDEC64(r,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
3962 MATH2(VarDecAdd); EXPECTDEC64(0,0,-1,0xFFFFFFFF,0xFFFFFF84);
3963
3964 SETDEC(l,3,0,0,123456); SETDEC64(r,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecAdd);
3965 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
3966 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
3967
3968 SETDEC(l,4,0,0,123456); SETDEC64(r,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecAdd);
3969 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
3970 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
3971
3972 SETDEC(l,5,0,0,123456); SETDEC64(r,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecAdd);
3973 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
3974 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
3975
3976 SETDEC(l,6,0,0,123456); SETDEC64(r,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
3977 MATH2(VarDecAdd); EXPECTDEC64(0,0,-1,0xFFFFFFFF,0xFFFFFFFF);
3978
3979 SETDEC(l,3,128,0,123456); SETDEC64(r,0,0,0x19999999,0x99999999,0x99999999);
3980 MATH2(VarDecAdd); EXPECTDEC64(1,0,-1,0xFFFFFFFF,0xFFFFFB27);
3981
3982 SETDEC(l,3,128,0,123567); SETDEC64(r,0,0,0x19999999,0x99999999,0x99999999);
3983 MATH2(VarDecAdd); EXPECTDEC64(1,0,-1,0xFFFFFFFF,0xFFFFFB26);
3984
3985 /* Promotes to the highest scale, so here the results are in the scale of 2 */
3986 SETDEC(l,2,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(2,0,0,0);
3987 SETDEC(l,2,0,0,100); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(2,0,0,200);
3988 }
3989
3990 static void test_VarDecSub(void)
3991 {
3992 MATHVARS2;
3993
3994 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecSub); EXPECTDECZERO();
3995 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecSub); EXPECTDEC(0,0x80,0,1);
3996 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecSub); EXPECTDECZERO();
3997 SETDEC(l,0,0,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecSub); EXPECTDEC(0,0,0,2);
3998 }
3999
4000 static void test_VarDecMul(void)
4001 {
4002 MATHVARS2;
4003
4004 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
4005 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
4006 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
4007 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecMul); EXPECTDEC(0,0,0,1);
4008 SETDEC(l,0,0,0,45000);SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC(0,0,0,90000);
4009 SETDEC(l,0,0,0,2); SETDEC(r,0,0,0,45000); MATH2(VarDecMul); EXPECTDEC(0,0,0,90000);
4010
4011 SETDEC(l,0,0x80,0,2); SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC(0,0x80,0,4);
4012 SETDEC(l,0,0,0,2); SETDEC(r,0,0x80,0,2); MATH2(VarDecMul); EXPECTDEC(0,0x80,0,4);
4013 SETDEC(l,0,0x80,0,2); SETDEC(r,0,0x80,0,2); MATH2(VarDecMul); EXPECTDEC(0,0,0,4);
4014
4015 SETDEC(l,4,0,0,2); SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC(4,0,0,4);
4016 SETDEC(l,0,0,0,2); SETDEC(r,3,0,0,2); MATH2(VarDecMul); EXPECTDEC(3,0,0,4);
4017 SETDEC(l,4,0,0,2); SETDEC(r,3,0,0,2); MATH2(VarDecMul); EXPECTDEC(7,0,0,4);
4018 /* this last one shows that native oleaut32 does *not* gratuitously seize opportunities
4019 to reduce the scale if possible - the canonical result for the expected value is (6,0,0,1)
4020 */
4021 SETDEC(l,4,0,0,5); SETDEC(r,3,0,0,2); MATH2(VarDecMul); EXPECTDEC(7,0,0,10);
4022
4023 SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4024 SETDEC(l,0,0,0,2); SETDEC64(r,0,0,0,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecMul); EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4025 SETDEC(l,0,0,1,1); SETDEC(r,0,0,0,0x80000000); MATH2(VarDecMul); EXPECTDEC(0,0,0x80000000,0x80000000);
4026 SETDEC(l,0,0,0,0x80000000); SETDEC(r,0,0,1,1); MATH2(VarDecMul); EXPECTDEC(0,0,0x80000000,0x80000000);
4027
4028 /* near-overflow, used as a reference */
4029 SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC(r,0,0,0,2000000000); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4030 /* actual overflow - right operand is 10 times the previous value */
4031 SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r,0,0,0,4,0xA817C800); MATH2(VarDecMul);
4032 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4033 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4034 /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result */
4035 SETDEC64(l,1,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r,0,0,0,4,0xA817C800); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4036
4037 /* near-overflow, used as a reference */
4038 SETDEC64(l,0,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC(r,0,0,0,1000000000); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4039 /* actual overflow - right operand is 10 times the previous value */
4040 SETDEC64(l,0,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC64(r,0,0,0,2,0x540BE400); MATH2(VarDecMul);
4041 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4042 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4043 /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result */
4044 SETDEC64(l,1,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC64(r,0,0,0,2,0x540BE400); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4045
4046 /* this one shows that native oleaut32 is willing to lose significant digits in order to avert an overflow */
4047 SETDEC64(l,2,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r,0,0,0,9,0x502F9001); MATH2(VarDecMul);EXPECTDEC64(1,0,0xee6b2800,0x19999998,0xab2e719a);
4048 }
4049
4050 static void test_VarDecDiv(void)
4051 {
4052 MATHVARS2;
4053
4054 /* identity divisions */
4055 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(0,0,0,0);
4056 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(0,0,0,1);
4057 SETDEC(l,1,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(1,0,0,1);
4058
4059 /* exact divisions */
4060 SETDEC(l,0,0,0,45); SETDEC(r,0,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,5);
4061 SETDEC(l,1,0,0,45); SETDEC(r,0,0,0,9); MATH2(VarDecDiv); EXPECTDEC(1,0,0,5);
4062 SETDEC(l,0,0,0,45); SETDEC(r,1,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,50);
4063 SETDEC(l,1,0,0,45); SETDEC(r,2,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,50);
4064 /* these last three results suggest that native oleaut32 scales both operands down to zero
4065 before the division, but does not always try to scale the result, even if it is possible -
4066 analogous to multiplication behavior.
4067 */
4068 SETDEC(l,1,0,0,45); SETDEC(r,1,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,5);
4069 SETDEC(l,2,0,0,450); SETDEC(r,1,0,0,9); MATH2(VarDecDiv);
4070 if (S(U(out)).scale == 1) EXPECTDEC(1,0,0,50);
4071 else EXPECTDEC(0,0,0,5);
4072
4073 /* inexact divisions */
4074 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4075 SETDEC(l,1,0,0,1); SETDEC(r,0,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,18070036,0x35458014,0x4d555555);
4076 SETDEC(l,0,0,0,1); SETDEC(r,1,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4077 SETDEC(l,1,0,0,1); SETDEC(r,2,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4078 SETDEC(l,1,0,0,1); SETDEC(r,1,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4079 SETDEC(l,2,0,0,10); SETDEC(r,1,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4080
4081 /* this one shows that native oleaut32 rounds up the result */
4082 SETDEC(l,0,0,0,2); SETDEC(r,0,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,361400724,0x296e0196,0x0aaaaaab);
4083
4084 /* sign tests */
4085 SETDEC(l,0,0x80,0,45); SETDEC(r,0,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0x80,0,5);
4086 SETDEC(l,0,0,0,45); SETDEC(r,0,0x80,0,9); MATH2(VarDecDiv);EXPECTDEC(0,0x80,0,5);
4087 SETDEC(l,0,0x80,0,45); SETDEC(r,0,0x80,0,9); MATH2(VarDecDiv);EXPECTDEC(0,0,0,5);
4088
4089 /* oddballs */
4090 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecDiv);/* indeterminate */
4091 ok(hres == DISP_E_DIVBYZERO,"Expected division-by-zero, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4092 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4093 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecDiv);/* division by zero */
4094 ok(hres == DISP_E_DIVBYZERO,"Expected division-by-zero, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4095 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4096
4097 }
4098
4099 static void test_VarDecCmp(void)
4100 {
4101 MATHVARS1;
4102
4103 SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4104 SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4105 SETDEC(l,0,0,0,1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4106
4107 SETDEC(l,0,0,0,1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4108 SETDEC(l,0,0,0,1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4109 SETDEC(l,0,0,0,1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4110
4111 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4112 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4113 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4114
4115 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4116 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4117 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4118
4119 SETDEC(l,0,0,0,0); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4120 SETDEC(l,0,0,0,0); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4121 SETDEC(l,0,0,0,0); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4122
4123 SETDEC(l,0,0,0,0); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4124 SETDEC(l,0,0,0,0); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4125 SETDEC(l,0,0,0,0); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4126
4127 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4128 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4129 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4130
4131 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4132 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4133 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4134
4135 SETDEC(l,0,0,-1,-1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4136 SETDEC(l,0,0,-1,-1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4137 SETDEC(l,0,0,-1,-1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4138
4139 SETDEC(l,0,0,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4140 SETDEC(l,0,0,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4141 SETDEC(l,0,0,-1,-1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4142
4143 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4144 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4145 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4146
4147 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4148 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4149 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4150
4151
4152 SETDEC(out,0,0,0,1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4153 SETDEC(out,0,0,0,1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4154 SETDEC(out,0,0,0,1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4155
4156 SETDEC(out,0,0,0,1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4157 SETDEC(out,0,0,0,1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4158 SETDEC(out,0,0,0,1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4159
4160 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4161 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4162 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4163
4164 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4165 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4166 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4167
4168 SETDEC(out,0,0,0,0); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4169 SETDEC(out,0,0,0,0); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4170 SETDEC(out,0,0,0,0); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4171
4172 SETDEC(out,0,0,0,0); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4173 SETDEC(out,0,0,0,0); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4174 SETDEC(out,0,0,0,0); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4175
4176 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4177 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4178 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4179
4180 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4181 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4182 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4183
4184 SETDEC(out,0,0,-1,-1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4185 SETDEC(out,0,0,-1,-1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4186 SETDEC(out,0,0,-1,-1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4187
4188 SETDEC(out,0,0,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4189 SETDEC(out,0,0,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4190 SETDEC(out,0,0,-1,-1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4191
4192 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4193 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4194 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4195
4196 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4197 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4198 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4199
4200 SETDEC(l,3,0,0,123456); SETDEC64(out,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
4201 MATH1(VarDecCmp); EXPECT_LT;
4202 }
4203
4204 static void test_VarDecCmpR8(void)
4205 {
4206 HRESULT hres;
4207 DECIMAL l;
4208 double r;
4209
4210 SETDEC(l,0,0,0,1); r = 0.0; MATH3(VarDecCmpR8); EXPECT_GT;
4211 SETDEC(l,0,0,0,1); r = 0.1; MATH3(VarDecCmpR8); EXPECT_GT;
4212 SETDEC(l,0,0,0,1); r = -0.1; MATH3(VarDecCmpR8); EXPECT_GT;
4213
4214 SETDEC(l,0,DECIMAL_NEG,0,1); r = 0.0; MATH3(VarDecCmpR8); EXPECT_LT;
4215 SETDEC(l,0,DECIMAL_NEG,0,1); r = 0.1; MATH3(VarDecCmpR8); EXPECT_LT;
4216 SETDEC(l,0,DECIMAL_NEG,0,1); r = -0.1; MATH3(VarDecCmpR8); EXPECT_LT;
4217
4218 SETDEC(l,0,0,0,0); r = 0.0; MATH3(VarDecCmpR8); EXPECT_EQ;
4219 SETDEC(l,0,0,0,0); r = 0.1; MATH3(VarDecCmpR8); EXPECT_LT;
4220 SETDEC(l,0,0,0,0); r = -0.1; MATH3(VarDecCmpR8); EXPECT_GT;
4221
4222 SETDEC(l,0,DECIMAL_NEG,0,0); r = 0.0; MATH3(VarDecCmpR8); EXPECT_EQ;
4223 SETDEC(l,0,DECIMAL_NEG,0,0); r = 0.1; MATH3(VarDecCmpR8); EXPECT_LT;
4224 SETDEC(l,0,DECIMAL_NEG,0,0); r = -0.1; MATH3(VarDecCmpR8); EXPECT_GT;
4225
4226 SETDEC(l,0,0,0,1); r = DECIMAL_NEG; MATH3(VarDecCmpR8); EXPECT_LT;
4227 SETDEC(l,0,DECIMAL_NEG,0,0); r = DECIMAL_NEG; MATH3(VarDecCmpR8); EXPECT_LT;
4228 SETDEC(l,0,0,-1,-1); r = DECIMAL_NEG; MATH3(VarDecCmpR8); EXPECT_GT;
4229 SETDEC(l,0,DECIMAL_NEG,-1,-1); r = DECIMAL_NEG; MATH3(VarDecCmpR8); EXPECT_LT;
4230 }
4231
4232 #define CLEAR(x) memset(&(x), 0xBB, sizeof(x))
4233
4234 static void test_VarDecRound(void)
4235 {
4236 HRESULT hres;
4237 DECIMAL l, out;
4238
4239 CLEAR(out); SETDEC(l, 0, 0, 0, 1); hres = VarDecRound(&l, 3, &out); EXPECTDEC(0, 0, 0, 1);
4240
4241 CLEAR(out); SETDEC(l, 0, 0, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, 0, 0, 1);
4242 CLEAR(out); SETDEC(l, 1, 0, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, 0, 0, 0);
4243 CLEAR(out); SETDEC(l, 1, 0, 0, 1); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 1);
4244 CLEAR(out); SETDEC(l, 2, 0, 0, 11); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 1);
4245 CLEAR(out); SETDEC(l, 2, 0, 0, 15); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 2);
4246 CLEAR(out); SETDEC(l, 6, 0, 0, 550001); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 6);
4247
4248 CLEAR(out); SETDEC(l, 0, DECIMAL_NEG, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, DECIMAL_NEG, 0, 1);
4249 CLEAR(out); SETDEC(l, 1, DECIMAL_NEG, 0, 1); hres = VarDecRound(&l, 0, &out); EXPECTDEC(0, DECIMAL_NEG, 0, 0);
4250 CLEAR(out); SETDEC(l, 1, DECIMAL_NEG, 0, 1); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 1);
4251 CLEAR(out); SETDEC(l, 2, DECIMAL_NEG, 0, 11); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 1);
4252 CLEAR(out); SETDEC(l, 2, DECIMAL_NEG, 0, 15); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 2);
4253 CLEAR(out); SETDEC(l, 6, DECIMAL_NEG, 0, 550001); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, DECIMAL_NEG, 0, 6);
4254
4255 CLEAR(out); SETDEC64(l, 0, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, 0, 0xffffffff, 0xffffffff, 0xffffffff);
4256 CLEAR(out); SETDEC64(l, 28, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, 0, 0, 0, 8);
4257 CLEAR(out); SETDEC64(l, 0, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff);
4258 CLEAR(out); SETDEC64(l, 28, DECIMAL_NEG, 0xffffffff, 0xffffffff, 0xffffffff); hres = VarDecRound(&l, 0, &out); EXPECTDEC64(0, DECIMAL_NEG, 0, 0, 8);
4259
4260 CLEAR(out); SETDEC(l, 2, 0, 0, 0); hres = VarDecRound(&l, 1, &out); EXPECTDEC(1, 0, 0, 0);
4261 }
4262
4263 /*
4264 * VT_BOOL
4265 */
4266
4267 #undef CONV_TYPE
4268 #define CONV_TYPE VARIANT_BOOL
4269 #undef EXPECTRES
4270 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
4271 #undef CONVERTRANGE
4272 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i++) { \
4273 CONVERT(func, i); if (i) { EXPECT(VARIANT_TRUE); } else { EXPECT(VARIANT_FALSE); } }
4274
4275 static void test_VarBoolFromI1(void)
4276 {
4277 CONVVARS(signed char);
4278 int i;
4279
4280 CONVERTRANGE(VarBoolFromI1, -128, 128);
4281 }
4282
4283 static void test_VarBoolFromUI1(void)
4284 {
4285 CONVVARS(BYTE);
4286 int i;
4287
4288 CONVERTRANGE(VarBoolFromUI1, 0, 256);
4289 }
4290
4291 static void test_VarBoolFromI2(void)
4292 {
4293 CONVVARS(SHORT);
4294 int i;
4295
4296 CONVERTRANGE(VarBoolFromI2, -32768, 32768);
4297 }
4298
4299 static void test_VarBoolFromUI2(void)
4300 {
4301 CONVVARS(USHORT);
4302 int i;
4303
4304 CONVERTRANGE(VarBoolFromUI2, 0, 65536);
4305 }
4306
4307 static void test_VarBoolFromI4(void)
4308 {
4309 CONVVARS(int);
4310
4311 CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
4312 CONVERT(VarBoolFromI4, -1); EXPECT(VARIANT_TRUE);
4313 CONVERT(VarBoolFromI4, 0); EXPECT(VARIANT_FALSE);
4314 CONVERT(VarBoolFromI4, 1); EXPECT(VARIANT_TRUE);
4315 CONVERT(VarBoolFromI4, 0x7fffffff); EXPECT(VARIANT_TRUE);
4316 }
4317
4318 static void test_VarBoolFromUI4(void)
4319 {
4320 CONVVARS(ULONG);
4321
4322 CONVERT(VarBoolFromI4, 0); EXPECT(VARIANT_FALSE);
4323 CONVERT(VarBoolFromI4, 1); EXPECT(VARIANT_TRUE);
4324 CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
4325 }
4326
4327 static void test_VarBoolFromR4(void)
4328 {
4329 CONVVARS(FLOAT);
4330
4331 CONVERT(VarBoolFromR4, -1.0f); EXPECT(VARIANT_TRUE);
4332 CONVERT(VarBoolFromR4, 0.0f); EXPECT(VARIANT_FALSE);
4333 CONVERT(VarBoolFromR4, 1.0f); EXPECT(VARIANT_TRUE);
4334 CONVERT(VarBoolFromR4, 1.5f); EXPECT(VARIANT_TRUE);
4335
4336 /* Rounding */
4337 CONVERT(VarBoolFromR4, -1.5f); EXPECT(VARIANT_TRUE);
4338 CONVERT(VarBoolFromR4, -0.6f); EXPECT(VARIANT_TRUE);
4339 CONVERT(VarBoolFromR4, -0.5f); EXPECT(VARIANT_TRUE);
4340 CONVERT(VarBoolFromR4, -0.4f); EXPECT(VARIANT_TRUE);
4341 CONVERT(VarBoolFromR4, 0.4f); EXPECT(VARIANT_TRUE);
4342 CONVERT(VarBoolFromR4, 0.5f); EXPECT(VARIANT_TRUE);
4343 CONVERT(VarBoolFromR4, 0.6f); EXPECT(VARIANT_TRUE);
4344 CONVERT(VarBoolFromR4, 1.5f); EXPECT(VARIANT_TRUE);
4345 }
4346
4347 static void test_VarBoolFromR8(void)
4348 {
4349 CONVVARS(DOUBLE);
4350
4351 /* Hopefully we made the point with R4 above that rounding is
4352 * irrelevant, so we'll skip that for R8 and Date
4353 */
4354 CONVERT(VarBoolFromR8, -1.0); EXPECT(VARIANT_TRUE);
4355 CONVERT(VarBoolFromR8, -0.0); EXPECT(VARIANT_FALSE);
4356 CONVERT(VarBoolFromR8, 1.0); EXPECT(VARIANT_TRUE);
4357 }
4358
4359 static void test_VarBoolFromCy(void)
4360 {
4361 CONVVARS(CY);
4362
4363 CONVERT_CY(VarBoolFromCy, -32769); EXPECT(VARIANT_TRUE);
4364 CONVERT_CY(VarBoolFromCy, -32768); EXPECT(VARIANT_TRUE);
4365 CONVERT_CY(VarBoolFromCy, -1); EXPECT(VARIANT_TRUE);
4366 CONVERT_CY(VarBoolFromCy, 0); EXPECT(VARIANT_FALSE);
4367 CONVERT_CY(VarBoolFromCy, 1); EXPECT(VARIANT_TRUE);
4368 CONVERT_CY(VarBoolFromCy, 32767); EXPECT(VARIANT_TRUE);
4369 CONVERT_CY(VarBoolFromCy, 32768); EXPECT(VARIANT_TRUE);
4370 }
4371
4372 static void test_VarBoolFromI8(void)
4373 {
4374 CONVVARS(LONG64);
4375
4376 CONVERT(VarBoolFromI8, -1); EXPECT(VARIANT_TRUE);
4377 CONVERT(VarBoolFromI8, 0); EXPECT(VARIANT_FALSE);
4378 CONVERT(VarBoolFromI8, 1); EXPECT(VARIANT_TRUE);
4379 }
4380
4381 static void test_VarBoolFromUI8(void)
4382 {
4383 CONVVARS(ULONG64);
4384
4385 CONVERT(VarBoolFromUI8, 0); EXPECT(VARIANT_FALSE);
4386 CONVERT(VarBoolFromUI8, 1); EXPECT(VARIANT_TRUE);
4387 }
4388
4389 static void test_VarBoolFromDec(void)
4390 {
4391 CONVVARS(DECIMAL);
4392
4393 CONVERT_BADDEC(VarBoolFromDec);
4394
4395 CONVERT_DEC(VarBoolFromDec,29,0,0,0); EXPECT_INVALID;
4396 CONVERT_DEC(VarBoolFromDec,0,0x1,0,0); EXPECT_INVALID;
4397 CONVERT_DEC(VarBoolFromDec,0,0x40,0,0); EXPECT_INVALID;
4398 CONVERT_DEC(VarBoolFromDec,0,0x7f,0,0); EXPECT_INVALID;
4399
4400 CONVERT_DEC(VarBoolFromDec,0,0x80,0,1); EXPECT(VARIANT_TRUE);
4401 CONVERT_DEC(VarBoolFromDec,0,0,0,0); EXPECT(VARIANT_FALSE);
4402 CONVERT_DEC(VarBoolFromDec,0,0,0,1); EXPECT(VARIANT_TRUE);
4403 CONVERT_DEC(VarBoolFromDec,0,0,1,0); EXPECT(VARIANT_TRUE);
4404
4405 CONVERT_DEC(VarBoolFromDec,2,0,0,CY_MULTIPLIER); EXPECT(VARIANT_TRUE);
4406 CONVERT_DEC(VarBoolFromDec,2,0x80,0,CY_MULTIPLIER); EXPECT(VARIANT_TRUE);
4407 }
4408
4409 static void test_VarBoolFromDate(void)
4410 {
4411 CONVVARS(DATE);
4412
4413 CONVERT(VarBoolFromDate, -1.0); EXPECT(VARIANT_TRUE);
4414 CONVERT(VarBoolFromDate, -0.0); EXPECT(VARIANT_FALSE);
4415 CONVERT(VarBoolFromDate, 1.0); EXPECT(VARIANT_TRUE);
4416 }
4417
4418 static void test_VarBoolFromStr(void)
4419 {
4420 CONVVARS(LCID);
4421 OLECHAR buff[128];
4422
4423 in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4424
4425 CONVERT_STR(VarBoolFromStr,NULL,0);
4426 if (hres != E_INVALIDARG)
4427 EXPECT_MISMATCH;
4428
4429 /* #FALSE# and #TRUE# Are always accepted */
4430 CONVERT_STR(VarBoolFromStr,"#FALSE#",0); EXPECT(VARIANT_FALSE);
4431 CONVERT_STR(VarBoolFromStr,"#TRUE#",0); EXPECT(VARIANT_TRUE);
4432
4433 /* Match of #FALSE# and #TRUE# is case sensitive */
4434 CONVERT_STR(VarBoolFromStr,"#False#",0); EXPECT_MISMATCH;
4435 /* But match against English is not */
4436 CONVERT_STR(VarBoolFromStr,"false",0); EXPECT(VARIANT_FALSE);
4437 CONVERT_STR(VarBoolFromStr,"False",0); EXPECT(VARIANT_FALSE);
4438 /* On/Off and yes/no are not acceptable inputs, with any flags set */
4439 CONVERT_STR(VarBoolFromStr,"On",0xffffffff); EXPECT_MISMATCH;
4440 CONVERT_STR(VarBoolFromStr,"Yes",0xffffffff); EXPECT_MISMATCH;
4441
4442 /* Change the LCID. This doesn't make any difference for text,unless we ask
4443 * to check local boolean text with the VARIANT_LOCALBOOL flag. */
4444 in = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
4445
4446 /* #FALSE# and #TRUE# are accepted in all locales */
4447 CONVERT_STR(VarBoolFromStr,"#FALSE#",0); EXPECT(VARIANT_FALSE);
4448 CONVERT_STR(VarBoolFromStr,"#TRUE#",0); EXPECT(VARIANT_TRUE);
4449 CONVERT_STR(VarBoolFromStr,"#FALSE#",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4450 CONVERT_STR(VarBoolFromStr,"#TRUE#",VARIANT_LOCALBOOL); EXPECT(VARIANT_TRUE);
4451
4452 /* English is accepted regardless of the locale */
4453 CONVERT_STR(VarBoolFromStr,"false",0); EXPECT(VARIANT_FALSE);
4454 /* And is still not case sensitive */
4455 CONVERT_STR(VarBoolFromStr,"False",0); EXPECT(VARIANT_FALSE);
4456
4457 if (has_locales)
4458 {
4459 /* French is rejected without VARIANT_LOCALBOOL */
4460 CONVERT_STR(VarBoolFromStr,"faux",0); EXPECT_MISMATCH;
4461 /* But accepted if this flag is given */
4462 CONVERT_STR(VarBoolFromStr,"faux",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4463 /* Regardless of case - from this we assume locale text comparisons ignore case */
4464 CONVERT_STR(VarBoolFromStr,"Faux",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4465
4466 /* Changing the locale prevents the localised text from being compared -
4467 * this demonstrates that only the indicated LCID and English are searched */
4468 in = MAKELCID(MAKELANGID(LANG_POLISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4469 CONVERT_STR(VarBoolFromStr,"faux",VARIANT_LOCALBOOL); EXPECT_MISMATCH;
4470 }
4471
4472 /* Numeric strings are read as 0 or non-0 */
4473 CONVERT_STR(VarBoolFromStr,"0",0); EXPECT(VARIANT_FALSE);
4474 CONVERT_STR(VarBoolFromStr,"-1",0); EXPECT(VARIANT_TRUE);
4475 CONVERT_STR(VarBoolFromStr,"+1",0); EXPECT(VARIANT_TRUE);
4476
4477 if (has_locales)
4478 {
4479 /* Numeric strings are read as floating point numbers. The line below fails
4480 * because '.' is not a valid decimal separator for Polish numbers */
4481 CONVERT_STR(VarBoolFromStr,"0.1",LOCALE_NOUSEROVERRIDE); EXPECT_MISMATCH;
4482 }
4483
4484 /* Changing the lcid back to US English reads the r8 correctly */
4485 in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4486 CONVERT_STR(VarBoolFromStr,"0.1",LOCALE_NOUSEROVERRIDE); EXPECT(VARIANT_TRUE);
4487 }
4488
4489 static void test_VarBoolCopy(void)
4490 {
4491 COPYTEST(1, VT_BOOL, V_BOOL(&vSrc), V_BOOL(&vDst), V_BOOLREF(&vSrc), V_BOOLREF(&vDst), "%d");
4492 }
4493
4494 #define BOOL_STR(flags, str) hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, flags, VT_BSTR); \
4495 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
4496 V_BSTR(&vDst) && !memcmp(V_BSTR(&vDst), str, sizeof(str)), \
4497 "hres=0x%X, type=%d (should be VT_BSTR), *bstr='%c'\n", \
4498 hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?'); \
4499 VariantClear(&vDst)
4500
4501 static void test_VarBoolChangeTypeEx(void)
4502 {
4503 static const WCHAR szTrue[] = { 'T','r','u','e','\0' };
4504 static const WCHAR szFalse[] = { 'F','a','l','s','e','\0' };
4505 static const WCHAR szFaux[] = { 'F','a','u','x','\0' };
4506 HRESULT hres;
4507 VARIANT_BOOL in;
4508 VARIANTARG vSrc, vDst;
4509 LCID lcid;
4510
4511 in = 1;
4512
4513 INITIAL_TYPETEST(VT_BOOL, V_BOOL, "%d");
4514 COMMON_TYPETEST;
4515
4516 /* The common tests convert to a number. Try the different flags */
4517 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4518
4519 V_VT(&vSrc) = VT_BOOL;
4520 V_BOOL(&vSrc) = 1;
4521
4522 BOOL_STR(VARIANT_ALPHABOOL, szTrue);
4523 V_BOOL(&vSrc) = 0;
4524 BOOL_STR(VARIANT_ALPHABOOL, szFalse);
4525
4526 if (has_locales)
4527 {
4528 lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
4529
4530 /* VARIANT_ALPHABOOL is always English */
4531 BOOL_STR(VARIANT_ALPHABOOL, szFalse);
4532 /* VARIANT_LOCALBOOL uses the localised text */
4533 BOOL_STR(VARIANT_LOCALBOOL, szFaux);
4534 /* Both flags together acts as VARIANT_LOCALBOOL */
4535 BOOL_STR(VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, szFaux);
4536 }
4537 }
4538
4539 /*
4540 * BSTR
4541 */
4542
4543 static void test_VarBstrFromI4(void)
4544 {
4545 static const WCHAR int_min[] = { '-','2','1','4','7','4','8','3','6','4','8','\0' };
4546 static const WCHAR minus_42[] = { '-','4','2','\0' };
4547 BSTR bstr = NULL;
4548 HRESULT hres;
4549 LONG value;
4550 LCID lcid;
4551
4552 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4553
4554 value = -2147483648;
4555 hres = VarBstrFromI4(value, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4556 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4557 if (bstr)
4558 {
4559 ok(memcmp(bstr, int_min, sizeof(int_min)) == 0, "string different\n");
4560 SysFreeString(bstr);
4561 }
4562
4563 value = -42;
4564 hres = VarBstrFromI4(value, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4565 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4566 if (bstr)
4567 {
4568 ok(memcmp(bstr, minus_42, sizeof(minus_42)) == 0, "string different\n");
4569 SysFreeString(bstr);
4570 }
4571 }
4572
4573 static void test_VarBstrFromR4(void)
4574 {
4575 static const WCHAR szNative[] = { '6','5','4','3','2','2','.','3','\0' };
4576 static const WCHAR szZero[] = {'0', '\0'};
4577 static const WCHAR szOneHalf_English[] = { '0','.','5','\0' }; /* uses period */
4578 static const WCHAR szOneHalf_Spanish[] = { '0',',','5','\0' }; /* uses comma */
4579 LCID lcid;
4580 LCID lcid_spanish;
4581 HRESULT hres;
4582 BSTR bstr = NULL;
4583
4584 float f;
4585
4586 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4587 lcid_spanish = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH), SORT_DEFAULT);
4588 f = 654322.23456f;
4589 hres = VarBstrFromR4(f, lcid, 0, &bstr);
4590 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4591 if (bstr)
4592 {
4593 todo_wine {
4594 /* MSDN states that rounding of R4/R8 is dependent on the underlying
4595 * bit pattern of the number and so is architecture dependent. In this
4596 * case Wine returns .2 (which is more correct) and Native returns .3
4597 */
4598 ok(memcmp(bstr, szNative, sizeof(szNative)) == 0, "string different\n");
4599 }
4600 SysFreeString(bstr);
4601 }
4602
4603 f = -0.0;
4604 hres = VarBstrFromR4(f, lcid, 0, &bstr);
4605 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4606 if (bstr)
4607 {
4608 if (bstr[0] == '-')
4609 ok(memcmp(bstr + 1, szZero, sizeof(szZero)) == 0, "negative zero (got %s)\n", wtoascii(bstr));
4610 else
4611 ok(memcmp(bstr, szZero, sizeof(szZero)) == 0, "negative zero (got %s)\n", wtoascii(bstr));
4612 SysFreeString(bstr);
4613 }
4614
4615 /* The following tests that lcid is used for decimal separator even without LOCALE_USE_NLS */
4616 f = 0.5;
4617 hres = VarBstrFromR4(f, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4618 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4619 if (bstr)
4620 {
4621 ok(memcmp(bstr, szOneHalf_English, sizeof(szOneHalf_English)) == 0, "English locale failed (got %s)\n", wtoascii(bstr));
4622 SysFreeString(bstr);
4623 }
4624 f = 0.5;
4625 hres = VarBstrFromR4(f, lcid_spanish, LOCALE_NOUSEROVERRIDE, &bstr);
4626 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4627 if (bstr)
4628 {
4629 ok(memcmp(bstr, szOneHalf_Spanish, sizeof(szOneHalf_Spanish)) == 0, "Spanish locale failed (got %s)\n", wtoascii(bstr));
4630 SysFreeString(bstr);
4631 }
4632 }
4633
4634 static void _BSTR_DATE(DATE dt, const char *str, int line)
4635 {
4636 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4637 char buff[256];
4638 BSTR bstr = NULL;
4639 HRESULT hres;
4640
4641 hres = VarBstrFromDate(dt, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4642 if (bstr)
4643 {
4644 WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
4645 SysFreeString(bstr);
4646 }
4647 else
4648 buff[0] = 0;
4649 ok_(__FILE__, line)(hres == S_OK && !strcmp(str, buff),
4650 "Expected '%s', got '%s', hres = 0x%08x\n", str, buff, hres);
4651 }
4652
4653 static void test_VarBstrFromDate(void)
4654 {
4655 #define BSTR_DATE(dt,str) _BSTR_DATE(dt,str,__LINE__)
4656
4657 BSTR_DATE(0.0, "12:00:00 AM");
4658 BSTR_DATE(3.34, "1/2/1900 8:09:36 AM");
4659 BSTR_DATE(3339.34, "2/20/1909 8:09:36 AM");
4660 BSTR_DATE(365.00, "12/30/1900");
4661 BSTR_DATE(365.25, "12/30/1900 6:00:00 AM");
4662 BSTR_DATE(1461.0, "12/31/1903");
4663 BSTR_DATE(1461.5, "12/31/1903 12:00:00 PM");
4664 BSTR_DATE(-49192.24, "4/24/1765 5:45:36 AM");
4665 BSTR_DATE(-657434.0, "1/1/100");
4666 BSTR_DATE(2958465.0, "12/31/9999");
4667
4668 #undef BSTR_DATE
4669 }
4670
4671 static void _BSTR_CY(LONG a, LONG b, const char *str, LCID lcid, int line)
4672 {
4673 HRESULT hr;
4674 BSTR bstr = NULL;
4675 char buff[256];
4676 CY l;
4677
4678 S(l).Lo = b;
4679 S(l).Hi = a;
4680 hr = VarBstrFromCy(l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4681 ok(hr == S_OK, "got hr 0x%08x\n", hr);
4682
4683 if(bstr)
4684 {
4685 WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
4686 SysFreeString(bstr);
4687 }
4688 else
4689 buff[0] = 0;
4690
4691 if(hr == S_OK)
4692 {
4693 ok_(__FILE__, line)(!strcmp(str, buff), "Expected '%s', got '%s'\n", str, buff);
4694 }
4695 }
4696
4697 static void test_VarBstrFromCy(void)
4698 {
4699 #define BSTR_CY(a, b, str, lcid) _BSTR_CY(a, b, str, lcid, __LINE__)
4700
4701 LCID en_us, sp;
4702
4703 en_us = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4704 sp = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4705
4706 BSTR_CY(0, 0, "0", en_us);
4707 BSTR_CY(0, 10000, "1", en_us);
4708 BSTR_CY(0, 15000, "1.5", en_us);
4709 BSTR_CY(0xffffffff, ((15000)^0xffffffff)+1, "-1.5", en_us);
4710 /* (1 << 32) - 1 / 1000 */
4711 BSTR_CY(0, 0xffffffff, "429496.7295", en_us);
4712 /* (1 << 32) / 1000 */
4713 BSTR_CY(1, 0, "429496.7296", en_us);
4714 /* ((1 << 63) - 1)/10000 */
4715 BSTR_CY(0x7fffffff, 0xffffffff, "922337203685477.5807", en_us);
4716 BSTR_CY(0, 9, "0.0009", en_us);
4717 BSTR_CY(0, 9, "0,0009", sp);
4718
4719 #undef BSTR_CY
4720 }
4721
4722 static void _BSTR_DEC(BYTE scale, BYTE sign, ULONG hi, ULONG mid, ULONGLONG lo, const char *str,
4723 LCID lcid, int line)
4724 {
4725 char buff[256];
4726 HRESULT hr;
4727 BSTR bstr = NULL;
4728 DECIMAL dec;
4729
4730 SETDEC64(dec, scale, sign, hi, mid, lo);
4731 hr = VarBstrFromDec(&dec, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4732 ok_(__FILE__, line)(hr == S_OK, "got hr 0x%08x\n", hr);
4733
4734 if(bstr)
4735 {
4736 WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0);
4737 SysFreeString(bstr);
4738 }
4739 else
4740 buff[0] = 0;
4741
4742 if(hr == S_OK)
4743 {
4744 ok_(__FILE__, line)(!strcmp(str, buff), "Expected '%s', got '%s'\n", str, buff);
4745 }
4746 }
4747
4748 static void test_VarBstrFromDec(void)
4749 {
4750 #define BSTR_DEC(scale, sign, hi, lo, str, lcid) _BSTR_DEC(scale, sign, hi, 0, lo, str, lcid, __LINE__)
4751 #define BSTR_DEC64(scale, sign, hi, mid, lo, str, lcid) _BSTR_DEC(scale, sign, hi, mid, lo, str, lcid, __LINE__)
4752
4753 LCID en_us, sp;
4754
4755 en_us = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4756 sp = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4757
4758 BSTR_DEC(0,0,0,0, "0", en_us);
4759
4760 BSTR_DEC(0,0,0,1, "1", en_us);
4761 BSTR_DEC(1,0,0,10, "1", en_us);
4762 BSTR_DEC(2,0,0,100, "1", en_us);
4763 BSTR_DEC(3,0,0,1000,"1", en_us);
4764
4765 BSTR_DEC(1,0,0,15, "1.5", en_us);
4766 BSTR_DEC(2,0,0,150, "1.5", en_us);
4767 BSTR_DEC(3,0,0,1500,"1.5", en_us);
4768
4769 BSTR_DEC(1,0x80,0,15, "-1.5", en_us);
4770
4771 /* (1 << 32) - 1 */
4772 BSTR_DEC(0,0,0,0xffffffff, "4294967295", en_us);
4773 /* (1 << 32) */
4774 BSTR_DEC64(0,0,0,1,0, "4294967296", en_us);
4775 /* (1 << 64) - 1 */
4776 BSTR_DEC64(0,0,0,0xffffffff,0xffffffff, "18446744073709551615", en_us);
4777 /* (1 << 64) */
4778 BSTR_DEC(0,0,1,0, "18446744073709551616", en_us);
4779 /* (1 << 96) - 1 */
4780 BSTR_DEC64(0,0,0xffffffff,0xffffffff,0xffffffff, "79228162514264337593543950335", en_us);
4781 /* 1 * 10^-10 */
4782 BSTR_DEC(10,0,0,1, "0.0000000001", en_us);
4783 /* ((1 << 96) - 1) * 10^-10 */
4784 BSTR_DEC64(10,0,0xffffffffUL,0xffffffff,0xffffffff, "7922816251426433759.3543950335", en_us);
4785 /* ((1 << 96) - 1) * 10^-28 */
4786 BSTR_DEC64(28,0,0xffffffffUL,0xffffffff,0xffffffff, "7.9228162514264337593543950335", en_us);
4787
4788 /* check leading zeros and decimal sep. for English locale */
4789 BSTR_DEC(4,0,0,9, "0.0009", en_us);
4790 BSTR_DEC(5,0,0,90, "0.0009", en_us);
4791 BSTR_DEC(6,0,0,900, "0.0009", en_us);
4792 BSTR_DEC(7,0,0,9000, "0.0009", en_us);
4793
4794 /* check leading zeros and decimal sep. for Spanish locale */
4795 BSTR_DEC(4,0,0,9, "0,0009", sp);
4796 BSTR_DEC(5,0,0,90, "0,0009", sp);
4797 BSTR_DEC(6,0,0,900, "0,0009", sp);
4798 BSTR_DEC(7,0,0,9000, "0,0009", sp);
4799
4800 #undef BSTR_DEC
4801 #undef BSTR_DEC64
4802 }
4803
4804 #define _VARBSTRCMP(left,right,lcid,flags,result) \
4805 hres = VarBstrCmp(left,right,lcid,flags); \
4806 ok(hres == result, "VarBstrCmp: expected " #result ", got hres=0x%x\n", hres)
4807 #define VARBSTRCMP(left,right,flags,result) \
4808 _VARBSTRCMP(left,right,lcid,flags,result)
4809
4810 static void test_VarBstrCmp(void)
4811 {
4812 LCID lcid;
4813 HRESULT hres;
4814 static const WCHAR sz[] = {'W','u','r','s','c','h','t','\0'};
4815 static const WCHAR szempty[] = {'\0'};
4816 static const WCHAR sz1[] = { 'a',0 };
4817 static const WCHAR sz2[] = { 'A',0 };
4818 static const WCHAR s1[] = { 'a',0 };
4819 static const WCHAR s2[] = { 'a',0,'b' };
4820 static const char sb1[] = {1,0,1};
4821 static const char sb2[] = {1,0,2};
4822 static const char sbchr0[] = {0,0};
4823 static const char sbchr00[] = {0,0,0};
4824 BSTR bstr, bstrempty, bstr2;
4825
4826 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4827 bstr = SysAllocString(sz);
4828 bstrempty = SysAllocString(szempty);
4829
4830 /* NULL handling. Yepp, MSDN is totally wrong here */
4831 VARBSTRCMP(NULL,NULL,0,VARCMP_EQ);
4832 VARBSTRCMP(bstr,NULL,0,VARCMP_GT);
4833 VARBSTRCMP(NULL,bstr,0,VARCMP_LT);
4834
4835 /* NULL and empty string comparisons */
4836 VARBSTRCMP(bstrempty,NULL,0,VARCMP_EQ);
4837 VARBSTRCMP(NULL,bstrempty,0,VARCMP_EQ);
4838
4839 SysFreeString(bstr);
4840 bstr = SysAllocString(sz1);
4841
4842 bstr2 = SysAllocString(sz2);
4843 VARBSTRCMP(bstr,bstr2,0,VARCMP_LT);
4844 VARBSTRCMP(bstr,bstr2,NORM_IGNORECASE,VARCMP_EQ);
4845 SysFreeString(bstr2);
4846 /* These two strings are considered equal even though one is
4847 * NULL-terminated and the other not.
4848 */
4849 bstr2 = SysAllocStringLen(s1, ARRAY_SIZE(s1));
4850 VARBSTRCMP(bstr,bstr2,0,VARCMP_EQ);
4851 SysFreeString(bstr2);
4852
4853 /* These two strings are not equal */
4854 bstr2 = SysAllocStringLen(s2, ARRAY_SIZE(s2));
4855 VARBSTRCMP(bstr,bstr2,0,VARCMP_LT);
4856 SysFreeString(bstr2);
4857
4858 SysFreeString(bstr);
4859
4860 bstr = SysAllocStringByteLen(sbchr0, sizeof(sbchr0));
4861 bstr2 = SysAllocStringByteLen(sbchr00, sizeof(sbchr00));
4862 VARBSTRCMP(bstr,bstrempty,0,VARCMP_GT);
4863 VARBSTRCMP(bstrempty,bstr,0,VARCMP_LT);
4864 VARBSTRCMP(bstr2,bstrempty,0,VARCMP_GT);
4865 VARBSTRCMP(bstr2,bstr,0,VARCMP_EQ);
4866 SysFreeString(bstr2);
4867 SysFreeString(bstr);
4868
4869 /* When (LCID == 0) it should be a binary comparison
4870 * so these two strings could not match.
4871 */
4872 bstr = SysAllocStringByteLen(sb1, sizeof(sb1));
4873 bstr2 = SysAllocStringByteLen(sb2, sizeof(sb2));
4874 lcid = 0;
4875 VARBSTRCMP(bstr,bstr2,0,VARCMP_LT);
4876 SysFreeString(bstr2);
4877 SysFreeString(bstr);
4878
4879 bstr = SysAllocStringByteLen(sbchr0, sizeof(sbchr0));
4880 bstr2 = SysAllocStringByteLen(sbchr00, sizeof(sbchr00));
4881 VARBSTRCMP(bstr,bstrempty,0,VARCMP_GT);
4882 VARBSTRCMP(bstrempty,bstr,0,VARCMP_LT);
4883 VARBSTRCMP(bstr2,bstrempty,0,VARCMP_GT);
4884 VARBSTRCMP(bstr2,bstr,0,VARCMP_GT);
4885 SysFreeString(bstr2);
4886 SysFreeString(bstr);
4887 SysFreeString(bstrempty);
4888 }
4889
4890 /* Get the internal representation of a BSTR */
4891 static inline LPINTERNAL_BSTR Get(const BSTR lpszString)
4892 {
4893 return lpszString ? (LPINTERNAL_BSTR)((char*)lpszString - sizeof(DWORD)) : NULL;
4894 }
4895
4896 static inline BSTR GetBSTR(const LPINTERNAL_BSTR bstr)
4897 {
4898 return (BSTR)bstr->szString;
4899 }
4900
4901 static void test_SysStringLen(void)
4902 {
4903 INTERNAL_BSTR bstr;
4904 BSTR str = GetBSTR(&bstr);
4905
4906 bstr.dwLen = 0;
4907 ok (SysStringLen(str) == 0, "Expected dwLen 0, got %d\n", SysStringLen(str));
4908 bstr.dwLen = 2;
4909 ok (SysStringLen(str) == 1, "Expected dwLen 1, got %d\n", SysStringLen(str));
4910 }
4911
4912 static void test_SysStringByteLen(void)
4913 {
4914 INTERNAL_BSTR bstr;
4915 BSTR str = GetBSTR(&bstr);
4916
4917 bstr.dwLen = 0;
4918 ok (SysStringByteLen(str) == 0, "Expected dwLen 0, got %d\n", SysStringByteLen(str));
4919 bstr.dwLen = 2;
4920 ok (SysStringByteLen(str) == 2, "Expected dwLen 2, got %d\n", SysStringByteLen(str));
4921 }
4922
4923 static void test_SysAllocString(void)
4924 {
4925 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
4926 BSTR str;
4927
4928 str = SysAllocString(NULL);
4929 ok (str == NULL, "Expected NULL, got %p\n", str);
4930
4931 str = SysAllocString(szTest);
4932 ok (str != NULL, "Expected non-NULL\n");
4933 if (str)
4934 {
4935 LPINTERNAL_BSTR bstr = Get(str);
4936 DWORD_PTR p = (DWORD_PTR)str;
4937 int align = sizeof(void *);
4938
4939 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
4940 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
4941 ok ((p & ~(align-1)) == p, "Not aligned to %d\n", align);
4942 SysFreeString(str);
4943 }
4944 }
4945
4946 static void test_SysAllocStringLen(void)
4947 {
4948 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
4949 BSTR str;
4950
4951 /* Very early native dlls do not limit the size of strings, so skip this test */
4952 if (0)
4953 {
4954 str = SysAllocStringLen(szTest, 0x80000000);
4955 ok (str == NULL, "Expected NULL, got %p\n", str);
4956 }
4957
4958 str = SysAllocStringLen(NULL, 0);
4959 ok (str != NULL, "Expected non-NULL\n");
4960 if (str)
4961 {
4962 LPINTERNAL_BSTR bstr = Get(str);
4963
4964 ok (bstr->dwLen == 0, "Expected 0, got %d\n", bstr->dwLen);
4965 ok (!bstr->szString[0], "String not empty\n");
4966 SysFreeString(str);
4967 }
4968
4969 str = SysAllocStringLen(szTest, 4);
4970 ok (str != NULL, "Expected non-NULL\n");
4971 if (str)
4972 {
4973 LPINTERNAL_BSTR bstr = Get(str);
4974
4975 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
4976 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
4977 SysFreeString(str);
4978 }
4979 }
4980
4981 static void test_SysAllocStringByteLen(void)
4982 {
4983 const OLECHAR szTest[10] = { 'T','e','s','t','\0' };
4984 const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
4985 char *buf;
4986 BSTR str;
4987 int i;
4988
4989 if (sizeof(void *) == 4) /* not limited to 0x80000000 on Win64 */
4990 {
4991 str = SysAllocStringByteLen(szTestA, 0x80000000);
4992 ok (str == NULL, "Expected NULL, got %p\n", str);
4993 }
4994
4995 str = SysAllocStringByteLen(szTestA, 0xffffffff);
4996 ok (str == NULL, "Expected NULL, got %p\n", str);
4997
4998 str = SysAllocStringByteLen(NULL, 0);
4999 ok (str != NULL, "Expected non-NULL\n");
5000 if (str)
5001 {
5002 LPINTERNAL_BSTR bstr = Get(str);
5003
5004 ok (bstr->dwLen == 0, "Expected 0, got %d\n", bstr->dwLen);
5005 ok (!bstr->szString[0], "String not empty\n");
5006 SysFreeString(str);
5007 }
5008
5009 str = SysAllocStringByteLen(szTestA, 4);
5010 ok (str != NULL, "Expected non-NULL\n");
5011 if (str)
5012 {
5013 LPINTERNAL_BSTR bstr = Get(str);
5014
5015 ok (bstr->dwLen == 4, "Expected 4, got %d\n", bstr->dwLen);
5016 ok (!lstrcmpA((LPCSTR)bstr->szString, szTestA), "String different\n");
5017 SysFreeString(str);
5018 }
5019
5020 /* Odd lengths are allocated rounded up, but truncated at the right position */
5021 str = SysAllocStringByteLen(szTestA, 3);
5022 ok (str != NULL, "Expected non-NULL\n");
5023 if (str)
5024 {
5025 const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
5026 LPINTERNAL_BSTR bstr = Get(str);
5027
5028 ok (bstr->dwLen == 3, "Expected 3, got %d\n", bstr->dwLen);
5029 ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
5030 ok (!bstr->szString[2], "String not terminated\n");
5031 SysFreeString(str);
5032 }
5033
5034 str = SysAllocStringByteLen((LPCSTR)szTest, 8);
5035 ok (str != NULL, "Expected non-NULL\n");
5036 if (str)
5037 {
5038 LPINTERNAL_BSTR bstr = Get(str);
5039
5040 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5041 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5042 SysFreeString(str);
5043 }
5044
5045 /* Make sure terminating null is aligned properly */
5046 buf = HeapAlloc(GetProcessHeap(), 0, 1025);
5047 ok (buf != NULL, "Expected non-NULL\n");
5048 for (i = 0; i < 1024; i++)
5049 {
5050 LPINTERNAL_BSTR bstr;
5051
5052 str = SysAllocStringByteLen(NULL, i);
5053 ok (str != NULL, "Expected non-NULL\n");
5054 bstr = Get(str);
5055 ok (bstr->dwLen == i, "Expected %d, got %d\n", i, bstr->dwLen);
5056 ok (!bstr->szString[(i+sizeof(WCHAR)-1)/sizeof(WCHAR)], "String not terminated\n");
5057 SysFreeString(str);
5058
5059 memset(buf, 0xaa, 1025);
5060 str = SysAllocStringByteLen(buf, i);
5061 ok (str != NULL, "Expected non-NULL\n");
5062 bstr = Get(str);
5063 ok (bstr->dwLen == i, "Expected %d, got %d\n", i, bstr->dwLen);
5064 buf[i] = 0;
5065 ok (!lstrcmpA((LPCSTR)bstr->szString, buf), "String different\n");
5066 ok (!bstr->szString[(i+sizeof(WCHAR)-1)/sizeof(WCHAR)], "String not terminated\n");
5067 SysFreeString(str);
5068 }
5069 HeapFree(GetProcessHeap(), 0, buf);
5070 }
5071
5072 static void test_SysReAllocString(void)
5073 {
5074 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5075 const OLECHAR szSmaller[2] = { 'x','\0' };
5076 const OLECHAR szLarger[7] = { 'L','a','r','g','e','r','\0' };
5077 BSTR str;
5078
5079 str = SysAllocStringLen(szTest, 4);
5080 ok (str != NULL, "Expected non-NULL\n");
5081 if (str)
5082 {
5083 LPINTERNAL_BSTR bstr;
5084 int changed;
5085
5086 bstr = Get(str);
5087 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5088 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5089
5090 changed = SysReAllocString(&str, szSmaller);
5091 ok (changed == 1, "Expected 1, got %d\n", changed);
5092 /* Vista creates a new string, but older versions reuse the existing string. */
5093 /*ok (str == oldstr, "Created new string\n");*/
5094 bstr = Get(str);
5095 ok (bstr->dwLen == 2, "Expected 2, got %d\n", bstr->dwLen);
5096 ok (!lstrcmpW(bstr->szString, szSmaller), "String different\n");
5097
5098 changed = SysReAllocString(&str, szLarger);
5099 ok (changed == 1, "Expected 1, got %d\n", changed);
5100 /* Early versions always make new strings rather than resizing */
5101 /* ok (str == oldstr, "Created new string\n"); */
5102 bstr = Get(str);
5103 ok (bstr->dwLen == 12, "Expected 12, got %d\n", bstr->dwLen);
5104 ok (!lstrcmpW(bstr->szString, szLarger), "String different\n");
5105
5106 SysFreeString(str);
5107 }
5108 }
5109
5110 static void test_SysReAllocStringLen(void)
5111 {
5112 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5113 const OLECHAR szSmaller[2] = { 'x','\0' };
5114 const OLECHAR szLarger[7] = { 'L','a','r','g','e','r','\0' };
5115 BSTR str;
5116
5117 str = SysAllocStringLen(szTest, 4);
5118 ok (str != NULL, "Expected non-NULL\n");
5119 if (str)
5120 {
5121 LPINTERNAL_BSTR bstr;
5122 int changed;
5123
5124 bstr = Get(str);
5125 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5126 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5127
5128 changed = SysReAllocStringLen(&str, szSmaller, 1);
5129 ok (changed == 1, "Expected 1, got %d\n", changed);
5130 /* Vista creates a new string, but older versions reuse the existing string. */
5131 /*ok (str == oldstr, "Created new string\n");*/
5132 bstr = Get(str);
5133 ok (bstr->dwLen == 2, "Expected 2, got %d\n", bstr->dwLen);
5134 ok (!lstrcmpW(bstr->szString, szSmaller), "String different\n");
5135
5136 changed = SysReAllocStringLen(&str, szLarger, 6);
5137 ok (changed == 1, "Expected 1, got %d\n", changed);
5138 /* Early versions always make new strings rather than resizing */
5139 /* ok (str == oldstr, "Created new string\n"); */
5140 bstr = Get(str);
5141 ok (bstr->dwLen == 12, "Expected 12, got %d\n", bstr->dwLen);
5142 ok (!lstrcmpW(bstr->szString, szLarger), "String different\n");
5143
5144 changed = SysReAllocStringLen(&str, str, 6);
5145 ok (changed == 1, "Expected 1, got %d\n", changed);
5146
5147 SysFreeString(str);
5148 }
5149
5150 /* Windows always returns null terminated strings */
5151 str = SysAllocStringLen(szTest, 4);
5152 ok (str != NULL, "Expected non-NULL\n");
5153 if (str)
5154 {
5155 const int CHUNK_SIZE = 64;
5156 const int STRING_SIZE = 24;
5157 int changed;
5158 changed = SysReAllocStringLen(&str, NULL, CHUNK_SIZE);
5159 ok (changed == 1, "Expected 1, got %d\n", changed);
5160 ok (str != NULL, "Expected non-NULL\n");
5161 if (str)
5162 {
5163 BSTR oldstr = str;
5164
5165 /* Filling string */
5166 memset (str, 0xAB, CHUNK_SIZE * sizeof (OLECHAR));
5167 /* Checking null terminator */
5168 changed = SysReAllocStringLen(&str, NULL, STRING_SIZE);
5169 ok (changed == 1, "Expected 1, got %d\n", changed);
5170 ok (str != NULL, "Expected non-NULL\n");
5171 if (str)
5172 {
5173 ok (str == oldstr, "Expected reuse of the old string memory\n");
5174 ok (str[STRING_SIZE] == 0,
5175 "Expected null terminator, got 0x%04X\n", str[STRING_SIZE]);
5176 SysFreeString(str);
5177 }
5178 }
5179 }
5180
5181 /* Some Windows applications use the same pointer for pbstr and psz */
5182 str = SysAllocStringLen(szTest, 4);
5183 ok(str != NULL, "Expected non-NULL\n");
5184 if(str)
5185 {
5186 SysReAllocStringLen(&str, str, 1000000);
5187 ok(SysStringLen(str)==1000000, "Incorrect string length\n");
5188 ok(!memcmp(szTest, str, 4*sizeof(WCHAR)), "Incorrect string returned\n");
5189
5190 SysFreeString(str);
5191 }
5192 }
5193
5194 static void test_BstrCopy(void)
5195 {
5196 const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
5197 const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
5198 LPINTERNAL_BSTR bstr;
5199 BSTR str;
5200 HRESULT hres;
5201 VARIANT vt1, vt2;
5202
5203 str = SysAllocStringByteLen(szTestA, 3);
5204 ok (str != NULL, "Expected non-NULL\n");
5205 if (str)
5206 {
5207 V_VT(&vt1) = VT_BSTR;
5208 V_BSTR(&vt1) = str;
5209 V_VT(&vt2) = VT_EMPTY;
5210 hres = VariantCopy(&vt2, &vt1);
5211 ok (hres == S_OK,"Failed to copy binary bstring with hres 0x%08x\n", hres);
5212 bstr = Get(V_BSTR(&vt2));
5213 ok (bstr->dwLen == 3, "Expected 3, got %d\n", bstr->dwLen);
5214 ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
5215 VariantClear(&vt2);
5216 VariantClear(&vt1);
5217 }
5218 }
5219
5220 static void test_VarBstrCat(void)
5221 {
5222 static const WCHAR sz1[] = { 'a',0 };
5223 static const WCHAR sz2[] = { 'b',0 };
5224 static const WCHAR sz1sz2[] = { 'a','b',0 };
5225 static const WCHAR s1[] = { 'a',0 };
5226 static const WCHAR s2[] = { 'b',0 };
5227 static const WCHAR s1s2[] = { 'a',0,'b',0 };
5228 static const char str1A[] = "Have ";
5229 static const char str2A[] = "A Cigar";
5230 HRESULT ret;
5231 BSTR str1, str2, res;
5232 UINT len;
5233
5234 if (0)
5235 {
5236 /* Crash */
5237 VarBstrCat(NULL, NULL, NULL);
5238 }
5239
5240 /* Concatenation of two NULL strings works */
5241 ret = VarBstrCat(NULL, NULL, &res);
5242 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5243 ok(res != NULL, "Expected a string\n");
5244 ok(SysStringLen(res) == 0, "Expected a 0-length string\n");
5245 SysFreeString(res);
5246
5247 str1 = SysAllocString(sz1);
5248
5249 /* Concatenation with one NULL arg */
5250 ret = VarBstrCat(NULL, str1, &res);
5251 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5252 ok(res != NULL, "Expected a string\n");
5253 ok(SysStringLen(res) == SysStringLen(str1), "Unexpected length\n");
5254 ok(!memcmp(res, sz1, SysStringLen(str1)), "Unexpected value\n");
5255 SysFreeString(res);
5256 ret = VarBstrCat(str1, NULL, &res);
5257 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5258 ok(res != NULL, "Expected a string\n");
5259 ok(SysStringLen(res) == SysStringLen(str1), "Unexpected length\n");
5260 ok(!memcmp(res, sz1, SysStringLen(str1)), "Unexpected value\n");
5261 SysFreeString(res);
5262
5263 /* Concatenation of two zero-terminated strings */
5264 str2 = SysAllocString(sz2);
5265 ret = VarBstrCat(str1, str2, &res);
5266 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5267 ok(res != NULL, "Expected a string\n");
5268 ok(SysStringLen(res) == ARRAY_SIZE(sz1sz2) - 1, "Unexpected length\n");
5269 ok(!memcmp(res, sz1sz2, sizeof(sz1sz2)), "Unexpected value\n");
5270 SysFreeString(res);
5271
5272 SysFreeString(str2);
5273 SysFreeString(str1);
5274
5275 /* Concatenation of two strings with embedded NULLs */
5276 str1 = SysAllocStringLen(s1, ARRAY_SIZE(s1));
5277 str2 = SysAllocStringLen(s2, ARRAY_SIZE(s2));
5278
5279 ret = VarBstrCat(str1, str2, &res);
5280 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5281 ok(res != NULL, "Expected a string\n");
5282 ok(SysStringLen(res) == ARRAY_SIZE(s1s2), "Unexpected length\n");
5283 ok(!memcmp(res, s1s2, sizeof(s1s2)), "Unexpected value\n");
5284 SysFreeString(res);
5285
5286 SysFreeString(str2);
5287 SysFreeString(str1);
5288
5289 /* Concatenation of ansi BSTRs, both odd byte count not including termination */
5290 str1 = SysAllocStringByteLen(str1A, sizeof(str1A)-1);
5291 str2 = SysAllocStringByteLen(str2A, sizeof(str2A)-1);
5292 len = SysStringLen(str1);
5293 ok(len == (sizeof(str1A)-1)/sizeof(WCHAR), "got length %u\n", len);
5294 len = SysStringLen(str2);
5295 ok(len == (sizeof(str2A)-1)/sizeof(WCHAR), "got length %u\n", len);
5296
5297 ret = VarBstrCat(str1, str2, &res);
5298 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5299 ok(res != NULL, "Expected a string\n");
5300 len = (sizeof(str1A) + sizeof(str2A) - 2)/sizeof(WCHAR);
5301 ok(SysStringLen(res) == len, "got %d, expected %u\n", SysStringLen(res), len);
5302 ok(!memcmp(res, "Have A Cigar", sizeof(str1A) + sizeof(str2A) - 1), "got (%s)\n", (char*)res);
5303 SysFreeString(res);
5304
5305 SysFreeString(str2);
5306 SysFreeString(str1);
5307
5308 /* Concatenation of ansi BSTRs, both 1 byte length not including termination */
5309 str1 = SysAllocStringByteLen(str1A, 1);
5310 str2 = SysAllocStringByteLen(str2A, 1);
5311 len = SysStringLen(str1);
5312 ok(len == 0, "got length %u\n", len);
5313 len = SysStringLen(str2);
5314 ok(len == 0, "got length %u\n", len);
5315
5316 ret = VarBstrCat(str1, str2, &res);
5317 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5318 ok(res != NULL, "Expected a string\n");
5319 ok(SysStringLen(res) == 1, "got %d, expected 1\n", SysStringLen(res));
5320 ok(!memcmp(res, "HA", 2), "got (%s)\n", (char*)res);
5321 SysFreeString(res);
5322
5323 SysFreeString(str2);
5324 SysFreeString(str1);
5325 }
5326
5327 /* IUnknown */
5328
5329 static void test_IUnknownClear(void)
5330 {
5331 HRESULT hres;
5332 VARIANTARG v;
5333 DummyDispatch u;
5334 IUnknown* pu;
5335
5336 init_test_dispatch(1, VT_UI1, &u);
5337 pu = (IUnknown*)&u.IDispatch_iface;
5338
5339 /* Test that IUnknown_Release is called on by-value */
5340 V_VT(&v) = VT_UNKNOWN;
5341 V_UNKNOWN(&v) = (IUnknown*)&u.IDispatch_iface;
5342 hres = VariantClear(&v);
5343 ok(hres == S_OK && u.ref == 0 && V_VT(&v) == VT_EMPTY,
5344 "clear unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5345 S_OK, 0, VT_EMPTY, hres, u.ref, V_VT(&v));
5346
5347 /* But not when clearing a by-reference*/
5348 u.ref = 1;
5349 V_VT(&v) = VT_UNKNOWN|VT_BYREF;
5350 V_UNKNOWNREF(&v) = &pu;
5351 hres = VariantClear(&v);
5352 ok(hres == S_OK && u.ref == 1 && V_VT(&v) == VT_EMPTY,
5353 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5354 S_OK, 1, VT_EMPTY, hres, u.ref, V_VT(&v));
5355 }
5356
5357 static void test_IUnknownCopy(void)
5358 {
5359 HRESULT hres;
5360 VARIANTARG vSrc, vDst;
5361 DummyDispatch u;
5362 IUnknown* pu;
5363
5364 init_test_dispatch(1, VT_UI1, &u);
5365 pu = (IUnknown*)&u.IDispatch_iface;
5366
5367 /* AddRef is called on by-value copy */
5368 VariantInit(&vDst);
5369 V_VT(&vSrc) = VT_UNKNOWN;
5370 V_UNKNOWN(&vSrc) = pu;
5371 hres = VariantCopy(&vDst, &vSrc);
5372 ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
5373 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5374 S_OK, 2, VT_EMPTY, hres, u.ref, V_VT(&vDst));
5375
5376 /* AddRef is skipped on copy of by-reference IDispatch */
5377 VariantInit(&vDst);
5378 u.ref = 1;
5379 V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5380 V_UNKNOWNREF(&vSrc) = &pu;
5381 hres = VariantCopy(&vDst, &vSrc);
5382 ok(hres == S_OK && u.ref == 1 && V_VT(&vDst) == (VT_UNKNOWN|VT_BYREF),
5383 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5384 S_OK, 1, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
5385
5386 /* AddRef is called copying by-reference IDispatch with indirection */
5387 VariantInit(&vDst);
5388 u.ref = 1;
5389 V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5390 V_UNKNOWNREF(&vSrc) = &pu;
5391 hres = VariantCopyInd(&vDst, &vSrc);
5392 ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
5393 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5394 S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
5395
5396 /* Indirection in place also calls AddRef */
5397 u.ref = 1;
5398 V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5399 V_UNKNOWNREF(&vSrc) = &pu;
5400 hres = VariantCopyInd(&vSrc, &vSrc);
5401 ok(hres == S_OK && u.ref == 2 && V_VT(&vSrc) == VT_UNKNOWN,
5402 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5403 S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vSrc));
5404 }
5405
5406 static void test_IUnknownChangeTypeEx(void)
5407 {
5408 HRESULT hres;
5409 VARIANTARG vSrc, vDst;
5410 LCID lcid;
5411 VARTYPE vt;
5412 DummyDispatch u;
5413 IUnknown* pu;
5414
5415 init_test_dispatch(1, VT_UI1, &u);
5416 pu = (IUnknown*)&u.IDispatch_iface;
5417
5418 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5419
5420 /* NULL IUnknown -> IDispatch */
5421 V_VT(&vSrc) = VT_UNKNOWN;
5422 V_UNKNOWN(&vSrc) = NULL;
5423 VariantInit(&vDst);
5424 V_DISPATCH(&vDst) = (void*)0xdeadbeef;
5425 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_DISPATCH);
5426 ok(hres == S_OK && V_VT(&vDst) == VT_DISPATCH && V_DISPATCH(&vDst) == NULL,
5427 "change unk(src,dst): expected 0x%08x,%d,%p, got 0x%08x,%d,%p\n",
5428 S_OK, VT_DISPATCH, NULL, hres, V_VT(&vDst), V_DISPATCH(&vDst));
5429
5430 V_VT(&vSrc) = VT_UNKNOWN;
5431 V_UNKNOWN(&vSrc) = pu;
5432
5433 /* =>IDispatch in place */
5434 hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_DISPATCH);
5435 ok(hres == S_OK && u.ref == 1 &&
5436 V_VT(&vSrc) == VT_DISPATCH && V_DISPATCH(&vSrc) == (IDispatch*)pu,
5437 "change unk(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5438 S_OK, 1, VT_DISPATCH, pu, hres, u.ref, V_VT(&vSrc), V_DISPATCH(&vSrc));
5439
5440 /* =>IDispatch */
5441 u.ref = 1;
5442 V_VT(&vSrc) = VT_UNKNOWN;
5443 V_UNKNOWN(&vSrc) = pu;
5444 VariantInit(&vDst);
5445 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5446 /* Note vSrc is not cleared, as final refcount is 2 */
5447 ok(hres == S_OK && u.ref == 2 &&
5448 V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == pu,
5449 "change unk(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5450 S_OK, 2, VT_UNKNOWN, pu, hres, u.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
5451
5452 /* Can't change unknown to anything else */
5453 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5454 {
5455 HRESULT hExpected = DISP_E_BADVARTYPE;
5456
5457 V_VT(&vSrc) = VT_UNKNOWN;
5458 V_UNKNOWN(&vSrc) = pu;
5459 VariantInit(&vDst);
5460
5461 if (vt == VT_UNKNOWN || vt == VT_DISPATCH || vt == VT_EMPTY || vt == VT_NULL)
5462 hExpected = S_OK;
5463 else
5464 {
5465 if (vt == VT_I8 || vt == VT_UI8)
5466 {
5467 if (has_i8)
5468 hExpected = DISP_E_TYPEMISMATCH;
5469 }
5470 else if (vt == VT_RECORD)
5471 {
5472 hExpected = DISP_E_TYPEMISMATCH;
5473 }
5474 else if (vt >= VT_I2 && vt <= VT_UINT && vt != (VARTYPE)15)
5475 hExpected = DISP_E_TYPEMISMATCH;
5476 }
5477
5478 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5479 ok(hres == hExpected,
5480 "change unk(badvar): vt %d expected 0x%08x, got 0x%08x\n",
5481 vt, hExpected, hres);
5482 }
5483 }
5484
5485 /* IDispatch */
5486 static void test_IDispatchClear(void)
5487 {
5488 HRESULT hres;
5489 VARIANTARG v;
5490 DummyDispatch d;
5491 IDispatch* pd;
5492
5493 init_test_dispatch(1, VT_UI1, &d);
5494 pd = &d.IDispatch_iface;
5495
5496 /* As per IUnknown */
5497
5498 V_VT(&v) = VT_DISPATCH;
5499 V_DISPATCH(&v) = pd;
5500 hres = VariantClear(&v);
5501 ok(hres == S_OK && d.ref == 0 && V_VT(&v) == VT_EMPTY,
5502 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5503 S_OK, 0, VT_EMPTY, hres, d.ref, V_VT(&v));
5504
5505 d.ref = 1;
5506 V_VT(&v) = VT_DISPATCH|VT_BYREF;
5507 V_DISPATCHREF(&v) = &pd;
5508 hres = VariantClear(&v);
5509 ok(hres == S_OK && d.ref == 1 && V_VT(&v) == VT_EMPTY,
5510 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5511 S_OK, 1, VT_EMPTY, hres, d.ref, V_VT(&v));
5512 }
5513
5514 static void test_IDispatchCopy(void)
5515 {
5516 HRESULT hres;
5517 VARIANTARG vSrc, vDst;
5518 DummyDispatch d;
5519 IDispatch* pd;
5520
5521 init_test_dispatch(1, VT_UI1, &d);
5522 pd = &d.IDispatch_iface;
5523
5524 /* As per IUnknown */
5525
5526 VariantInit(&vDst);
5527 V_VT(&vSrc) = VT_DISPATCH;
5528 V_DISPATCH(&vSrc) = pd;
5529 hres = VariantCopy(&vDst, &vSrc);
5530 ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
5531 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5532 S_OK, 2, VT_EMPTY, hres, d.ref, V_VT(&vDst));
5533
5534 VariantInit(&vDst);
5535 d.ref = 1;
5536 V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5537 V_DISPATCHREF(&vSrc) = &pd;
5538 hres = VariantCopy(&vDst, &vSrc);
5539 ok(hres == S_OK && d.ref == 1 && V_VT(&vDst) == (VT_DISPATCH|VT_BYREF),
5540 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5541 S_OK, 1, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
5542
5543 VariantInit(&vDst);
5544 d.ref = 1;
5545 V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5546 V_DISPATCHREF(&vSrc) = &pd;
5547 hres = VariantCopyInd(&vDst, &vSrc);
5548 ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
5549 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5550 S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
5551
5552 d.ref = 1;
5553 V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5554 V_DISPATCHREF(&vSrc) = &pd;
5555 hres = VariantCopyInd(&vSrc, &vSrc);
5556 ok(hres == S_OK && d.ref == 2 && V_VT(&vSrc) == VT_DISPATCH,
5557 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5558 S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vSrc));
5559 }
5560
5561 static void test_IDispatchChangeTypeEx(void)
5562 {
5563 HRESULT hres;
5564 VARIANTARG vSrc, vDst;
5565 LCID lcid;
5566 DummyDispatch d;
5567 IDispatch* pd;
5568
5569 init_test_dispatch(1, VT_UI1, &d);
5570 pd = &d.IDispatch_iface;
5571
5572 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5573
5574 /* NULL IDispatch -> IUnknown */
5575 V_VT(&vSrc) = VT_DISPATCH;
5576 V_DISPATCH(&vSrc) = NULL;
5577 VariantInit(&vDst);
5578 V_UNKNOWN(&vDst) = (void*)0xdeadbeef;
5579 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5580 ok(hres == S_OK && V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == NULL,
5581 "change unk(src,dst): expected 0x%08x,%d,%p, got 0x%08x,%d,%p\n",
5582 S_OK, VT_UNKNOWN, NULL, hres, V_VT(&vDst), V_UNKNOWN(&vDst));
5583
5584 V_VT(&vSrc) = VT_DISPATCH;
5585 V_DISPATCH(&vSrc) = pd;
5586
5587 /* =>IUnknown in place */
5588 hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_UNKNOWN);
5589 ok(hres == S_OK && d.ref == 1 &&
5590 V_VT(&vSrc) == VT_UNKNOWN && V_UNKNOWN(&vSrc) == (IUnknown*)pd,
5591 "change disp(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5592 S_OK, 1, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vSrc), V_UNKNOWN(&vSrc));
5593
5594 /* =>IUnknown */
5595 d.ref = 1;
5596 V_VT(&vSrc) = VT_DISPATCH;
5597 V_DISPATCH(&vSrc) = pd;
5598 VariantInit(&vDst);
5599 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5600 /* Note vSrc is not cleared, as final refcount is 2 */
5601 ok(hres == S_OK && d.ref == 2 &&
5602 V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == (IUnknown*)pd,
5603 "change disp(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5604 S_OK, 2, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
5605
5606 /* FIXME: Verify that VARIANT_NOVALUEPROP prevents conversion to integral
5607 * types. this requires that the xxxFromDisp tests work first.
5608 */
5609 }
5610
5611 /* VT_ERROR */
5612 static void test_ErrorChangeTypeEx(void)
5613 {
5614 HRESULT hres;
5615 VARIANTARG vSrc, vDst;
5616 VARTYPE vt;
5617 LCID lcid;
5618
5619 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5620
5621 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5622 {
5623 HRESULT hExpected = DISP_E_BADVARTYPE;
5624
5625 V_VT(&vSrc) = VT_ERROR;
5626 V_ERROR(&vSrc) = 1;
5627 VariantInit(&vDst);
5628 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5629
5630 if (vt == VT_ERROR)
5631 hExpected = S_OK;
5632 else
5633 {
5634 if (vt == VT_I8 || vt == VT_UI8)
5635 {
5636 if (has_i8)
5637 hExpected = DISP_E_TYPEMISMATCH;
5638 }
5639 else if (vt == VT_RECORD)
5640 {
5641 hExpected = DISP_E_TYPEMISMATCH;
5642 }
5643 else if (vt <= VT_UINT && vt != (VARTYPE)15)
5644 hExpected = DISP_E_TYPEMISMATCH;
5645 }
5646
5647 ok(hres == hExpected,
5648 "change err: vt %d expected 0x%08x, got 0x%08x\n", vt, hExpected, hres);
5649 }
5650 }
5651
5652 /* VT_EMPTY */
5653 static void test_EmptyChangeTypeEx(void)
5654 {
5655 VARTYPE vt;
5656 LCID lcid;
5657
5658 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5659
5660 for (vt = VT_EMPTY; vt <= VT_BSTR_BLOB; vt++)
5661 {
5662 HRESULT hExpected, hres;
5663 VARIANTARG vSrc, vDst;
5664
5665 /* skip for undefined types */
5666 if ((vt == 15) || (vt > VT_VERSIONED_STREAM && vt < VT_BSTR_BLOB))
5667 continue;
5668
5669 switch (vt)
5670 {
5671 case VT_I8:
5672 case VT_UI8:
5673 if (has_i8)
5674 hExpected = S_OK;
5675 else
5676 hExpected = DISP_E_BADVARTYPE;
5677 break;
5678 case VT_RECORD:
5679 case VT_VARIANT:
5680 case VT_DISPATCH:
5681 case VT_UNKNOWN:
5682 case VT_ERROR:
5683 hExpected = DISP_E_TYPEMISMATCH;
5684 break;
5685 case VT_EMPTY:
5686 case VT_NULL:
5687 case VT_I2:
5688 case VT_I4:
5689 case VT_R4:
5690 case VT_R8:
5691 case VT_CY:
5692 case VT_DATE:
5693 case VT_BSTR:
5694 case VT_BOOL:
5695 case VT_DECIMAL:
5696 case VT_I1:
5697 case VT_UI1:
5698 case VT_UI2:
5699 case VT_UI4:
5700 case VT_INT:
5701 case VT_UINT:
5702 hExpected = S_OK;
5703 break;
5704 default:
5705 hExpected = DISP_E_BADVARTYPE;
5706 }
5707
5708 VariantInit(&vSrc);
5709 V_VT(&vSrc) = VT_EMPTY;
5710 memset(&vDst, 0, sizeof(vDst));
5711 V_VT(&vDst) = VT_NULL;
5712
5713 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5714 ok(hres == hExpected, "change empty: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
5715 vt, hExpected, hres, V_VT(&vDst));
5716 if (hres == S_OK)
5717 {
5718 ok(V_VT(&vDst) == vt, "change empty: vt %d, got %d\n", vt, V_VT(&vDst));
5719 VariantClear(&vDst);
5720 }
5721 }
5722 }
5723
5724 /* VT_NULL */
5725 static void test_NullChangeTypeEx(void)
5726 {
5727 VARTYPE vt;
5728 LCID lcid;
5729
5730 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5731
5732 for (vt = VT_EMPTY; vt <= VT_BSTR_BLOB; vt++)
5733 {
5734 VARIANTARG vSrc, vDst;
5735 HRESULT hExpected, hres;
5736
5737 /* skip for undefined types */
5738 if ((vt == 15) || (vt > VT_VERSIONED_STREAM && vt < VT_BSTR_BLOB))
5739 continue;
5740
5741 switch (vt)
5742 {
5743 case VT_I8:
5744 case VT_UI8:
5745 if (has_i8)
5746 hExpected = DISP_E_TYPEMISMATCH;
5747 else
5748 hExpected = DISP_E_BADVARTYPE;
5749 break;
5750 case VT_NULL:
5751 hExpected = S_OK;
5752 break;
5753 case VT_EMPTY:
5754 case VT_I2:
5755 case VT_I4:
5756 case VT_R4:
5757 case VT_R8:
5758 case VT_CY:
5759 case VT_DATE:
5760 case VT_BSTR:
5761 case VT_DISPATCH:
5762 case VT_ERROR:
5763 case VT_BOOL:
5764 case VT_VARIANT:
5765 case VT_UNKNOWN:
5766 case VT_DECIMAL:
5767 case VT_I1:
5768 case VT_UI1:
5769 case VT_UI2:
5770 case VT_UI4:
5771 case VT_INT:
5772 case VT_UINT:
5773 case VT_RECORD:
5774 hExpected = DISP_E_TYPEMISMATCH;
5775 break;
5776 default:
5777 hExpected = DISP_E_BADVARTYPE;
5778 }
5779
5780 VariantInit(&vSrc);
5781 V_VT(&vSrc) = VT_NULL;
5782 memset(&vDst, 0, sizeof(vDst));
5783 V_VT(&vDst) = VT_EMPTY;
5784
5785 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5786 ok(hres == hExpected, "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
5787 vt, hExpected, hres, V_VT(&vDst));
5788
5789 /* should work only for VT_NULL -> VT_NULL case */
5790 if (hres == S_OK)
5791 ok(V_VT(&vDst) == VT_NULL, "change null: VT_NULL expected 0x%08x, got 0x%08x, vt %d\n",
5792 hExpected, hres, V_VT(&vDst));
5793 else
5794 ok(V_VT(&vDst) == VT_EMPTY, "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
5795 vt, hExpected, hres, V_VT(&vDst));
5796 }
5797 }
5798
5799
5800 /* VT_UINT */
5801 static void test_UintChangeTypeEx(void)
5802 {
5803 HRESULT hres;
5804 VARIANTARG vSrc, vDst;
5805 LCID lcid;
5806
5807 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5808
5809 /* Converting a VT_UINT to a VT_INT does not check for overflow */
5810 V_VT(&vDst) = VT_EMPTY;
5811 V_VT(&vSrc) = VT_UINT;
5812 V_UI4(&vSrc) = -1;
5813 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_I4);
5814 ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == -1,
5815 "change uint: Expected %d,0x%08x,%d got %d,0x%08x,%d\n",
5816 VT_I4, S_OK, -1, V_VT(&vDst), hres, V_I4(&vDst));
5817 }
5818
5819 #define NUM_CUST_ITEMS 16
5820
5821 static void test_ClearCustData(void)
5822 {
5823 CUSTDATA ci;
5824 unsigned i;
5825
5826 ci.cCustData = NUM_CUST_ITEMS;
5827 ci.prgCustData = CoTaskMemAlloc( sizeof(CUSTDATAITEM) * NUM_CUST_ITEMS );
5828 for (i = 0; i < NUM_CUST_ITEMS; i++)
5829 VariantInit(&ci.prgCustData[i].varValue);
5830 ClearCustData(&ci);
5831 ok(!ci.cCustData && !ci.prgCustData, "ClearCustData didn't clear fields!\n");
5832 }
5833
5834 static void test_NullByRef(void)
5835 {
5836 VARIANT v1, v2;
5837 HRESULT hRes;
5838
5839 VariantInit(&v1);
5840 VariantInit(&v2);
5841 V_VT(&v1) = VT_BYREF|VT_VARIANT;
5842 V_BYREF(&v1) = 0;
5843
5844 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_I4);
5845 ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5846
5847 VariantClear(&v1);
5848 V_VT(&v1) = VT_BYREF|VT_VARIANT;
5849 V_BYREF(&v1) = 0;
5850 V_VT(&v2) = VT_I4;
5851 V_I4(&v2) = 123;
5852
5853 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_VARIANT);
5854 ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5855 ok(V_VT(&v2) == VT_I4 && V_I4(&v2) == 123, "VariantChangeTypeEx shouldn't change pvargDest\n");
5856
5857 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_BYREF|VT_I4);
5858 ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5859
5860 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, 0x3847);
5861 ok(hRes == DISP_E_BADVARTYPE, "VariantChangeTypeEx should return DISP_E_BADVARTYPE\n");
5862 }
5863
5864 /* Dst Variant should remain unchanged if VariantChangeType cannot convert */
5865 static void test_ChangeType_keep_dst(void)
5866 {
5867 VARIANT v1, v2;
5868 BSTR bstr;
5869 static const WCHAR testW[] = {'t','e','s','t',0};
5870 HRESULT hres;
5871
5872 bstr = SysAllocString(testW);
5873 VariantInit(&v1);
5874 VariantInit(&v2);
5875 V_VT(&v1) = VT_BSTR;
5876 V_BSTR(&v1) = bstr;
5877 hres = VariantChangeTypeEx(&v1, &v1, 0, 0, VT_INT);
5878 ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
5879 ok(V_VT(&v1) == VT_BSTR && V_BSTR(&v1) == bstr, "VariantChangeTypeEx changed dst variant\n");
5880 V_VT(&v2) = VT_INT;
5881 V_INT(&v2) = 4;
5882 hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_INT);
5883 ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
5884 ok(V_VT(&v2) == VT_INT && V_INT(&v2) == 4, "VariantChangeTypeEx changed dst variant\n");
5885 V_VT(&v2) = 0xff; /* incorrect variant type */
5886 hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_INT);
5887 ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
5888 ok(V_VT(&v2) == 0xff, "VariantChangeTypeEx changed dst variant\n");
5889 hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_BSTR);
5890 ok(hres == DISP_E_BADVARTYPE, "VariantChangeTypeEx returns %08x\n", hres);
5891 ok(V_VT(&v2) == 0xff, "VariantChangeTypeEx changed dst variant\n");
5892 SysFreeString(bstr);
5893 }
5894
5895 /* This tests assumes an empty cache, so it needs to be ran early in the test. */
5896 static void test_bstr_cache(void)
5897 {
5898 BSTR str, str2, strs[20];
5899 unsigned i;
5900
5901 static const WCHAR testW[] = {'t','e','s','t',0};
5902
5903 if (GetEnvironmentVariableA("OANOCACHE", NULL, 0)) {
5904 skip("BSTR cache is disabled, some tests will be skipped.\n");
5905 return;
5906 }
5907
5908 str = SysAllocString(testW);
5909 /* This should put the string into cache */
5910 SysFreeString(str);
5911 /* The string is in cache, this won't touch it */
5912 SysFreeString(str);
5913
5914 ok(SysStringLen(str) == 4, "unexpected len\n");
5915 ok(!lstrcmpW(str, testW), "string changed\n");
5916
5917 str2 = SysAllocString(testW);
5918 ok(str == str2, "str != str2\n");
5919 SysFreeString(str2);
5920
5921 /* Fill the bucket with cached entries.
5922 We roll our own, to show that the cache doesn't use
5923 the bstr length field to determine bucket allocation. */
5924 for(i=0; i < ARRAY_SIZE(strs); i++)
5925 {
5926 DWORD_PTR *ptr = CoTaskMemAlloc(64);
5927 ptr[0] = 0;
5928 strs[i] = (BSTR)(ptr + 1);
5929 }
5930 for(i=0; i < ARRAY_SIZE(strs); i++)
5931 SysFreeString(strs[i]);
5932
5933 /* Following allocation will be made from cache */
5934 str = SysAllocStringLen(NULL, 24);
5935 ok(str == strs[0], "str != strs[0]\n");
5936
5937 /* Smaller buffers may also use larger cached buffers */
5938 str2 = SysAllocStringLen(NULL, 16);
5939 ok(str2 == strs[1], "str2 != strs[1]\n");
5940
5941 SysFreeString(str);
5942 SysFreeString(str2);
5943 SysFreeString(str);
5944 SysFreeString(str2);
5945 }
5946
5947 static void write_typelib(int res_no, const char *filename)
5948 {
5949 DWORD written;
5950 HANDLE file;
5951 HRSRC res;
5952 void *ptr;
5953
5954 file = CreateFileA( filename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
5955 ok( file != INVALID_HANDLE_VALUE, "file creation failed\n" );
5956 if (file == INVALID_HANDLE_VALUE) return;
5957 res = FindResourceA( GetModuleHandleA(NULL), (LPCSTR)MAKEINTRESOURCE(res_no), "TYPELIB" );
5958 ok( res != 0, "couldn't find resource\n" );
5959 ptr = LockResource( LoadResource( GetModuleHandleA(NULL), res ));
5960 WriteFile( file, ptr, SizeofResource( GetModuleHandleA(NULL), res ), &written, NULL );
5961 ok( written == SizeofResource( GetModuleHandleA(NULL), res ), "couldn't write resource\n" );
5962 CloseHandle( file );
5963 }
5964
5965 static const char *create_test_typelib(int res_no)
5966 {
5967 static char filename[MAX_PATH];
5968
5969 GetTempFileNameA( ".", "tlb", 0, filename );
5970 write_typelib(res_no, filename);
5971 return filename;
5972 }
5973
5974 static void test_recinfo(void)
5975 {
5976 static const WCHAR testW[] = {'t','e','s','t',0};
5977 static WCHAR teststructW[] = {'t','e','s','t','_','s','t','r','u','c','t',0};
5978 static WCHAR teststruct2W[] = {'t','e','s','t','_','s','t','r','u','c','t','2',0};
5979 static WCHAR teststruct3W[] = {'t','e','s','t','_','s','t','r','u','c','t','3',0};
5980 WCHAR filenameW[MAX_PATH], filename2W[MAX_PATH];
5981 ITypeInfo *typeinfo, *typeinfo2, *typeinfo3;
5982 IRecordInfo *recinfo, *recinfo2, *recinfo3;
5983 struct test_struct teststruct, testcopy;
5984 ITypeLib *typelib, *typelib2;
5985 const char *filename;
5986 DummyDispatch dispatch;
5987 TYPEATTR *attr;
5988 MEMBERID memid;
5989 UINT16 found;
5990 HRESULT hr;
5991 ULONG size;
5992 BOOL ret;
5993
5994 filename = create_test_typelib(2);
5995 MultiByteToWideChar(CP_ACP, 0, filename, -1, filenameW, MAX_PATH);
5996 hr = LoadTypeLibEx(filenameW, REGKIND_NONE, &typelib);
5997 ok(hr == S_OK, "got 0x%08x\n", hr);
5998
5999 filename = create_test_typelib(3);
6000 MultiByteToWideChar(CP_ACP, 0, filename, -1, filename2W, MAX_PATH);
6001 hr = LoadTypeLibEx(filename2W, REGKIND_NONE, &typelib2);
6002 ok(hr == S_OK, "got 0x%08x\n", hr);
6003
6004 typeinfo = NULL;
6005 found = 1;
6006 hr = ITypeLib_FindName(typelib, teststructW, 0, &typeinfo, &memid, &found);
6007 ok(hr == S_OK, "got 0x%08x\n", hr);
6008 ok(typeinfo != NULL, "got %p\n", typeinfo);
6009 hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
6010 ok(hr == S_OK, "got 0x%08x\n", hr);
6011 ok(IsEqualGUID(&attr->guid, &UUID_test_struct), "got %s\n", wine_dbgstr_guid(&attr->guid));
6012 ok(attr->typekind == TKIND_RECORD, "got %d\n", attr->typekind);
6013
6014 typeinfo2 = NULL;
6015 found = 1;
6016 hr = ITypeLib_FindName(typelib, teststruct2W, 0, &typeinfo2, &memid, &found);
6017 ok(hr == S_OK, "got 0x%08x\n", hr);
6018 ok(typeinfo2 != NULL, "got %p\n", typeinfo2);
6019
6020 typeinfo3 = NULL;
6021 found = 1;
6022 hr = ITypeLib_FindName(typelib2, teststruct3W, 0, &typeinfo3, &memid, &found);
6023 ok(hr == S_OK, "got 0x%08x\n", hr);
6024 ok(typeinfo3 != NULL, "got %p\n", typeinfo3);
6025
6026 hr = GetRecordInfoFromTypeInfo(typeinfo, &recinfo);
6027 ok(hr == S_OK, "got 0x%08x\n", hr);
6028
6029 hr = GetRecordInfoFromTypeInfo(typeinfo2, &recinfo2);
6030 ok(hr == S_OK, "got 0x%08x\n", hr);
6031
6032 hr = GetRecordInfoFromTypeInfo(typeinfo3, &recinfo3);
6033 ok(hr == S_OK, "got 0x%08x\n", hr);
6034
6035 /* IsMatchingType, these two records only differ in GUIDs */
6036 ret = IRecordInfo_IsMatchingType(recinfo, recinfo2);
6037 ok(!ret, "got %d\n", ret);
6038
6039 /* these two have same GUIDs, but different set of fields */
6040 ret = IRecordInfo_IsMatchingType(recinfo2, recinfo3);
6041 ok(ret, "got %d\n", ret);
6042
6043 IRecordInfo_Release(recinfo3);
6044 ITypeInfo_Release(typeinfo3);
6045 IRecordInfo_Release(recinfo2);
6046 ITypeInfo_Release(typeinfo2);
6047
6048 size = 0;
6049 hr = IRecordInfo_GetSize(recinfo, &size);
6050 ok(hr == S_OK, "got 0x%08x\n", hr);
6051 ok(size == sizeof(struct test_struct), "got size %d\n", size);
6052 ok(attr->cbSizeInstance == sizeof(struct test_struct), "got instance size %d\n", attr->cbSizeInstance);
6053 ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
6054
6055 /* RecordInit() */
6056 teststruct.hr = E_FAIL;
6057 teststruct.b = 0x1;
6058 teststruct.disp = (void*)0xdeadbeef;
6059 teststruct.bstr = (void*)0xdeadbeef;
6060
6061 hr = IRecordInfo_RecordInit(recinfo, &teststruct);
6062 ok(hr == S_OK, "got 0x%08x\n", hr);
6063 ok(teststruct.hr == 0, "got 0x%08x\n", teststruct.hr);
6064 ok(teststruct.b == 0, "got 0x%08x\n", teststruct.b);
6065 ok(teststruct.disp == NULL, "got %p\n", teststruct.disp);
6066 ok(teststruct.bstr == NULL, "got %p\n", teststruct.bstr);
6067
6068 init_test_dispatch(10, VT_UI1, &dispatch);
6069
6070 /* RecordCopy(), interface field reference increased */
6071 teststruct.hr = S_FALSE;
6072 teststruct.b = VARIANT_TRUE;
6073 teststruct.disp = &dispatch.IDispatch_iface;
6074 teststruct.bstr = SysAllocString(testW);
6075 memset(&testcopy, 0, sizeof(testcopy));
6076 hr = IRecordInfo_RecordCopy(recinfo, &teststruct, &testcopy);
6077 ok(hr == S_OK, "got 0x%08x\n", hr);
6078 ok(testcopy.hr == S_FALSE, "got 0x%08x\n", testcopy.hr);
6079 ok(testcopy.b == VARIANT_TRUE, "got %d\n", testcopy.b);
6080 ok(testcopy.disp == teststruct.disp, "got %p\n", testcopy.disp);
6081 ok(dispatch.ref == 11, "got %d\n", dispatch.ref);
6082 ok(testcopy.bstr != teststruct.bstr, "got %p\n", testcopy.bstr);
6083 ok(!lstrcmpW(testcopy.bstr, teststruct.bstr), "got %s, %s\n", wine_dbgstr_w(testcopy.bstr), wine_dbgstr_w(teststruct.bstr));
6084
6085 /* RecordClear() */
6086 hr = IRecordInfo_RecordClear(recinfo, &teststruct);
6087 ok(hr == S_OK, "got 0x%08x\n", hr);
6088 ok(teststruct.bstr == NULL, "got %p\n", teststruct.bstr);
6089 hr = IRecordInfo_RecordClear(recinfo, &testcopy);
6090 ok(hr == S_OK, "got 0x%08x\n", hr);
6091 ok(testcopy.bstr == NULL, "got %p\n", testcopy.bstr);
6092
6093 /* now the destination contains the interface pointer */
6094 memset(&testcopy, 0, sizeof(testcopy));
6095 testcopy.disp = &dispatch.IDispatch_iface;
6096 dispatch.ref = 10;
6097
6098 hr = IRecordInfo_RecordCopy(recinfo, &teststruct, &testcopy);
6099 ok(hr == S_OK, "got 0x%08x\n", hr);
6100 ok(dispatch.ref == 9, "got %d\n", dispatch.ref);
6101
6102 IRecordInfo_Release(recinfo);
6103
6104 ITypeInfo_Release(typeinfo);
6105 ITypeLib_Release(typelib2);
6106 ITypeLib_Release(typelib);
6107 DeleteFileW(filenameW);
6108 DeleteFileW(filename2W);
6109 }
6110
6111 START_TEST(vartype)
6112 {
6113 hOleaut32 = GetModuleHandleA("oleaut32.dll");
6114
6115 has_i8 = GetProcAddress(hOleaut32, "VarI8FromI1") != NULL;
6116 has_locales = has_i8 && GetProcAddress(hOleaut32, "GetVarConversionLocaleSetting") != NULL;
6117
6118 trace("LCIDs: System=0x%08x, User=0x%08x\n", GetSystemDefaultLCID(),
6119 GetUserDefaultLCID());
6120
6121 test_bstr_cache();
6122
6123 test_VarI1FromI2();
6124 test_VarI1FromI4();
6125 test_VarI1FromI8();
6126 test_VarI1FromUI1();
6127 test_VarI1FromUI2();
6128 test_VarI1FromUI4();
6129 test_VarI1FromUI8();
6130 test_VarI1FromBool();
6131 test_VarI1FromR4();
6132 test_VarI1FromR8();
6133 test_VarI1FromDate();
6134 test_VarI1FromCy();
6135 test_VarI1FromDec();
6136 test_VarI1FromStr();
6137 test_VarUI1FromDisp();
6138 test_VarI1Copy();
6139 test_VarI1ChangeTypeEx();
6140
6141 test_VarUI1FromI1();
6142 test_VarUI1FromI2();
6143 test_VarUI1FromI4();
6144 test_VarUI1FromI8();
6145 test_VarUI1FromUI2();
6146 test_VarUI1FromUI4();
6147 test_VarUI1FromUI8();
6148 test_VarUI1FromBool();
6149 test_VarUI1FromR4();
6150 test_VarUI1FromR8();
6151 test_VarUI1FromDate();
6152 test_VarUI1FromCy();
6153 test_VarUI1FromDec();
6154 test_VarUI1FromStr();
6155 test_VarUI1Copy();
6156 test_VarUI1ChangeTypeEx();
6157
6158 test_VarI2FromI1();
6159 test_VarI2FromI4();
6160 test_VarI2FromI8();
6161 test_VarI2FromUI1();
6162 test_VarI2FromUI2();
6163 test_VarI2FromUI4();
6164 test_VarI2FromUI8();
6165 test_VarI2FromBool();
6166 test_VarI2FromR4();
6167 test_VarI2FromR8();
6168 test_VarI2FromDate();
6169 test_VarI2FromCy();
6170 test_VarI2FromDec();
6171 test_VarI2FromStr();
6172 test_VarI2Copy();
6173 test_VarI2ChangeTypeEx();
6174
6175 test_VarUI2FromI1();
6176 test_VarUI2FromI2();
6177 test_VarUI2FromI4();
6178 test_VarUI2FromI8();
6179 test_VarUI2FromUI1();
6180 test_VarUI2FromUI4();
6181 test_VarUI2FromUI8();
6182 test_VarUI2FromBool();
6183 test_VarUI2FromR4();
6184 test_VarUI2FromR8();
6185 test_VarUI2FromDate();
6186 test_VarUI2FromCy();
6187 test_VarUI2FromDec();
6188 test_VarUI2FromStr();
6189 test_VarUI2Copy();
6190 test_VarUI2ChangeTypeEx();
6191
6192 test_VarI4FromI1();
6193 test_VarI4FromI2();
6194 test_VarI4FromI8();
6195 test_VarI4FromUI1();
6196 test_VarI4FromUI2();
6197 test_VarI4FromUI4();
6198 test_VarI4FromUI8();
6199 test_VarI4FromBool();
6200 test_VarI4FromR4();
6201 test_VarI4FromR8();
6202 test_VarI4FromDate();
6203 test_VarI4FromCy();
6204 test_VarI4FromDec();
6205 test_VarI4FromStr();
6206 test_VarI4Copy();
6207 test_VarI4ChangeTypeEx();
6208
6209 test_VarUI4FromI1();
6210 test_VarUI4FromI2();
6211 test_VarUI4FromUI2();
6212 test_VarUI4FromI8();
6213 test_VarUI4FromUI1();
6214 test_VarUI4FromI4();
6215 test_VarUI4FromUI8();
6216 test_VarUI4FromBool();
6217 test_VarUI4FromR4();
6218 test_VarUI4FromR8();
6219 test_VarUI4FromDate();
6220 test_VarUI4FromCy();
6221 test_VarUI4FromDec();
6222 test_VarUI4FromStr();
6223 test_VarUI4Copy();
6224 test_VarUI4ChangeTypeEx();
6225
6226 test_VarI8FromI1();
6227 test_VarI8FromUI1();
6228 test_VarI8FromI2();
6229 test_VarI8FromUI2();
6230 test_VarI8FromUI4();
6231 test_VarI8FromR4();
6232 test_VarI8FromR8();
6233 test_VarI8FromBool();
6234 test_VarI8FromUI8();
6235 test_VarI8FromCy();
6236 test_VarI8FromDec();
6237 test_VarI8FromDate();
6238 test_VarI8FromStr();
6239 test_VarI8Copy();
6240 test_VarI8ChangeTypeEx();
6241
6242 test_VarUI8FromI1();
6243 test_VarUI8FromUI1();
6244 test_VarUI8FromI2();
6245 test_VarUI8FromUI2();
6246 test_VarUI8FromUI4();
6247 test_VarUI8FromR4();
6248 test_VarUI8FromR8();
6249 test_VarUI8FromBool();
6250 test_VarUI8FromI8();
6251 test_VarUI8FromCy();
6252 test_VarUI8FromDec();
6253 test_VarUI8FromDate();
6254 test_VarUI8FromStr();
6255 test_VarUI8Copy();
6256 test_VarUI8ChangeTypeEx();
6257
6258 test_VarR4FromI1();
6259 test_VarR4FromUI1();
6260 test_VarR4FromI2();
6261 test_VarR4FromUI2();
6262 test_VarR4FromI4();
6263 test_VarR4FromUI4();
6264 test_VarR4FromR8();
6265 test_VarR4FromBool();
6266 test_VarR4FromCy();
6267 test_VarR4FromI8();
6268 test_VarR4FromUI8();
6269 test_VarR4FromDec();
6270 test_VarR4FromDate();
6271 test_VarR4FromStr();
6272 test_VarR4Copy();
6273 test_VarR4ChangeTypeEx();
6274
6275 test_VarR8FromI1();
6276 test_VarR8FromUI1();
6277 test_VarR8FromI2();
6278 test_VarR8FromUI2();
6279 test_VarR8FromI4();
6280 test_VarR8FromUI4();
6281 test_VarR8FromR4();
6282 test_VarR8FromBool();
6283 test_VarR8FromCy();
6284 test_VarR8FromI8();
6285 test_VarR8FromUI8();
6286 test_VarR8FromDec();
6287 test_VarR8FromDate();
6288 test_VarR8FromStr();
6289 test_VarR8Copy();
6290 test_VarR8ChangeTypeEx();
6291 test_VarR8Round();
6292
6293 test_VarDateFromI1();
6294 test_VarDateFromUI1();
6295 test_VarDateFromI2();
6296 test_VarDateFromUI2();
6297 test_VarDateFromI4();
6298 test_VarDateFromUI4();
6299 test_VarDateFromR4();
6300 test_VarDateFromR8();
6301 test_VarDateFromBool();
6302 test_VarDateFromCy();
6303 test_VarDateFromI8();
6304 test_VarDateFromUI8();
6305 test_VarDateFromDec();
6306 test_VarDateFromStr();
6307 test_VarDateCopy();
6308 test_VarDateChangeTypeEx();
6309
6310 test_VarCyFromI1();
6311 test_VarCyFromUI1();
6312 test_VarCyFromI2();
6313 test_VarCyFromUI2();
6314 test_VarCyFromI4();
6315 test_VarCyFromUI4();
6316 test_VarCyFromR4();
6317 test_VarCyFromR8();
6318 test_VarCyFromBool();
6319 test_VarCyFromI8();
6320 test_VarCyFromUI8();
6321 test_VarCyFromDec();
6322 test_VarCyFromDate();
6323
6324 test_VarCyAdd();
6325 test_VarCyMul();
6326 test_VarCySub();
6327 test_VarCyAbs();
6328 test_VarCyNeg();
6329 test_VarCyMulI4();
6330 test_VarCyMulI8();
6331 test_VarCyCmp();
6332 test_VarCyCmpR8();
6333 test_VarCyRound();
6334 test_VarCyFix();
6335 test_VarCyInt();
6336
6337 test_VarDecFromI1();
6338 test_VarDecFromI2();
6339 test_VarDecFromI4();
6340 test_VarDecFromI8();
6341 test_VarDecFromUI1();
6342 test_VarDecFromUI2();
6343 test_VarDecFromUI4();
6344 test_VarDecFromUI8();
6345 test_VarDecFromR4();
6346 test_VarDecFromR8();
6347 test_VarDecFromDate();
6348 test_VarDecFromStr();
6349 test_VarDecFromCy();
6350 test_VarDecFromDate();
6351 test_VarDecFromBool();
6352
6353 test_VarDecAbs();
6354 test_VarDecNeg();
6355 test_VarDecAdd();
6356 test_VarDecSub();
6357 test_VarDecCmp();
6358 test_VarDecCmpR8();
6359 test_VarDecMul();
6360 test_VarDecDiv();
6361 test_VarDecRound();
6362
6363 test_VarBoolFromI1();
6364 test_VarBoolFromUI1();
6365 test_VarBoolFromI2();
6366 test_VarBoolFromUI2();
6367 test_VarBoolFromI4();
6368 test_VarBoolFromUI4();
6369 test_VarBoolFromR4();
6370 test_VarBoolFromR8();
6371 test_VarBoolFromCy();
6372 test_VarBoolFromI8();
6373 test_VarBoolFromUI8();
6374 test_VarBoolFromDec();
6375 test_VarBoolFromDate();
6376 test_VarBoolFromStr();
6377 test_VarBoolCopy();
6378 test_VarBoolChangeTypeEx();
6379
6380 test_VarBstrFromI4();
6381 test_VarBstrFromR4();
6382 test_VarBstrFromDate();
6383 test_VarBstrFromCy();
6384 test_VarBstrFromDec();
6385 test_VarBstrCmp();
6386 test_SysStringLen();
6387 test_SysStringByteLen();
6388 test_SysAllocString();
6389 test_SysAllocStringLen();
6390 test_SysAllocStringByteLen();
6391 test_SysReAllocString();
6392 test_SysReAllocStringLen();
6393 test_BstrCopy();
6394 test_VarBstrCat();
6395
6396 test_IUnknownClear();
6397 test_IUnknownCopy();
6398 test_IUnknownChangeTypeEx();
6399
6400 test_IDispatchClear();
6401 test_IDispatchCopy();
6402 test_IDispatchChangeTypeEx();
6403
6404 test_ErrorChangeTypeEx();
6405 test_EmptyChangeTypeEx();
6406 test_NullChangeTypeEx();
6407 test_UintChangeTypeEx();
6408
6409 test_ClearCustData();
6410
6411 test_NullByRef();
6412 test_ChangeType_keep_dst();
6413
6414 test_recinfo();
6415 }
Windows API implementation