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