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