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