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