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