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