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