?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Check for null pointers in IHTMLLocation_get*.
[wine/hramrach.git] / dlls / oleaut32 / tests / vartype.c
blob03210130dcd196d2958a10a891acb0d6ed31a2f0
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 #define EXPECTDECI if (i < 0) EXPECTDEC(0, 0x80, 0, -i); else EXPECTDEC(0, 0, 0, i)
4024
4025 static void test_VarDecFromI1(void)
4026 {
4027 CONVVARS(signed char);
4028 int i;
4029
4030 CHECKPTR(VarDecFromI1);
4031 for (i = -128; i < 128; i++)
4032 {
4033 CONVERT(VarDecFromI1,i); EXPECTDECI;
4034 }
4035 }
4036
4037 static void test_VarDecFromI2(void)
4038 {
4039 CONVVARS(SHORT);
4040 int i;
4041
4042 CHECKPTR(VarDecFromI2);
4043 for (i = -32768; i < 32768; i++)
4044 {
4045 CONVERT(VarDecFromI2,i); EXPECTDECI;
4046 }
4047 }
4048
4049 static void test_VarDecFromI4(void)
4050 {
4051 CONVVARS(LONG);
4052 int i;
4053
4054 CHECKPTR(VarDecFromI4);
4055 for (i = -32768; i < 32768; i++)
4056 {
4057 CONVERT(VarDecFromI4,i); EXPECTDECI;
4058 }
4059 }
4060
4061 static void test_VarDecFromI8(void)
4062 {
4063 CONVVARS(LONG64);
4064 int i;
4065
4066 CHECKPTR(VarDecFromI8);
4067 for (i = -32768; i < 32768; i++)
4068 {
4069 CONVERT(VarDecFromI8,i); EXPECTDECI;
4070 }
4071 }
4072
4073 static void test_VarDecFromUI1(void)
4074 {
4075 CONVVARS(BYTE);
4076 int i;
4077
4078 CHECKPTR(VarDecFromUI1);
4079 for (i = 0; i < 256; i++)
4080 {
4081 CONVERT(VarDecFromUI1,i); EXPECTDECI;
4082 }
4083 }
4084
4085 static void test_VarDecFromUI2(void)
4086 {
4087 CONVVARS(USHORT);
4088 int i;
4089
4090 CHECKPTR(VarDecFromUI2);
4091 for (i = 0; i < 65536; i++)
4092 {
4093 CONVERT(VarDecFromUI2,i); EXPECTDECI;
4094 }
4095 }
4096
4097 static void test_VarDecFromUI4(void)
4098 {
4099 CONVVARS(ULONG);
4100 int i;
4101
4102 CHECKPTR(VarDecFromUI4);
4103 for (i = 0; i < 65536; i++)
4104 {
4105 CONVERT(VarDecFromUI4,i); EXPECTDECI;
4106 }
4107 }
4108
4109 static void test_VarDecFromUI8(void)
4110 {
4111 CONVVARS(ULONG64);
4112 int i;
4113
4114 CHECKPTR(VarDecFromUI8);
4115 for (i = 0; i < 65536; i++)
4116 {
4117 CONVERT(VarDecFromUI8,i); EXPECTDECI;
4118 }
4119 }
4120
4121 static void test_VarDecFromBool(void)
4122 {
4123 CONVVARS(SHORT);
4124 int i;
4125
4126 CHECKPTR(VarDecFromBool);
4127 /* Test all possible type values. Note that the result is reduced to 0 or -1 */
4128 for (i = -32768; i < 0; i++)
4129 {
4130 CONVERT(VarDecFromBool,i);
4131 if (i)
4132 EXPECTDEC(0,0x80,0,1);
4133 else
4134 EXPECTDEC(0,0,0,0);
4135 }
4136 }
4137
4138 static void test_VarDecFromR4(void)
4139 {
4140 CONVVARS(float);
4141
4142 CHECKPTR(VarDecFromR4);
4143
4144 CONVERT(VarDecFromR4,-0.6f); EXPECTDEC(1,0x80,0,6);
4145 CONVERT(VarDecFromR4,-0.5f); EXPECTDEC(1,0x80,0,5);
4146 CONVERT(VarDecFromR4,-0.4f); EXPECTDEC(1,0x80,0,4);
4147 CONVERT(VarDecFromR4,0.0f); EXPECTDEC(0,0,0,0);
4148 CONVERT(VarDecFromR4,0.4f); EXPECTDEC(1,0,0,4);
4149 CONVERT(VarDecFromR4,0.5f); EXPECTDEC(1,0,0,5);
4150 CONVERT(VarDecFromR4,0.6f); EXPECTDEC(1,0,0,6);
4151 }
4152
4153 static void test_VarDecFromR8(void)
4154 {
4155 CONVVARS(double);
4156
4157 CHECKPTR(VarDecFromR8);
4158
4159 CONVERT(VarDecFromR8,-0.6); EXPECTDEC(1,0x80,0,6);
4160 CONVERT(VarDecFromR8,-0.5); EXPECTDEC(1,0x80,0,5);
4161 CONVERT(VarDecFromR8,-0.4); EXPECTDEC(1,0x80,0,4);
4162 CONVERT(VarDecFromR8,0.0); EXPECTDEC(0,0,0,0);
4163 CONVERT(VarDecFromR8,0.4); EXPECTDEC(1,0,0,4);
4164 CONVERT(VarDecFromR8,0.5); EXPECTDEC(1,0,0,5);
4165 CONVERT(VarDecFromR8,0.6); EXPECTDEC(1,0,0,6);
4166 }
4167
4168 static void test_VarDecFromDate(void)
4169 {
4170 CONVVARS(DATE);
4171
4172 CHECKPTR(VarDecFromDate);
4173
4174 CONVERT(VarDecFromDate,-0.6); EXPECTDEC(1,0x80,0,6);
4175 CONVERT(VarDecFromDate,-0.5); EXPECTDEC(1,0x80,0,5);
4176 CONVERT(VarDecFromDate,-0.4); EXPECTDEC(1,0x80,0,4);
4177 CONVERT(VarDecFromDate,0.0); EXPECTDEC(0,0,0,0);
4178 CONVERT(VarDecFromDate,0.4); EXPECTDEC(1,0,0,4);
4179 CONVERT(VarDecFromDate,0.5); EXPECTDEC(1,0,0,5);
4180 CONVERT(VarDecFromDate,0.6); EXPECTDEC(1,0,0,6);
4181 }
4182
4183 static void test_VarDecFromStr(void)
4184 {
4185 CONVVARS(LCID);
4186 OLECHAR buff[128];
4187
4188 CHECKPTR(VarDecFromStr);
4189
4190 in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4191
4192 CONVERT_STR(VarDecFromStr,NULL,0); EXPECT_MISMATCH;
4193 CONVERT_STR(VarDecFromStr,"-1", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0x80,0,1);
4194 CONVERT_STR(VarDecFromStr,"0", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,0,0);
4195 CONVERT_STR(VarDecFromStr,"1", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,0,1);
4196 CONVERT_STR(VarDecFromStr,"0.5", LOCALE_NOUSEROVERRIDE); EXPECTDEC(1,0,0,5);
4197 CONVERT_STR(VarDecFromStr,"4294967296", LOCALE_NOUSEROVERRIDE); EXPECTDEC64(0,0,0,1,0);
4198 CONVERT_STR(VarDecFromStr,"18446744073709551616", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,1,0);
4199 CONVERT_STR(VarDecFromStr,"4294967296.0", LOCALE_NOUSEROVERRIDE); EXPECTDEC64(0,0,0,1,0);
4200 CONVERT_STR(VarDecFromStr,"18446744073709551616.0", LOCALE_NOUSEROVERRIDE); EXPECTDEC(0,0,1,0);
4201 }
4202
4203 static void test_VarDecFromCy(void)
4204 {
4205 CONVVARS(CY);
4206
4207 CHECKPTR(VarDecFromCy);
4208
4209 CONVERT_CY(VarDecFromCy, -1); EXPECTDEC(4,0x80,0,10000);
4210 CONVERT_CY(VarDecFromCy, 0); EXPECTDEC(4,0,0,0);
4211 CONVERT_CY(VarDecFromCy, 1); EXPECTDEC(4,0,0,10000);
4212 CONVERT_CY(VarDecFromCy, 0.5); EXPECTDEC(4,0,0,5000);
4213 }
4214
4215 #undef MATHVARS1
4216 #define MATHVARS1 HRESULT hres; DECIMAL l, out
4217 #undef MATHVARS2
4218 #define MATHVARS2 MATHVARS1; DECIMAL r
4219 #undef MATH1
4220 #define MATH1(func) hres = p##func(&l, &out)
4221 #undef MATH2
4222 #define MATH2(func) hres = p##func(&l, &r, &out)
4223
4224 static void test_VarDecAbs(void)
4225 {
4226 MATHVARS1;
4227
4228 CHECKPTR(VarDecAbs);
4229 SETDEC(l,0,0x80,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
4230 SETDEC(l,0,0,0,0); MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
4231 SETDEC(l,0,0x80,0,0); MATH1(VarDecAbs); EXPECTDEC(0,0,0,0);
4232 SETDEC(l,0,0,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0,0,1);
4233
4234 /* Doesn't check for invalid input */
4235 SETDEC(l,0,0x7f,0,1); MATH1(VarDecAbs); EXPECTDEC(0,0x7f,0,1);
4236 SETDEC(l,0,0x80,29,1); MATH1(VarDecAbs); EXPECTDEC(0,0,29,1);
4237 }
4238
4239 static void test_VarDecNeg(void)
4240 {
4241 MATHVARS1;
4242
4243 CHECKPTR(VarDecNeg);
4244 SETDEC(l,0,0x80,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0,0,1);
4245 SETDEC(l,0,0,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,0); /* '-0'! */
4246 SETDEC(l,0,0x80,0,0); MATH1(VarDecNeg); EXPECTDEC(0,0,0,0);
4247 SETDEC(l,0,0,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0x80,0,1);
4248
4249 /* Doesn't check for invalid input */
4250 SETDEC(l,0,0x7f,0,1); MATH1(VarDecNeg); EXPECTDEC(0,0xff,0,1);
4251 SETDEC(l,0,0x80,29,1); MATH1(VarDecNeg); EXPECTDEC(0,0,29,1);
4252 SETDEC(l,0,0,29,1); MATH1(VarDecNeg); EXPECTDEC(0,0x80,29,1);
4253 }
4254
4255 static void test_VarDecAdd(void)
4256 {
4257 MATHVARS2;
4258
4259 CHECKPTR(VarDecAdd);
4260 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0);
4261 SETDEC(l,0,0,0,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
4262 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4263
4264 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4265 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,2);
4266 SETDEC(l,0,0,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,0); /* '-0'! */
4267 SETDEC(l,0,0,0,1); SETDEC(r,0,0x80,0,2); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
4268
4269 SETDEC(l,0,0x80,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4270 SETDEC(l,0,0x80,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0);
4271 SETDEC(l,0,0x80,0,1); SETDEC(r,0,0,0,2); MATH2(VarDecAdd); EXPECTDEC(0,0,0,1);
4272 SETDEC(l,0,0x80,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,2);
4273 SETDEC(l,0,0x80,0,2); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0x80,0,1);
4274
4275 SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,0xfffffffe);
4276 SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,(ULONG64)1 << 32);
4277 SETDEC(l,0,0,0,0xffffffff); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0,(ULONG64)1 << 32);
4278
4279 SETDEC64(l,0,0,0,0xffffffff,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC64(0,0,0,0xffffffff,1);
4280 SETDEC64(l,0,0,0,0xffffffff,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4281 EXPECTDEC64(0,0,0,0xfffffffe,0xffffffff);
4282
4283 SETDEC64(l,0,0,0,0xffffffff,0xffffffff); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,1,0);
4284 SETDEC64(l,0,0,0,0xffffffff,0xffffffff); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4285 EXPECTDEC64(0,0,0,0xffffffff,0xfffffffe);
4286
4287 SETDEC(l,0,0,0xffffffff,0); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(0,0,0xffffffff,1);
4288 SETDEC(l,0,0,0xffffffff,0); SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4289 EXPECTDEC64(0,0,0xfffffffe,0xffffffff,0xffffffff);
4290
4291 SETDEC64(l,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,0,0x80,0,1); MATH2(VarDecAdd);
4292 EXPECTDEC64(0,0,0xffffffff,0xffffffff,0xfffffffe);
4293 SETDEC64(l,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r,0,0,0,1); MATH2(VarDecAdd);
4294 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4295 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4296
4297 /* Promotes to the highest scale, so here the results are in the scale of 2 */
4298 SETDEC(l,2,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecAdd); EXPECTDEC(2,0,0,0);
4299 SETDEC(l,2,0,0,100); SETDEC(r,0,0,0,1); MATH2(VarDecAdd); EXPECTDEC(2,0,0,200);
4300 }
4301
4302 static void test_VarDecSub(void)
4303 {
4304 MATHVARS2;
4305
4306 CHECKPTR(VarDecSub);
4307 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecSub); EXPECTDEC(0,0x80,0,0);
4308 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecSub); EXPECTDEC(0,0x80,0,1);
4309 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecSub); EXPECTDEC(0,0x80,0,0);
4310 SETDEC(l,0,0,0,1); SETDEC(r,0,0x80,0,1); MATH2(VarDecSub); EXPECTDEC(0,0,0,2);
4311 }
4312
4313 static void test_VarDecMul(void)
4314 {
4315 MATHVARS2;
4316
4317 CHECKPTR(VarDecMul);
4318 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
4319 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
4320 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecMul); EXPECTDEC(0,0,0,0);
4321 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecMul); EXPECTDEC(0,0,0,1);
4322 SETDEC(l,0,0,0,45000);SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC(0,0,0,90000);
4323 SETDEC(l,0,0,0,2); SETDEC(r,0,0,0,45000); MATH2(VarDecMul); EXPECTDEC(0,0,0,90000);
4324
4325 SETDEC(l,0,0x80,0,2); SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC(0,0x80,0,4);
4326 SETDEC(l,0,0,0,2); SETDEC(r,0,0x80,0,2); MATH2(VarDecMul); EXPECTDEC(0,0x80,0,4);
4327 SETDEC(l,0,0x80,0,2); SETDEC(r,0,0x80,0,2); MATH2(VarDecMul); EXPECTDEC(0,0,0,4);
4328
4329 SETDEC(l,4,0,0,2); SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC(4,0,0,4);
4330 SETDEC(l,0,0,0,2); SETDEC(r,3,0,0,2); MATH2(VarDecMul); EXPECTDEC(3,0,0,4);
4331 SETDEC(l,4,0,0,2); SETDEC(r,3,0,0,2); MATH2(VarDecMul); EXPECTDEC(7,0,0,4);
4332 /* this last one shows that native oleaut32 does *not* gratuitously seize opportunities
4333 to reduce the scale if possible - the canonical result for the expected value is (6,0,0,1)
4334 */
4335 SETDEC(l,4,0,0,5); SETDEC(r,3,0,0,2); MATH2(VarDecMul); EXPECTDEC(7,0,0,10);
4336
4337 SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC(r,0,0,0,2); MATH2(VarDecMul); EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4338 SETDEC(l,0,0,0,2); SETDEC64(r,0,0,0,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecMul); EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4339 SETDEC(l,0,0,1,1); SETDEC(r,0,0,0,0x80000000); MATH2(VarDecMul); EXPECTDEC(0,0,0x80000000,0x80000000);
4340 SETDEC(l,0,0,0,0x80000000); SETDEC(r,0,0,1,1); MATH2(VarDecMul); EXPECTDEC(0,0,0x80000000,0x80000000);
4341
4342 /* near-overflow, used as a reference */
4343 SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC(r,0,0,0,2000000000); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4344 /* actual overflow - right operand is 10 times the previous value */
4345 SETDEC64(l,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r,0,0,0,4,0xA817C800); MATH2(VarDecMul);
4346 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4347 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4348 /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result */
4349 SETDEC64(l,1,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r,0,0,0,4,0xA817C800); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4350
4351 /* near-overflow, used as a reference */
4352 SETDEC64(l,0,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC(r,0,0,0,1000000000); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4353 /* actual overflow - right operand is 10 times the previous value */
4354 SETDEC64(l,0,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC64(r,0,0,0,2,0x540BE400); MATH2(VarDecMul);
4355 ok(hres == DISP_E_OVERFLOW,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4356 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4357 /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result */
4358 SETDEC64(l,1,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC64(r,0,0,0,2,0x540BE400); MATH2(VarDecMul);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4359
4360 /* this one shows that native oleaut32 is willing to lose significant digits in order to avert an overflow */
4361 SETDEC64(l,2,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r,0,0,0,9,0x502F9001); MATH2(VarDecMul);EXPECTDEC64(1,0,0xee6b2800,0x19999998,0xab2e719a);
4362 }
4363
4364 static void test_VarDecDiv(void)
4365 {
4366 MATHVARS2;
4367
4368 CHECKPTR(VarDecDiv);
4369 /* identity divisions */
4370 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(0,0,0,0);
4371 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(0,0,0,1);
4372 SETDEC(l,1,0,0,1); SETDEC(r,0,0,0,1); MATH2(VarDecDiv); EXPECTDEC(1,0,0,1);
4373
4374 /* exact divisions */
4375 SETDEC(l,0,0,0,45); SETDEC(r,0,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,5);
4376 SETDEC(l,1,0,0,45); SETDEC(r,0,0,0,9); MATH2(VarDecDiv); EXPECTDEC(1,0,0,5);
4377 SETDEC(l,0,0,0,45); SETDEC(r,1,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,50);
4378 SETDEC(l,1,0,0,45); SETDEC(r,2,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,50);
4379 /* these last three results suggest that native oleaut32 scales both operands down to zero
4380 before the division, but does *not* try to scale the result, even if it is possible -
4381 analogous to multiplication behavior
4382 */
4383 SETDEC(l,1,0,0,45); SETDEC(r,1,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0,0,5);
4384 SETDEC(l,2,0,0,450); SETDEC(r,1,0,0,9); MATH2(VarDecDiv); EXPECTDEC(1,0,0,50);
4385
4386 /* inexact divisions */
4387 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4388 SETDEC(l,1,0,0,1); SETDEC(r,0,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,18070036,0x35458014,0x4d555555);
4389 SETDEC(l,0,0,0,1); SETDEC(r,1,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4390 SETDEC(l,1,0,0,1); SETDEC(r,2,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4391 SETDEC(l,1,0,0,1); SETDEC(r,1,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4392 SETDEC(l,2,0,0,10); SETDEC(r,1,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4393
4394 /* this one shows that native oleaut32 rounds up the result */
4395 SETDEC(l,0,0,0,2); SETDEC(r,0,0,0,3); MATH2(VarDecDiv); EXPECTDEC64(28,0,361400724,0x296e0196,0x0aaaaaab);
4396
4397 /* sign tests */
4398 SETDEC(l,0,0x80,0,45); SETDEC(r,0,0,0,9); MATH2(VarDecDiv); EXPECTDEC(0,0x80,0,5);
4399 SETDEC(l,0,0,0,45); SETDEC(r,0,0x80,0,9); MATH2(VarDecDiv);EXPECTDEC(0,0x80,0,5);
4400 SETDEC(l,0,0x80,0,45); SETDEC(r,0,0x80,0,9); MATH2(VarDecDiv);EXPECTDEC(0,0,0,5);
4401
4402 /* oddballs */
4403 SETDEC(l,0,0,0,0); SETDEC(r,0,0,0,0); MATH2(VarDecDiv);/* indeterminate */
4404 ok(hres == DISP_E_DIVBYZERO,"Expected division-by-zero, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4405 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4406 SETDEC(l,0,0,0,1); SETDEC(r,0,0,0,0); MATH2(VarDecDiv);/* division by zero */
4407 ok(hres == DISP_E_DIVBYZERO,"Expected division-by-zero, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4408 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres);
4409
4410 }
4411
4412 static void test_VarDecCmp(void)
4413 {
4414 MATHVARS1;
4415
4416 CHECKPTR(VarDecCmp);
4417
4418 SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4419 SETDEC(l,0,0,0,1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4420 SETDEC(l,0,0,0,1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4421
4422 SETDEC(l,0,0,0,1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4423 SETDEC(l,0,0,0,1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4424 SETDEC(l,0,0,0,1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4425
4426 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4427 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4428 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4429
4430 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4431 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4432 SETDEC(l,0,DECIMAL_NEG,0,1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4433
4434 SETDEC(l,0,0,0,0); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4435 SETDEC(l,0,0,0,0); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4436 SETDEC(l,0,0,0,0); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4437
4438 SETDEC(l,0,0,0,0); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4439 SETDEC(l,0,0,0,0); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4440 SETDEC(l,0,0,0,0); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4441
4442 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4443 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4444 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4445
4446 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4447 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4448 SETDEC(l,0,DECIMAL_NEG,0,0); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4449
4450 SETDEC(l,0,0,-1,-1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4451 SETDEC(l,0,0,-1,-1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4452 SETDEC(l,0,0,-1,-1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4453
4454 SETDEC(l,0,0,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4455 SETDEC(l,0,0,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4456 SETDEC(l,0,0,-1,-1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4457
4458 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4459 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4460 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4461
4462 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4463 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4464 SETDEC(l,0,DECIMAL_NEG,-1,-1); SETDEC(out,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4465
4466
4467 SETDEC(out,0,0,0,1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4468 SETDEC(out,0,0,0,1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4469 SETDEC(out,0,0,0,1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4470
4471 SETDEC(out,0,0,0,1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4472 SETDEC(out,0,0,0,1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4473 SETDEC(out,0,0,0,1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4474
4475 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4476 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4477 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4478
4479 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_EQ;
4480 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4481 SETDEC(out,0,DECIMAL_NEG,0,1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4482
4483 SETDEC(out,0,0,0,0); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4484 SETDEC(out,0,0,0,0); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4485 SETDEC(out,0,0,0,0); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4486
4487 SETDEC(out,0,0,0,0); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4488 SETDEC(out,0,0,0,0); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4489 SETDEC(out,0,0,0,0); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4490
4491 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4492 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4493 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4494
4495 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4496 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_EQ;
4497 SETDEC(out,0,DECIMAL_NEG,0,0); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4498
4499 SETDEC(out,0,0,-1,-1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_LT;
4500 SETDEC(out,0,0,-1,-1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_LT;
4501 SETDEC(out,0,0,-1,-1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4502
4503 SETDEC(out,0,0,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_LT;
4504 SETDEC(out,0,0,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_LT;
4505 SETDEC(out,0,0,-1,-1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_LT;
4506
4507 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,0,0,1); MATH1(VarDecCmp); EXPECT_GT;
4508 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,0,0,0); MATH1(VarDecCmp); EXPECT_GT;
4509 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,0,-1,-1); MATH1(VarDecCmp); EXPECT_GT;
4510
4511 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,1); MATH1(VarDecCmp); EXPECT_GT;
4512 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,DECIMAL_NEG,0,0); MATH1(VarDecCmp); EXPECT_GT;
4513 SETDEC(out,0,DECIMAL_NEG,-1,-1); SETDEC(l,0,DECIMAL_NEG,-1,-1); MATH1(VarDecCmp); EXPECT_EQ;
4514
4515 }
4516
4517 /*
4518 * VT_BOOL
4519 */
4520
4521 #undef CONV_TYPE
4522 #define CONV_TYPE VARIANT_BOOL
4523 #undef _EXPECTRES
4524 #define _EXPECTRES(res, x, fs) \
4525 ok((hres == S_OK && out == (CONV_TYPE)(x)) || ((HRESULT)res != S_OK && hres == (HRESULT)res), \
4526 "expected " #x ", got " fs "; hres=0x%08x\n", out, hres)
4527 #undef EXPECTRES
4528 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
4529 #undef CONVERTRANGE
4530 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i++) { \
4531 CONVERT(func, i); if (i) { EXPECT(VARIANT_TRUE); } else { EXPECT(VARIANT_FALSE); } }
4532
4533 static void test_VarBoolFromI1(void)
4534 {
4535 CONVVARS(signed char);
4536 int i;
4537
4538 CHECKPTR(VarBoolFromI1);
4539 CONVERTRANGE(VarBoolFromI1, -128, 128);
4540 }
4541
4542 static void test_VarBoolFromUI1(void)
4543 {
4544 CONVVARS(BYTE);
4545 int i;
4546
4547 CHECKPTR(VarBoolFromUI1);
4548 CONVERTRANGE(VarBoolFromUI1, 0, 256);
4549 }
4550
4551 static void test_VarBoolFromI2(void)
4552 {
4553 CONVVARS(SHORT);
4554 int i;
4555
4556 CHECKPTR(VarBoolFromI2);
4557 CONVERTRANGE(VarBoolFromI2, -32768, 32768);
4558 }
4559
4560 static void test_VarBoolFromUI2(void)
4561 {
4562 CONVVARS(USHORT);
4563 int i;
4564
4565 CHECKPTR(VarBoolFromUI2);
4566 CONVERTRANGE(VarBoolFromUI2, 0, 65536);
4567 }
4568
4569 static void test_VarBoolFromI4(void)
4570 {
4571 CONVVARS(int);
4572
4573 CHECKPTR(VarBoolFromI4);
4574 CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
4575 CONVERT(VarBoolFromI4, -1); EXPECT(VARIANT_TRUE);
4576 CONVERT(VarBoolFromI4, 0); EXPECT(VARIANT_FALSE);
4577 CONVERT(VarBoolFromI4, 1); EXPECT(VARIANT_TRUE);
4578 CONVERT(VarBoolFromI4, 0x7fffffff); EXPECT(VARIANT_TRUE);
4579 }
4580
4581 static void test_VarBoolFromUI4(void)
4582 {
4583 CONVVARS(ULONG);
4584
4585 CHECKPTR(VarBoolFromUI4);
4586 CONVERT(VarBoolFromI4, 0); EXPECT(VARIANT_FALSE);
4587 CONVERT(VarBoolFromI4, 1); EXPECT(VARIANT_TRUE);
4588 CONVERT(VarBoolFromI4, 0x80000000); EXPECT(VARIANT_TRUE);
4589 }
4590
4591 static void test_VarBoolFromR4(void)
4592 {
4593 CONVVARS(FLOAT);
4594
4595 CHECKPTR(VarBoolFromR4);
4596 CONVERT(VarBoolFromR4, -1.0f); EXPECT(VARIANT_TRUE);
4597 CONVERT(VarBoolFromR4, 0.0f); EXPECT(VARIANT_FALSE);
4598 CONVERT(VarBoolFromR4, 1.0f); EXPECT(VARIANT_TRUE);
4599 CONVERT(VarBoolFromR4, 1.5f); EXPECT(VARIANT_TRUE);
4600
4601 /* Rounding */
4602 CONVERT(VarBoolFromR4, -1.5f); EXPECT(VARIANT_TRUE);
4603 CONVERT(VarBoolFromR4, -0.6f); EXPECT(VARIANT_TRUE);
4604 CONVERT(VarBoolFromR4, -0.5f); EXPECT(VARIANT_TRUE);
4605 CONVERT(VarBoolFromR4, -0.4f); EXPECT(VARIANT_TRUE);
4606 CONVERT(VarBoolFromR4, 0.4f); EXPECT(VARIANT_TRUE);
4607 CONVERT(VarBoolFromR4, 0.5f); EXPECT(VARIANT_TRUE);
4608 CONVERT(VarBoolFromR4, 0.6f); EXPECT(VARIANT_TRUE);
4609 CONVERT(VarBoolFromR4, 1.5f); EXPECT(VARIANT_TRUE);
4610 }
4611
4612 static void test_VarBoolFromR8(void)
4613 {
4614 CONVVARS(DOUBLE);
4615
4616 /* Hopefully we made the point with R4 above that rounding is
4617 * irrelevant, so we'll skip that for R8 and Date
4618 */
4619 CHECKPTR(VarBoolFromR8);
4620 CONVERT(VarBoolFromR8, -1.0); EXPECT(VARIANT_TRUE);
4621 CONVERT(VarBoolFromR8, -0.0); EXPECT(VARIANT_FALSE);
4622 CONVERT(VarBoolFromR8, 1.0); EXPECT(VARIANT_TRUE);
4623 }
4624
4625 static void test_VarBoolFromCy(void)
4626 {
4627 CONVVARS(CY);
4628
4629 CHECKPTR(VarBoolFromCy);
4630 CONVERT_CY(VarBoolFromCy, -32769); EXPECT(VARIANT_TRUE);
4631 CONVERT_CY(VarBoolFromCy, -32768); EXPECT(VARIANT_TRUE);
4632 CONVERT_CY(VarBoolFromCy, -1); EXPECT(VARIANT_TRUE);
4633 CONVERT_CY(VarBoolFromCy, 0); EXPECT(VARIANT_FALSE);
4634 CONVERT_CY(VarBoolFromCy, 1); EXPECT(VARIANT_TRUE);
4635 CONVERT_CY(VarBoolFromCy, 32767); EXPECT(VARIANT_TRUE);
4636 CONVERT_CY(VarBoolFromCy, 32768); EXPECT(VARIANT_TRUE);
4637 }
4638
4639 static void test_VarBoolFromI8(void)
4640 {
4641 CONVVARS(LONG64);
4642
4643 CHECKPTR(VarBoolFromI8);
4644 CONVERT(VarBoolFromI8, -1); EXPECT(VARIANT_TRUE);
4645 CONVERT(VarBoolFromI8, 0); EXPECT(VARIANT_FALSE);
4646 CONVERT(VarBoolFromI8, 1); EXPECT(VARIANT_TRUE);
4647 }
4648
4649 static void test_VarBoolFromUI8(void)
4650 {
4651 CONVVARS(ULONG64);
4652
4653 CHECKPTR(VarBoolFromUI8);
4654 CONVERT(VarBoolFromUI8, 0); EXPECT(VARIANT_FALSE);
4655 CONVERT(VarBoolFromUI8, 1); EXPECT(VARIANT_TRUE);
4656 }
4657
4658 static void test_VarBoolFromDec(void)
4659 {
4660 CONVVARS(DECIMAL);
4661
4662 CHECKPTR(VarBoolFromDec);
4663 CONVERT_BADDEC(VarBoolFromDec);
4664
4665 if (HAVE_OLEAUT32_DECIMAL)
4666 {
4667 /* Early versions of oleaut32 don't catch these errors */
4668 CONVERT_DEC(VarBoolFromDec,29,0,0,0); EXPECT_INVALID;
4669 CONVERT_DEC(VarBoolFromDec,0,0x1,0,0); EXPECT_INVALID;
4670 CONVERT_DEC(VarBoolFromDec,0,0x40,0,0); EXPECT_INVALID;
4671 CONVERT_DEC(VarBoolFromDec,0,0x7f,0,0); EXPECT_INVALID;
4672 }
4673
4674 CONVERT_DEC(VarBoolFromDec,0,0x80,0,1); EXPECT(VARIANT_TRUE);
4675 CONVERT_DEC(VarBoolFromDec,0,0,0,0); EXPECT(VARIANT_FALSE);
4676 CONVERT_DEC(VarBoolFromDec,0,0,0,1); EXPECT(VARIANT_TRUE);
4677 CONVERT_DEC(VarBoolFromDec,0,0,1,0); EXPECT(VARIANT_TRUE);
4678
4679 CONVERT_DEC(VarBoolFromDec,2,0,0,CY_MULTIPLIER); EXPECT(VARIANT_TRUE);
4680 CONVERT_DEC(VarBoolFromDec,2,0x80,0,CY_MULTIPLIER); EXPECT(VARIANT_TRUE);
4681 }
4682
4683 static void test_VarBoolFromDate(void)
4684 {
4685 CONVVARS(DATE);
4686
4687 CHECKPTR(VarBoolFromDate);
4688 CONVERT(VarBoolFromDate, -1.0); EXPECT(VARIANT_TRUE);
4689 CONVERT(VarBoolFromDate, -0.0); EXPECT(VARIANT_FALSE);
4690 CONVERT(VarBoolFromDate, 1.0); EXPECT(VARIANT_TRUE);
4691 }
4692
4693 static void test_VarBoolFromStr(void)
4694 {
4695 CONVVARS(LCID);
4696 OLECHAR buff[128];
4697
4698 CHECKPTR(VarBoolFromStr);
4699
4700 in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4701
4702 CONVERT_STR(VarBoolFromStr,NULL,0);
4703 if (hres != E_INVALIDARG)
4704 EXPECT_MISMATCH;
4705
4706 /* #FALSE# and #TRUE# Are always accepted */
4707 CONVERT_STR(VarBoolFromStr,"#FALSE#",0); EXPECT(VARIANT_FALSE);
4708 CONVERT_STR(VarBoolFromStr,"#TRUE#",0); EXPECT(VARIANT_TRUE);
4709
4710 /* Match of #FALSE# and #TRUE# is case sensitive */
4711 CONVERT_STR(VarBoolFromStr,"#False#",0); EXPECT_MISMATCH;
4712 /* But match against English is not */
4713 CONVERT_STR(VarBoolFromStr,"false",0); EXPECT(VARIANT_FALSE);
4714 CONVERT_STR(VarBoolFromStr,"False",0); EXPECT(VARIANT_FALSE);
4715 /* On/Off and yes/no are not acceptable inputs, with any flags set */
4716 CONVERT_STR(VarBoolFromStr,"On",0xffffffff); EXPECT_MISMATCH;
4717 CONVERT_STR(VarBoolFromStr,"Yes",0xffffffff); EXPECT_MISMATCH;
4718
4719 /* Change the LCID. This doesn't make any difference for text,unless we ask
4720 * to check local boolean text with the VARIANT_LOCALBOOL flag. */
4721 in = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
4722
4723 /* #FALSE# and #TRUE# are accepted in all locales */
4724 CONVERT_STR(VarBoolFromStr,"#FALSE#",0); EXPECT(VARIANT_FALSE);
4725 CONVERT_STR(VarBoolFromStr,"#TRUE#",0); EXPECT(VARIANT_TRUE);
4726 CONVERT_STR(VarBoolFromStr,"#FALSE#",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4727 CONVERT_STR(VarBoolFromStr,"#TRUE#",VARIANT_LOCALBOOL); EXPECT(VARIANT_TRUE);
4728
4729 /* English is accepted regardless of the locale */
4730 CONVERT_STR(VarBoolFromStr,"false",0); EXPECT(VARIANT_FALSE);
4731 /* And is still not case sensitive */
4732 CONVERT_STR(VarBoolFromStr,"False",0); EXPECT(VARIANT_FALSE);
4733
4734 if (HAVE_OLEAUT32_LOCALES)
4735 {
4736 /* French is rejected without VARIANT_LOCALBOOL */
4737 CONVERT_STR(VarBoolFromStr,"faux",0); EXPECT_MISMATCH;
4738 /* But accepted if this flag is given */
4739 CONVERT_STR(VarBoolFromStr,"faux",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4740 /* Regardless of case - from this we assume locale text comparisons ignore case */
4741 CONVERT_STR(VarBoolFromStr,"Faux",VARIANT_LOCALBOOL); EXPECT(VARIANT_FALSE);
4742
4743 /* Changing the locale prevents the localised text from being compared -
4744 * this demonstrates that only the indicated LCID and English are searched */
4745 in = MAKELCID(MAKELANGID(LANG_POLISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4746 CONVERT_STR(VarBoolFromStr,"faux",VARIANT_LOCALBOOL); EXPECT_MISMATCH;
4747 }
4748
4749 /* Numeric strings are read as 0 or non-0 */
4750 CONVERT_STR(VarBoolFromStr,"0",0); EXPECT(VARIANT_FALSE);
4751 CONVERT_STR(VarBoolFromStr,"-1",0); EXPECT(VARIANT_TRUE);
4752 CONVERT_STR(VarBoolFromStr,"+1",0); EXPECT(VARIANT_TRUE);
4753
4754 if (HAVE_OLEAUT32_LOCALES)
4755 {
4756 /* Numeric strings are read as floating point numbers. The line below fails
4757 * because '.' is not a valid decimal separator for Polish numbers */
4758 CONVERT_STR(VarBoolFromStr,"0.1",LOCALE_NOUSEROVERRIDE); EXPECT_MISMATCH;
4759 }
4760
4761 /* Changing the lcid back to US English reads the r8 correctly */
4762 in = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4763 CONVERT_STR(VarBoolFromStr,"0.1",LOCALE_NOUSEROVERRIDE); EXPECT(VARIANT_TRUE);
4764 }
4765
4766 static void test_VarBoolCopy(void)
4767 {
4768 COPYTEST(1, VT_BOOL, V_BOOL(&vSrc), V_BOOL(&vDst), V_BOOLREF(&vSrc), V_BOOLREF(&vDst), "%d");
4769 }
4770
4771 #define BOOL_STR(flags, str) hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, flags, VT_BSTR); \
4772 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
4773 V_BSTR(&vDst) && !memcmp(V_BSTR(&vDst), str, sizeof(str)), \
4774 "hres=0x%X, type=%d (should be VT_BSTR), *bstr='%c'\n", \
4775 hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?')
4776
4777 static void test_VarBoolChangeTypeEx(void)
4778 {
4779 static const WCHAR szTrue[] = { 'T','r','u','e','\0' };
4780 static const WCHAR szFalse[] = { 'F','a','l','s','e','\0' };
4781 static const WCHAR szFaux[] = { 'F','a','u','x','\0' };
4782 CONVVARS(CONV_TYPE);
4783 VARIANTARG vSrc, vDst;
4784 LCID lcid;
4785
4786 in = 1;
4787
4788 INITIAL_TYPETEST(VT_BOOL, V_BOOL, "%d");
4789 COMMON_TYPETEST;
4790
4791 /* The common tests convert to a number. Try the different flags */
4792 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4793
4794 V_VT(&vSrc) = VT_BOOL;
4795 V_BOOL(&vSrc) = 1;
4796
4797 if (!IS_ANCIENT)
4798 {
4799 BOOL_STR(VARIANT_ALPHABOOL, szTrue);
4800 V_BOOL(&vSrc) = 0;
4801 BOOL_STR(VARIANT_ALPHABOOL, szFalse);
4802 }
4803
4804 if (HAVE_OLEAUT32_LOCALES)
4805 {
4806 lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
4807
4808 /* VARIANT_ALPHABOOL is always English */
4809 BOOL_STR(VARIANT_ALPHABOOL, szFalse);
4810 /* VARIANT_LOCALBOOL uses the localised text */
4811 BOOL_STR(VARIANT_LOCALBOOL, szFaux);
4812 /* Both flags together acts as VARIANT_LOCALBOOL */
4813 BOOL_STR(VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, szFaux);
4814 }
4815 }
4816
4817 /*
4818 * BSTR
4819 */
4820
4821 static void test_VarBstrFromR4(void)
4822 {
4823 static const WCHAR szNative[] = { '6','5','4','3','2','2','.','3','\0' };
4824 static const WCHAR szZero[] = {'0', '\0'};
4825 static const WCHAR szOneHalf_English[] = { '0','.','5','\0' }; /* uses period */
4826 static const WCHAR szOneHalf_Spanish[] = { '0',',','5','\0' }; /* uses comma */
4827 LCID lcid;
4828 LCID lcid_spanish;
4829 HRESULT hres;
4830 BSTR bstr = NULL;
4831
4832 float f;
4833
4834 CHECKPTR(VarBstrFromR4);
4835
4836 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
4837 lcid_spanish = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH), SORT_DEFAULT);
4838 f = 654322.23456f;
4839 hres = pVarBstrFromR4(f, lcid, 0, &bstr);
4840 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4841 if (bstr)
4842 {
4843 todo_wine {
4844 /* MSDN states that rounding of R4/R8 is dependent on the underlying
4845 * bit pattern of the number and so is architecture dependent. In this
4846 * case Wine returns .2 (which is more correct) and Native returns .3
4847 */
4848 ok(memcmp(bstr, szNative, sizeof(szNative)) == 0, "string different\n");
4849 }
4850 }
4851
4852 f = -0.0;
4853 hres = pVarBstrFromR4(f, lcid, 0, &bstr);
4854 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4855 if (bstr)
4856 {
4857 ok(memcmp(bstr, szZero, sizeof(szZero)) == 0, "negative zero (got %s)\n", wtoascii(bstr));
4858 }
4859
4860 /* The following tests that lcid is used for decimal separator even without LOCALE_USE_NLS */
4861 f = 0.5;
4862 hres = pVarBstrFromR4(f, lcid, LOCALE_NOUSEROVERRIDE, &bstr);
4863 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4864 if (bstr)
4865 {
4866 ok(memcmp(bstr, szOneHalf_English, sizeof(szOneHalf_English)) == 0, "English locale failed (got %s)\n", wtoascii(bstr));
4867 }
4868 f = 0.5;
4869 hres = pVarBstrFromR4(f, lcid_spanish, LOCALE_NOUSEROVERRIDE, &bstr);
4870 ok(hres == S_OK, "got hres 0x%08x\n", hres);
4871 if (bstr)
4872 {
4873 ok(memcmp(bstr, szOneHalf_Spanish, sizeof(szOneHalf_Spanish)) == 0, "Spanish locale failed (got %s)\n", wtoascii(bstr));
4874 }
4875 }
4876
4877 #define BSTR_DATE(dt,str) SysFreeString(bstr); bstr = NULL; \
4878 hres = pVarBstrFromDate(dt,lcid,LOCALE_NOUSEROVERRIDE,&bstr); \
4879 if (bstr) WideCharToMultiByte(CP_ACP, 0, bstr, -1, buff, sizeof(buff), 0, 0); \
4880 else buff[0] = 0; \
4881 ok(hres == S_OK && !strcmp(str,buff), "Expected '%s', got '%s', hres = 0x%08x\n", \
4882 str, buff, hres)
4883
4884 static void test_VarBstrFromDate(void)
4885 {
4886 char buff[256];
4887 LCID lcid;
4888 HRESULT hres;
4889 BSTR bstr = NULL;
4890
4891 CHECKPTR(VarBstrFromDate);
4892 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4893
4894 BSTR_DATE(0.0, "12:00:00 AM");
4895 BSTR_DATE(3.34, "1/2/1900 8:09:36 AM");
4896 BSTR_DATE(3339.34, "2/20/1909 8:09:36 AM");
4897 BSTR_DATE(365.00, "12/30/1900");
4898 BSTR_DATE(365.25, "12/30/1900 6:00:00 AM");
4899 BSTR_DATE(1461.0, "12/31/1903");
4900 BSTR_DATE(1461.5, "12/31/1903 12:00:00 PM");
4901 todo_wine { BSTR_DATE(-657434.0, "1/1/100"); }
4902 BSTR_DATE(2958465.0, "12/31/9999");
4903 }
4904
4905 #define BSTR_CY(l, a, b, e) \
4906 S(l).Lo = b; S(l).Hi = a; \
4907 hres = pVarBstrFromCy(l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);\
4908 ok(hres == S_OK, "got hres 0x%08x\n", hres);\
4909 if (hres== S_OK && bstr)\
4910 {\
4911 ok(lstrcmpW(bstr, e) == 0, "invalid number (got %s)\n", wtoascii(bstr));\
4912 }
4913
4914 static void test_VarBstrFromCy(void)
4915 {
4916 LCID lcid;
4917 HRESULT hres;
4918 BSTR bstr = NULL;
4919 CY l;
4920
4921 static const WCHAR szZero[] = {'0', '\0'};
4922 static const WCHAR szOne[] = {'1', '\0'};
4923 static const WCHAR szOnePointFive[] = {'1','.','5','\0'};
4924 static const WCHAR szMinusOnePointFive[] = {'-','1','.','5','\0'};
4925 static const WCHAR szBigNum1[] = {'4','2','9','4','9','6','.','7','2','9','5','\0'}; /* (1 << 32) - 1 / 1000 */
4926 static const WCHAR szBigNum2[] = {'4','2','9','4','9','6','.','7','2','9','6','\0'}; /* (1 << 32) / 1000 */
4927 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 */
4928
4929 static const WCHAR szSmallNumber_English[] = {'0','.','0','0','0','9','\0'};
4930 static const WCHAR szSmallNumber_Spanish[] = {'0',',','0','0','0','9','\0'};
4931
4932 CHECKPTR(VarBstrFromCy);
4933 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
4934
4935 /* check zero */
4936 BSTR_CY(l, 0,0, szZero);
4937
4938 /* check one */
4939 BSTR_CY(l, 0, 10000, szOne);
4940
4941 /* check one point five */
4942 BSTR_CY(l, 0, 15000, szOnePointFive);
4943
4944 /* check minus one point five */
4945 BSTR_CY(l, 0xffffffff, ((15000)^0xffffffff)+1, szMinusOnePointFive);
4946
4947 /* check bignum (1) */
4948 BSTR_CY(l, 0, 0xffffffff, szBigNum1);
4949
4950 /* check bignum (2) */
4951 BSTR_CY(l, 1,0, szBigNum2);
4952
4953 /* check bignum (3) */
4954 BSTR_CY(l, 0x7fffffff,0xffffffff, szBigNum3);
4955
4956 /* check leading zeros and decimal sep. for English locale */
4957 BSTR_CY(l, 0,9, szSmallNumber_English);
4958
4959 lcid = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
4960
4961 /* check leading zeros and decimal sep. for Spanish locale */
4962 BSTR_CY(l, 0,9, szSmallNumber_Spanish);
4963 }
4964
4965 #undef BSTR_CY
4966
4967 #define BSTR_DEC(l, a, b, c, d, e) \
4968 SETDEC(l, a,b,c,d);\
4969 hres = pVarBstrFromDec(&l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);\
4970 ok(hres == S_OK, "got hres 0x%08x\n", hres);\
4971 if (hres== S_OK && bstr)\
4972 {\
4973 ok(lstrcmpW(bstr, e) == 0, "invalid number (got %s)\n", wtoascii(bstr));\
4974 }
4975
4976 #define BSTR_DEC64(l, a, b, c, x, d, e) \
4977 SETDEC64(l, a,b,c,x,d);\
4978 hres = pVarBstrFromDec(&l, lcid, LOCALE_NOUSEROVERRIDE, &bstr);\
4979 ok(hres == S_OK, "got hres 0x%08x\n", hres);\
4980 if (hres== S_OK && bstr)\
4981 {\
4982 ok(lstrcmpW(bstr, e) == 0, "invalid number (got %s)\n", wtoascii(bstr));\
4983 }
4984
4985 static void test_VarBstrFromDec(void)
4986 {
4987 LCID lcid;
4988 HRESULT hres;
4989 BSTR bstr = NULL;
4990 DECIMAL l;
4991
4992 static const WCHAR szZero[] = {'0', '\0'};
4993 static const WCHAR szOne[] = {'1', '\0'};
4994 static const WCHAR szOnePointFive[] = {'1','.','5','\0'};
4995 static const WCHAR szMinusOnePointFive[] = {'-','1','.','5','\0'};
4996 static const WCHAR szBigNum1[] = {'4','2','9','4','9','6','7','2','9','5','\0'}; /* (1 << 32) - 1 */
4997 static const WCHAR szBigNum2[] = {'4','2','9','4','9','6','7','2','9','6','\0'}; /* (1 << 32) */
4998 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 */
4999 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) */
5000 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 */
5001 static const WCHAR szBigScale1[] = {'0','.','0','0','0','0','0','0','0','0','0','1','\0'}; /* 1 * 10^-10 */
5002 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 */
5003 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 */
5004
5005 static const WCHAR szSmallNumber_English[] = {'0','.','0','0','0','9','\0'};
5006 static const WCHAR szSmallNumber_Spanish[] = {'0',',','0','0','0','9','\0'};
5007
5008 CHECKPTR(VarBstrFromDec);
5009 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
5010
5011 /* check zero */
5012 BSTR_DEC(l, 0,0,0,0, szZero);
5013
5014 /* check one */
5015 BSTR_DEC(l, 0,0,0,1, szOne);
5016 BSTR_DEC(l, 1,0,0,10,szOne);
5017 BSTR_DEC(l, 2,0,0,100,szOne);
5018 BSTR_DEC(l, 3,0,0,1000,szOne);
5019
5020 /* check one point five */
5021 BSTR_DEC(l, 1,0,0,15, szOnePointFive);
5022 BSTR_DEC(l, 2,0,0,150, szOnePointFive);
5023 BSTR_DEC(l, 3,0,0,1500, szOnePointFive);
5024
5025 /* check minus one point five */
5026 BSTR_DEC(l, 1,0x80,0,15, szMinusOnePointFive);
5027
5028 /* check bignum (1) */
5029 BSTR_DEC(l, 0,0,0,0xffffffff, szBigNum1);
5030
5031 /* check bignum (2) */
5032 BSTR_DEC64(l, 0,0,0,1,0, szBigNum2);
5033
5034 /* check bignum (3) */
5035 BSTR_DEC64(l, 0,0,0,0xffffffff,0xffffffff, szBigNum3);
5036
5037 /* check bignum (4) */
5038 BSTR_DEC(l, 0,0,1,0, szBigNum4);
5039
5040 /* check bignum (5) */
5041 BSTR_DEC64(l, 0,0,0xffffffff,0xffffffff,0xffffffff, szBigNum5);
5042
5043 /* check bigscale (1) */
5044 BSTR_DEC(l, 10,0,0,1, szBigScale1);
5045
5046 /* check bigscale (2) */
5047 BSTR_DEC64(l, 10,0,0xffffffffUL,0xffffffff,0xffffffff, szBigScale2);
5048
5049 /* check bigscale (3) */
5050 BSTR_DEC64(l, 28,0,0xffffffffUL,0xffffffff,0xffffffff, szBigScale3);
5051
5052 /* check leading zeros and decimal sep. for English locale */
5053 BSTR_DEC(l, 4,0,0,9, szSmallNumber_English);
5054 BSTR_DEC(l, 5,0,0,90, szSmallNumber_English);
5055 BSTR_DEC(l, 6,0,0,900, szSmallNumber_English);
5056 BSTR_DEC(l, 7,0,0,9000, szSmallNumber_English);
5057
5058 lcid = MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_DEFAULT), SORT_DEFAULT);
5059
5060 /* check leading zeros and decimal sep. for Spanish locale */
5061 BSTR_DEC(l, 4,0,0,9, szSmallNumber_Spanish);
5062 BSTR_DEC(l, 5,0,0,90, szSmallNumber_Spanish);
5063 BSTR_DEC(l, 6,0,0,900, szSmallNumber_Spanish);
5064 BSTR_DEC(l, 7,0,0,9000, szSmallNumber_Spanish);
5065 }
5066 #undef BSTR_DEC
5067 #undef BSTR_DEC64
5068
5069 #define _VARBSTRCMP(left,right,lcid,flags,result) \
5070 hres = pVarBstrCmp(left,right,lcid,flags); \
5071 ok(hres == result, "VarBstrCmp: expected " #result ", got hres=0x%x\n", hres)
5072 #define VARBSTRCMP(left,right,flags,result) \
5073 _VARBSTRCMP(left,right,lcid,flags,result)
5074
5075 static void test_VarBstrCmp(void)
5076 {
5077 LCID lcid;
5078 HRESULT hres;
5079 static const WCHAR sz[] = {'W','u','r','s','c','h','t','\0'};
5080 static const WCHAR szempty[] = {'\0'};
5081 static const WCHAR sz1[] = { 'a',0 };
5082 static const WCHAR sz2[] = { 'A',0 };
5083 static const WCHAR s1[] = { 'a',0 };
5084 static const WCHAR s2[] = { 'a',0,'b' };
5085 static const char sb1[] = {1,0,1};
5086 static const char sb2[] = {1,0,2};
5087 static const char sbchr0[] = {0,0};
5088 static const char sbchr00[] = {0,0,0};
5089 BSTR bstr, bstrempty, bstr2;
5090
5091 CHECKPTR(VarBstrCmp);
5092
5093 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
5094 bstr = SysAllocString(sz);
5095 bstrempty = SysAllocString(szempty);
5096
5097 /* NULL handling. Yepp, MSDN is totally wrong here */
5098 VARBSTRCMP(NULL,NULL,0,VARCMP_EQ);
5099 VARBSTRCMP(bstr,NULL,0,VARCMP_GT);
5100 VARBSTRCMP(NULL,bstr,0,VARCMP_LT);
5101
5102 /* NULL and empty string comparisons */
5103 VARBSTRCMP(bstrempty,NULL,0,VARCMP_EQ);
5104 VARBSTRCMP(NULL,bstrempty,0,VARCMP_EQ);
5105
5106 SysFreeString(bstr);
5107 bstr = SysAllocString(sz1);
5108
5109 bstr2 = SysAllocString(sz2);
5110 VARBSTRCMP(bstr,bstr2,0,VARCMP_LT);
5111 VARBSTRCMP(bstr,bstr2,NORM_IGNORECASE,VARCMP_EQ);
5112 SysFreeString(bstr2);
5113 /* These two strings are considered equal even though one is
5114 * NULL-terminated and the other not.
5115 */
5116 bstr2 = SysAllocStringLen(s1, sizeof(s1) / sizeof(WCHAR));
5117 VARBSTRCMP(bstr,bstr2,0,VARCMP_EQ);
5118 SysFreeString(bstr2);
5119
5120 /* These two strings are not equal */
5121 bstr2 = SysAllocStringLen(s2, sizeof(s2) / sizeof(WCHAR));
5122 VARBSTRCMP(bstr,bstr2,0,VARCMP_LT);
5123 SysFreeString(bstr2);
5124
5125 SysFreeString(bstr);
5126
5127 bstr = SysAllocStringByteLen(sbchr0, sizeof(sbchr0));
5128 bstr2 = SysAllocStringByteLen(sbchr0, sizeof(sbchr00));
5129 VARBSTRCMP(bstr,bstrempty,0,VARCMP_GT);
5130 VARBSTRCMP(bstrempty,bstr,0,VARCMP_LT);
5131 VARBSTRCMP(bstr2,bstrempty,0,VARCMP_GT);
5132 VARBSTRCMP(bstr2,bstr,0,VARCMP_EQ);
5133 SysFreeString(bstr2);
5134 SysFreeString(bstr);
5135
5136 /* When (LCID == 0) it should be a binary comparison
5137 * so these two strings could not match.
5138 */
5139 bstr = SysAllocStringByteLen(sb1, sizeof(sb1));
5140 bstr2 = SysAllocStringByteLen(sb2, sizeof(sb2));
5141 lcid = 0;
5142 VARBSTRCMP(bstr,bstr2,0,VARCMP_LT);
5143 SysFreeString(bstr2);
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_GT);
5152 SysFreeString(bstr2);
5153 SysFreeString(bstr);
5154 }
5155
5156 /* Get the internal representation of a BSTR */
5157 static inline LPINTERNAL_BSTR Get(const BSTR lpszString)
5158 {
5159 return lpszString ? (LPINTERNAL_BSTR)((char*)lpszString - sizeof(DWORD)) : NULL;
5160 }
5161
5162 static inline BSTR GetBSTR(const LPINTERNAL_BSTR bstr)
5163 {
5164 return (BSTR)bstr->szString;
5165 }
5166
5167 static void test_SysStringLen(void)
5168 {
5169 INTERNAL_BSTR bstr;
5170 BSTR str = GetBSTR(&bstr);
5171
5172 bstr.dwLen = 0;
5173 ok (SysStringLen(str) == 0, "Expected dwLen 0, got %d\n", SysStringLen(str));
5174 bstr.dwLen = 2;
5175 ok (SysStringLen(str) == 1, "Expected dwLen 1, got %d\n", SysStringLen(str));
5176 }
5177
5178 static void test_SysStringByteLen(void)
5179 {
5180 INTERNAL_BSTR bstr;
5181 BSTR str = GetBSTR(&bstr);
5182
5183 bstr.dwLen = 0;
5184 ok (SysStringByteLen(str) == 0, "Expected dwLen 0, got %d\n", SysStringByteLen(str));
5185 bstr.dwLen = 2;
5186 ok (SysStringByteLen(str) == 2, "Expected dwLen 2, got %d\n", SysStringByteLen(str));
5187 }
5188
5189 static void test_SysAllocString(void)
5190 {
5191 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5192 BSTR str;
5193
5194 str = SysAllocString(NULL);
5195 ok (str == NULL, "Expected NULL, got %p\n", str);
5196
5197 str = SysAllocString(szTest);
5198 ok (str != NULL, "Expected non-NULL\n");
5199 if (str)
5200 {
5201 LPINTERNAL_BSTR bstr = Get(str);
5202
5203 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5204 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5205 SysFreeString(str);
5206 }
5207 }
5208
5209 static void test_SysAllocStringLen(void)
5210 {
5211 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5212 BSTR str;
5213
5214 /* Very early native dlls do not limit the size of strings, so skip this test */
5215 if (0)
5216 {
5217 str = SysAllocStringLen(szTest, 0x80000000);
5218 todo_wine {
5219 ok (str == NULL, "Expected NULL, got %p\n", str);
5220 }
5221 }
5222
5223 str = SysAllocStringLen(NULL, 0);
5224 ok (str != NULL, "Expected non-NULL\n");
5225 if (str)
5226 {
5227 LPINTERNAL_BSTR bstr = Get(str);
5228
5229 ok (bstr->dwLen == 0, "Expected 0, got %d\n", bstr->dwLen);
5230 ok (!bstr->szString[0], "String not empty\n");
5231 SysFreeString(str);
5232 }
5233
5234 str = SysAllocStringLen(szTest, 4);
5235 ok (str != NULL, "Expected non-NULL\n");
5236 if (str)
5237 {
5238 LPINTERNAL_BSTR bstr = Get(str);
5239
5240 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5241 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5242 SysFreeString(str);
5243 }
5244 }
5245
5246 static void test_SysAllocStringByteLen(void)
5247 {
5248 const OLECHAR szTest[10] = { 'T','e','s','t','\0' };
5249 const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
5250 BSTR str;
5251
5252 str = SysAllocStringByteLen(szTestA, 0x80000000);
5253 ok (str == NULL, "Expected NULL, got %p\n", str);
5254
5255 str = SysAllocStringByteLen(szTestA, 0xffffffff);
5256 ok (str == NULL, "Expected NULL, got %p\n", str);
5257
5258 str = SysAllocStringByteLen(NULL, 0);
5259 ok (str != NULL, "Expected non-NULL\n");
5260 if (str)
5261 {
5262 LPINTERNAL_BSTR bstr = Get(str);
5263
5264 ok (bstr->dwLen == 0, "Expected 0, got %d\n", bstr->dwLen);
5265 ok (!bstr->szString[0], "String not empty\n");
5266 SysFreeString(str);
5267 }
5268
5269 str = SysAllocStringByteLen(szTestA, 4);
5270 ok (str != NULL, "Expected non-NULL\n");
5271 if (str)
5272 {
5273 LPINTERNAL_BSTR bstr = Get(str);
5274
5275 ok (bstr->dwLen == 4, "Expected 4, got %d\n", bstr->dwLen);
5276 ok (!lstrcmpA((LPCSTR)bstr->szString, szTestA), "String different\n");
5277 SysFreeString(str);
5278 }
5279
5280 /* Odd lengths are allocated rounded up, but truncated at the right position */
5281 str = SysAllocStringByteLen(szTestA, 3);
5282 ok (str != NULL, "Expected non-NULL\n");
5283 if (str)
5284 {
5285 const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
5286 LPINTERNAL_BSTR bstr = Get(str);
5287
5288 ok (bstr->dwLen == 3, "Expected 3, got %d\n", bstr->dwLen);
5289 ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
5290 SysFreeString(str);
5291 }
5292
5293 str = SysAllocStringByteLen((LPCSTR)szTest, 8);
5294 ok (str != NULL, "Expected non-NULL\n");
5295 if (str)
5296 {
5297 LPINTERNAL_BSTR bstr = Get(str);
5298
5299 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5300 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5301 SysFreeString(str);
5302 }
5303 }
5304
5305 static void test_SysReAllocString(void)
5306 {
5307 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5308 const OLECHAR szSmaller[2] = { 'x','\0' };
5309 const OLECHAR szLarger[7] = { 'L','a','r','g','e','r','\0' };
5310 BSTR str;
5311
5312 str = SysAllocStringLen(szTest, 4);
5313 ok (str != NULL, "Expected non-NULL\n");
5314 if (str)
5315 {
5316 LPINTERNAL_BSTR bstr;
5317 BSTR oldstr = str;
5318 int changed;
5319
5320 bstr = Get(str);
5321 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5322 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5323
5324 changed = SysReAllocString(&str, szSmaller);
5325 ok (changed == 1, "Expected 1, got %d\n", changed);
5326 /* Vista creates a new string, but older versions reuse the existing string. */
5327 /*ok (str == oldstr, "Created new string\n");*/
5328 bstr = Get(str);
5329 ok (bstr->dwLen == 2, "Expected 2, got %d\n", bstr->dwLen);
5330 ok (!lstrcmpW(bstr->szString, szSmaller), "String different\n");
5331
5332 oldstr = str;
5333 changed = SysReAllocString(&str, szLarger);
5334 ok (changed == 1, "Expected 1, got %d\n", changed);
5335 /* Early versions always make new strings rather than resizing */
5336 /* ok (str == oldstr, "Created new string\n"); */
5337 bstr = Get(str);
5338 ok (bstr->dwLen == 12, "Expected 12, got %d\n", bstr->dwLen);
5339 ok (!lstrcmpW(bstr->szString, szLarger), "String different\n");
5340
5341 SysFreeString(str);
5342 }
5343 }
5344
5345 static void test_SysReAllocStringLen(void)
5346 {
5347 const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
5348 const OLECHAR szSmaller[2] = { 'x','\0' };
5349 const OLECHAR szLarger[7] = { 'L','a','r','g','e','r','\0' };
5350 BSTR str;
5351
5352 str = SysAllocStringLen(szTest, 4);
5353 ok (str != NULL, "Expected non-NULL\n");
5354 if (str)
5355 {
5356 LPINTERNAL_BSTR bstr;
5357 BSTR oldstr = str;
5358 int changed;
5359
5360 bstr = Get(str);
5361 ok (bstr->dwLen == 8, "Expected 8, got %d\n", bstr->dwLen);
5362 ok (!lstrcmpW(bstr->szString, szTest), "String different\n");
5363
5364 changed = SysReAllocStringLen(&str, szSmaller, 1);
5365 ok (changed == 1, "Expected 1, got %d\n", changed);
5366 /* Vista creates a new string, but older versions reuse the existing string. */
5367 /*ok (str == oldstr, "Created new string\n");*/
5368 bstr = Get(str);
5369 ok (bstr->dwLen == 2, "Expected 2, got %d\n", bstr->dwLen);
5370 ok (!lstrcmpW(bstr->szString, szSmaller), "String different\n");
5371
5372 oldstr = str;
5373 changed = SysReAllocStringLen(&str, szLarger, 6);
5374 ok (changed == 1, "Expected 1, got %d\n", changed);
5375 /* Early versions always make new strings rather than resizing */
5376 /* ok (str == oldstr, "Created new string\n"); */
5377 bstr = Get(str);
5378 ok (bstr->dwLen == 12, "Expected 12, got %d\n", bstr->dwLen);
5379 ok (!lstrcmpW(bstr->szString, szLarger), "String different\n");
5380
5381 changed = SysReAllocStringLen(&str, str, 6);
5382 ok (changed == 1, "Expected 1, got %d\n", changed);
5383
5384 SysFreeString(str);
5385 }
5386 }
5387
5388 static void test_BstrCopy(void)
5389 {
5390 const CHAR szTestA[6] = { 'T','e','s','t','\0','?' };
5391 const CHAR szTestTruncA[4] = { 'T','e','s','\0' };
5392 LPINTERNAL_BSTR bstr;
5393 BSTR str;
5394 HRESULT hres;
5395 VARIANT vt1, vt2;
5396
5397 str = SysAllocStringByteLen(szTestA, 3);
5398 ok (str != NULL, "Expected non-NULL\n");
5399 if (str)
5400 {
5401 V_VT(&vt1) = VT_BSTR;
5402 V_BSTR(&vt1) = str;
5403 V_VT(&vt2) = VT_EMPTY;
5404 hres = VariantCopy(&vt2, &vt1);
5405 ok (hres == S_OK,"Failed to copy binary bstring with hres 0x%08x\n", hres);
5406 bstr = Get(V_BSTR(&vt2));
5407 ok (bstr->dwLen == 3, "Expected 3, got %d\n", bstr->dwLen);
5408 ok (!lstrcmpA((LPCSTR)bstr->szString, szTestTruncA), "String different\n");
5409 }
5410 }
5411
5412 static void test_VarBstrCat(void)
5413 {
5414 static const WCHAR sz1[] = { 'a',0 };
5415 static const WCHAR sz2[] = { 'b',0 };
5416 static const WCHAR sz1sz2[] = { 'a','b',0 };
5417 static const WCHAR s1[] = { 'a',0 };
5418 static const WCHAR s2[] = { 'b',0 };
5419 static const WCHAR s1s2[] = { 'a',0,'b',0 };
5420 HRESULT ret;
5421 BSTR str1, str2, res;
5422
5423 /* Crash
5424 ret = VarBstrCat(NULL, NULL, NULL);
5425 */
5426
5427 /* Concatenation of two NULL strings works */
5428 ret = VarBstrCat(NULL, NULL, &res);
5429 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5430 ok(res != NULL, "Expected a string\n");
5431 ok(SysStringLen(res) == 0, "Expected a 0-length string\n");
5432 SysFreeString(res);
5433
5434 str1 = SysAllocString(sz1);
5435
5436 /* Concatenation with one NULL arg */
5437 ret = VarBstrCat(NULL, str1, &res);
5438 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5439 ok(res != NULL, "Expected a string\n");
5440 ok(SysStringLen(res) == SysStringLen(str1), "Unexpected length\n");
5441 ok(!memcmp(res, sz1, SysStringLen(str1)), "Unexpected value\n");
5442 SysFreeString(res);
5443 ret = VarBstrCat(str1, NULL, &res);
5444 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5445 ok(res != NULL, "Expected a string\n");
5446 ok(SysStringLen(res) == SysStringLen(str1), "Unexpected length\n");
5447 ok(!memcmp(res, sz1, SysStringLen(str1)), "Unexpected value\n");
5448 SysFreeString(res);
5449
5450 /* Concatenation of two zero-terminated strings */
5451 str2 = SysAllocString(sz2);
5452 ret = VarBstrCat(str1, str2, &res);
5453 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5454 ok(res != NULL, "Expected a string\n");
5455 ok(SysStringLen(res) == sizeof(sz1sz2) / sizeof(WCHAR) - 1,
5456 "Unexpected length\n");
5457 ok(!memcmp(res, sz1sz2, sizeof(sz1sz2)), "Unexpected value\n");
5458 SysFreeString(res);
5459
5460 SysFreeString(str2);
5461 SysFreeString(str1);
5462
5463 /* Concatenation of two strings with embedded NULLs */
5464 str1 = SysAllocStringLen(s1, sizeof(s1) / sizeof(WCHAR));
5465 str2 = SysAllocStringLen(s2, sizeof(s2) / sizeof(WCHAR));
5466
5467 ret = VarBstrCat(str1, str2, &res);
5468 ok(ret == S_OK, "VarBstrCat failed: %08x\n", ret);
5469 ok(res != NULL, "Expected a string\n");
5470 ok(SysStringLen(res) == sizeof(s1s2) / sizeof(WCHAR),
5471 "Unexpected length\n");
5472 ok(!memcmp(res, s1s2, sizeof(s1s2)), "Unexpected value\n");
5473 SysFreeString(res);
5474
5475 SysFreeString(str2);
5476 SysFreeString(str1);
5477 }
5478
5479 /* IUnknown */
5480
5481 static void test_IUnknownClear(void)
5482 {
5483 HRESULT hres;
5484 VARIANTARG v;
5485 DummyDispatch u = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5486 IUnknown* pu = (IUnknown*)&u;
5487
5488 /* Test that IUnknown_Release is called on by-value */
5489 V_VT(&v) = VT_UNKNOWN;
5490 V_UNKNOWN(&v) = (IUnknown*)&u;
5491 hres = VariantClear(&v);
5492 ok(hres == S_OK && u.ref == 0 && V_VT(&v) == VT_EMPTY,
5493 "clear unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5494 S_OK, 0, VT_EMPTY, hres, u.ref, V_VT(&v));
5495
5496 /* But not when clearing a by-reference*/
5497 u.ref = 1;
5498 V_VT(&v) = VT_UNKNOWN|VT_BYREF;
5499 V_UNKNOWNREF(&v) = &pu;
5500 hres = VariantClear(&v);
5501 ok(hres == S_OK && u.ref == 1 && V_VT(&v) == VT_EMPTY,
5502 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5503 S_OK, 1, VT_EMPTY, hres, u.ref, V_VT(&v));
5504 }
5505
5506 static void test_IUnknownCopy(void)
5507 {
5508 HRESULT hres;
5509 VARIANTARG vSrc, vDst;
5510 DummyDispatch u = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5511 IUnknown* pu = (IUnknown*)&u;
5512
5513 /* AddRef is called on by-value copy */
5514 VariantInit(&vDst);
5515 V_VT(&vSrc) = VT_UNKNOWN;
5516 V_UNKNOWN(&vSrc) = pu;
5517 hres = VariantCopy(&vDst, &vSrc);
5518 ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
5519 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5520 S_OK, 2, VT_EMPTY, hres, u.ref, V_VT(&vDst));
5521
5522 /* AddRef is skipped on copy of by-reference IDispatch */
5523 VariantInit(&vDst);
5524 u.ref = 1;
5525 V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5526 V_UNKNOWNREF(&vSrc) = &pu;
5527 hres = VariantCopy(&vDst, &vSrc);
5528 ok(hres == S_OK && u.ref == 1 && V_VT(&vDst) == (VT_UNKNOWN|VT_BYREF),
5529 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5530 S_OK, 1, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
5531
5532 /* AddRef is called copying by-reference IDispatch with indirection */
5533 VariantInit(&vDst);
5534 u.ref = 1;
5535 V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5536 V_UNKNOWNREF(&vSrc) = &pu;
5537 hres = VariantCopyInd(&vDst, &vSrc);
5538 ok(hres == S_OK && u.ref == 2 && V_VT(&vDst) == VT_UNKNOWN,
5539 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5540 S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vDst));
5541
5542 /* Indirection in place also calls AddRef */
5543 u.ref = 1;
5544 V_VT(&vSrc) = VT_UNKNOWN|VT_BYREF;
5545 V_UNKNOWNREF(&vSrc) = &pu;
5546 hres = VariantCopyInd(&vSrc, &vSrc);
5547 ok(hres == S_OK && u.ref == 2 && V_VT(&vSrc) == VT_UNKNOWN,
5548 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5549 S_OK, 2, VT_DISPATCH, hres, u.ref, V_VT(&vSrc));
5550 }
5551
5552 static void test_IUnknownChangeTypeEx(void)
5553 {
5554 HRESULT hres;
5555 VARIANTARG vSrc, vDst;
5556 LCID lcid;
5557 VARTYPE vt;
5558 DummyDispatch u = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5559 IUnknown* pu = (IUnknown*)&u;
5560
5561 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5562
5563 V_VT(&vSrc) = VT_UNKNOWN;
5564 V_UNKNOWN(&vSrc) = pu;
5565
5566 /* =>IDispatch in place */
5567 hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_DISPATCH);
5568 ok(hres == S_OK && u.ref == 1 &&
5569 V_VT(&vSrc) == VT_DISPATCH && V_DISPATCH(&vSrc) == (IDispatch*)pu,
5570 "change unk(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5571 S_OK, 1, VT_DISPATCH, pu, hres, u.ref, V_VT(&vSrc), V_DISPATCH(&vSrc));
5572
5573 /* =>IDispatch */
5574 u.ref = 1;
5575 V_VT(&vSrc) = VT_UNKNOWN;
5576 V_UNKNOWN(&vSrc) = pu;
5577 VariantInit(&vDst);
5578 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5579 /* Note vSrc is not cleared, as final refcount is 2 */
5580 ok(hres == S_OK && u.ref == 2 &&
5581 V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == pu,
5582 "change unk(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5583 S_OK, 2, VT_UNKNOWN, pu, hres, u.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
5584
5585 /* Can't change unknown to anything else */
5586 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5587 {
5588 HRESULT hExpected = DISP_E_BADVARTYPE;
5589
5590 V_VT(&vSrc) = VT_UNKNOWN;
5591 V_UNKNOWN(&vSrc) = pu;
5592 VariantInit(&vDst);
5593
5594 if (vt == VT_UNKNOWN || vt == VT_DISPATCH || vt == VT_EMPTY || vt == VT_NULL)
5595 hExpected = S_OK;
5596 else
5597 {
5598 if (vt == VT_I8 || vt == VT_UI8)
5599 {
5600 if (HAVE_OLEAUT32_I8)
5601 hExpected = DISP_E_TYPEMISMATCH;
5602 }
5603 else if (vt == VT_RECORD)
5604 {
5605 if (HAVE_OLEAUT32_RECORD)
5606 hExpected = DISP_E_TYPEMISMATCH;
5607 }
5608 else if (vt >= VT_I2 && vt <= VT_UINT && vt != (VARTYPE)15)
5609 hExpected = DISP_E_TYPEMISMATCH;
5610 }
5611 if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5612 hExpected = DISP_E_BADVARTYPE;
5613
5614 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5615 ok(hres == hExpected,
5616 "change unk(badvar): vt %d expected 0x%08x, got 0x%08x\n",
5617 vt, hExpected, hres);
5618 }
5619 }
5620
5621 /* IDispatch */
5622 static void test_IDispatchClear(void)
5623 {
5624 HRESULT hres;
5625 VARIANTARG v;
5626 DummyDispatch d = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5627 IDispatch* pd = (IDispatch*)&d;
5628
5629 /* As per IUnknown */
5630
5631 V_VT(&v) = VT_DISPATCH;
5632 V_DISPATCH(&v) = pd;
5633 hres = VariantClear(&v);
5634 ok(hres == S_OK && d.ref == 0 && V_VT(&v) == VT_EMPTY,
5635 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5636 S_OK, 0, VT_EMPTY, hres, d.ref, V_VT(&v));
5637
5638 d.ref = 1;
5639 V_VT(&v) = VT_DISPATCH|VT_BYREF;
5640 V_DISPATCHREF(&v) = &pd;
5641 hres = VariantClear(&v);
5642 ok(hres == S_OK && d.ref == 1 && V_VT(&v) == VT_EMPTY,
5643 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5644 S_OK, 1, VT_EMPTY, hres, d.ref, V_VT(&v));
5645 }
5646
5647 static void test_IDispatchCopy(void)
5648 {
5649 HRESULT hres;
5650 VARIANTARG vSrc, vDst;
5651 DummyDispatch d = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5652 IDispatch* pd = (IDispatch*)&d;
5653
5654 /* As per IUnknown */
5655
5656 VariantInit(&vDst);
5657 V_VT(&vSrc) = VT_DISPATCH;
5658 V_DISPATCH(&vSrc) = pd;
5659 hres = VariantCopy(&vDst, &vSrc);
5660 ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
5661 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5662 S_OK, 2, VT_EMPTY, hres, d.ref, V_VT(&vDst));
5663
5664 VariantInit(&vDst);
5665 d.ref = 1;
5666 V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5667 V_DISPATCHREF(&vSrc) = &pd;
5668 hres = VariantCopy(&vDst, &vSrc);
5669 ok(hres == S_OK && d.ref == 1 && V_VT(&vDst) == (VT_DISPATCH|VT_BYREF),
5670 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5671 S_OK, 1, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
5672
5673 VariantInit(&vDst);
5674 d.ref = 1;
5675 V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5676 V_DISPATCHREF(&vSrc) = &pd;
5677 hres = VariantCopyInd(&vDst, &vSrc);
5678 ok(hres == S_OK && d.ref == 2 && V_VT(&vDst) == VT_DISPATCH,
5679 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5680 S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vDst));
5681
5682 d.ref = 1;
5683 V_VT(&vSrc) = VT_DISPATCH|VT_BYREF;
5684 V_DISPATCHREF(&vSrc) = &pd;
5685 hres = VariantCopyInd(&vSrc, &vSrc);
5686 ok(hres == S_OK && d.ref == 2 && V_VT(&vSrc) == VT_DISPATCH,
5687 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5688 S_OK, 2, VT_DISPATCH, hres, d.ref, V_VT(&vSrc));
5689 }
5690
5691 static void test_IDispatchChangeTypeEx(void)
5692 {
5693 HRESULT hres;
5694 VARIANTARG vSrc, vDst;
5695 LCID lcid;
5696 DummyDispatch d = { &DummyDispatch_VTable, 1, VT_UI1, FALSE };
5697 IDispatch* pd = (IDispatch*)&d;
5698
5699 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5700
5701 V_VT(&vSrc) = VT_DISPATCH;
5702 V_DISPATCH(&vSrc) = pd;
5703
5704 /* =>IUnknown in place */
5705 hres = VariantChangeTypeEx(&vSrc, &vSrc, lcid, 0, VT_UNKNOWN);
5706 ok(hres == S_OK && d.ref == 1 &&
5707 V_VT(&vSrc) == VT_UNKNOWN && V_UNKNOWN(&vSrc) == (IUnknown*)pd,
5708 "change disp(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5709 S_OK, 1, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vSrc), V_UNKNOWN(&vSrc));
5710
5711 /* =>IUnknown */
5712 d.ref = 1;
5713 V_VT(&vSrc) = VT_DISPATCH;
5714 V_DISPATCH(&vSrc) = pd;
5715 VariantInit(&vDst);
5716 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_UNKNOWN);
5717 /* Note vSrc is not cleared, as final refcount is 2 */
5718 ok(hres == S_OK && d.ref == 2 &&
5719 V_VT(&vDst) == VT_UNKNOWN && V_UNKNOWN(&vDst) == (IUnknown*)pd,
5720 "change disp(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5721 S_OK, 2, VT_UNKNOWN, pd, hres, d.ref, V_VT(&vDst), V_UNKNOWN(&vDst));
5722
5723 /* FIXME: Verify that VARIANT_NOVALUEPROP prevents conversion to integral
5724 * types. this requires that the xxxFromDisp tests work first.
5725 */
5726 }
5727
5728 /* VT_ERROR */
5729 static void test_ErrorChangeTypeEx(void)
5730 {
5731 HRESULT hres;
5732 VARIANTARG vSrc, vDst;
5733 VARTYPE vt;
5734 LCID lcid;
5735
5736 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5737
5738 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5739 {
5740 HRESULT hExpected = DISP_E_BADVARTYPE;
5741
5742 V_VT(&vSrc) = VT_ERROR;
5743 V_ERROR(&vSrc) = 1;
5744 VariantInit(&vDst);
5745 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5746
5747 if (vt == VT_ERROR)
5748 hExpected = S_OK;
5749 else
5750 {
5751 if (vt == VT_I8 || vt == VT_UI8)
5752 {
5753 if (HAVE_OLEAUT32_I8)
5754 hExpected = DISP_E_TYPEMISMATCH;
5755 }
5756 else if (vt == VT_RECORD)
5757 {
5758 if (HAVE_OLEAUT32_RECORD)
5759 hExpected = DISP_E_TYPEMISMATCH;
5760 }
5761 else if (vt <= VT_UINT && vt != (VARTYPE)15)
5762 hExpected = DISP_E_TYPEMISMATCH;
5763 }
5764 if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5765 hExpected = DISP_E_BADVARTYPE;
5766
5767 ok(hres == hExpected,
5768 "change err: vt %d expected 0x%08x, got 0x%08x\n", vt, hExpected, hres);
5769 }
5770 }
5771
5772 /* VT_EMPTY */
5773 static void test_EmptyChangeTypeEx(void)
5774 {
5775 HRESULT hres;
5776 VARIANTARG vSrc, vDst;
5777 VARTYPE vt;
5778 LCID lcid;
5779
5780 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5781
5782 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5783 {
5784 HRESULT hExpected = DISP_E_BADVARTYPE;
5785
5786 VariantInit(&vSrc);
5787 memset(&vDst, 0, sizeof(vDst));
5788 V_VT(&vDst) = VT_EMPTY;
5789
5790 if (vt == VT_I8 || vt == VT_UI8)
5791 {
5792 if (HAVE_OLEAUT32_I8)
5793 hExpected = S_OK;
5794 }
5795 else if (vt == VT_RECORD)
5796 {
5797 if (HAVE_OLEAUT32_RECORD)
5798 hExpected = DISP_E_TYPEMISMATCH;
5799 }
5800 else if (vt == VT_VARIANT || vt == VT_DISPATCH ||
5801 vt == VT_UNKNOWN || vt == VT_ERROR)
5802 {
5803 hExpected = DISP_E_TYPEMISMATCH;
5804 }
5805 else if (vt <= VT_UINT && vt != (VARTYPE)15)
5806 hExpected = S_OK;
5807
5808 if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5809 hExpected = DISP_E_BADVARTYPE;
5810
5811 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5812
5813 ok(hres == hExpected && (hres != S_OK || V_VT(&vDst) == vt),
5814 "change empty: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
5815 vt, hExpected, hres, V_VT(&vDst));
5816 }
5817 }
5818
5819 /* VT_NULL */
5820 static void test_NullChangeTypeEx(void)
5821 {
5822 HRESULT hres;
5823 VARIANTARG vSrc, vDst;
5824 VARTYPE vt;
5825 LCID lcid;
5826
5827 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5828
5829 for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
5830 {
5831 HRESULT hExpected = DISP_E_BADVARTYPE;
5832
5833 VariantInit(&vSrc);
5834 V_VT(&vSrc) = VT_NULL;
5835 memset(&vDst, 0, sizeof(vDst));
5836 V_VT(&vDst) = VT_EMPTY;
5837
5838 if (vt == VT_I8 || vt == VT_UI8)
5839 {
5840 if (HAVE_OLEAUT32_I8)
5841 hExpected = DISP_E_TYPEMISMATCH;
5842 }
5843 else if (vt == VT_RECORD)
5844 {
5845 if (HAVE_OLEAUT32_RECORD)
5846 hExpected = DISP_E_TYPEMISMATCH;
5847 }
5848 else if (vt == VT_NULL)
5849 {
5850 hExpected = S_OK;
5851 }
5852 else if (vt == VT_VARIANT || vt == VT_DISPATCH ||
5853 vt == VT_UNKNOWN || vt == VT_ERROR ||
5854 (vt <= VT_UINT && vt != (VARTYPE)15))
5855 hExpected = DISP_E_TYPEMISMATCH;
5856
5857 if (IS_ANCIENT && IS_MODERN_VTYPE(vt))
5858 hExpected = DISP_E_BADVARTYPE;
5859
5860 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, vt);
5861
5862 ok(hres == hExpected && (hres != S_OK || V_VT(&vDst) == vt),
5863 "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
5864 vt, hExpected, hres, V_VT(&vDst));
5865 }
5866 }
5867
5868
5869 /* VT_UINT */
5870 static void test_UintChangeTypeEx(void)
5871 {
5872 HRESULT hres;
5873 VARIANTARG vSrc, vDst;
5874 LCID lcid;
5875
5876 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
5877
5878 /* Converting a VT_UINT to a VT_INT does not check for overflow */
5879 V_VT(&vDst) = VT_EMPTY;
5880 V_VT(&vSrc) = VT_UINT;
5881 V_UI4(&vSrc) = -1;
5882 hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, 0, VT_I4);
5883 ok(hres == S_OK && V_VT(&vDst) == VT_I4 && V_I4(&vDst) == -1,
5884 "change uint: Expected %d,0x%08x,%d got %d,0x%08x,%d\n",
5885 VT_I4, S_OK, -1, V_VT(&vDst), hres, V_I4(&vDst));
5886 }
5887
5888 #define NUM_CUST_ITEMS 16
5889
5890 static void test_ClearCustData(void)
5891 {
5892 CUSTDATA ci;
5893 unsigned i;
5894
5895 CHECKPTR(ClearCustData);
5896
5897 ci.cCustData = NUM_CUST_ITEMS;
5898 ci.prgCustData = CoTaskMemAlloc( sizeof(CUSTDATAITEM) * NUM_CUST_ITEMS );
5899 for (i = 0; i < NUM_CUST_ITEMS; i++)
5900 VariantInit(&ci.prgCustData[i].varValue);
5901 pClearCustData(&ci);
5902 ok(!ci.cCustData && !ci.prgCustData, "ClearCustData didn't clear fields!\n");
5903 }
5904
5905 static void test_NullByRef(void)
5906 {
5907 VARIANT v1, v2;
5908 HRESULT hRes;
5909
5910 VariantInit(&v1);
5911 VariantInit(&v2);
5912 V_VT(&v1) = VT_BYREF|VT_VARIANT;
5913 V_BYREF(&v1) = 0;
5914
5915 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_I4);
5916 ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5917
5918 VariantClear(&v1);
5919 V_VT(&v1) = VT_BYREF|VT_VARIANT;
5920 V_BYREF(&v1) = 0;
5921 V_VT(&v2) = VT_I4;
5922 V_I4(&v2) = 123;
5923
5924 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_VARIANT);
5925 ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5926 ok(V_VT(&v2) == VT_I4 && V_I4(&v2) == 123, "VariantChangeTypeEx shouldn't change pvargDest\n");
5927
5928 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_BYREF|VT_I4);
5929 ok(hRes == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
5930
5931 hRes = VariantChangeTypeEx(&v2, &v1, 0, 0, 0x3847);
5932 ok(hRes == DISP_E_BADVARTYPE, "VariantChangeTypeEx should return DISP_E_BADVARTYPE\n");
5933 }
5934
5935 /* Dst Variant should remain unchanged if VariantChangeType cannot convert */
5936 static void test_ChangeType_keep_dst(void)
5937 {
5938 VARIANT v1, v2;
5939 BSTR bstr;
5940 static const WCHAR testW[] = {'t','e','s','t',0};
5941 HRESULT hres;
5942
5943 bstr = SysAllocString(testW);
5944 VariantInit(&v1);
5945 VariantInit(&v2);
5946 V_VT(&v1) = VT_BSTR;
5947 V_BSTR(&v1) = bstr;
5948 hres = VariantChangeTypeEx(&v1, &v1, 0, 0, VT_INT);
5949 ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
5950 ok(V_VT(&v1) == VT_BSTR && V_BSTR(&v1) == bstr, "VariantChangeTypeEx changed dst variant\n");
5951 V_VT(&v2) = VT_INT;
5952 V_INT(&v2) = 4;
5953 hres = VariantChangeTypeEx(&v2, &v1, 0, 0, VT_INT);
5954 ok(hres == DISP_E_TYPEMISMATCH, "VariantChangeTypeEx returns %08x\n", hres);
5955 ok(V_VT(&v2) == VT_INT && V_INT(&v2) == 4, "VariantChangeTypeEx changed dst variant\n");
5956 SysFreeString(bstr);
5957 }
5958
5959 START_TEST(vartype)
5960 {
5961 hOleaut32 = GetModuleHandleA("oleaut32.dll");
5962
5963 trace("LCID's: System=0x%08x, User=0x%08x\n", GetSystemDefaultLCID(),
5964 GetUserDefaultLCID());
5965
5966 test_VarI1FromI2();
5967 test_VarI1FromI4();
5968 test_VarI1FromI8();
5969 test_VarI1FromUI1();
5970 test_VarI1FromUI2();
5971 test_VarI1FromUI4();
5972 test_VarI1FromUI8();
5973 test_VarI1FromBool();
5974 test_VarI1FromR4();
5975 test_VarI1FromR8();
5976 test_VarI1FromDate();
5977 test_VarI1FromCy();
5978 test_VarI1FromDec();
5979 test_VarI1FromStr();
5980 test_VarUI1FromDisp();
5981 test_VarI1Copy();
5982 test_VarI1ChangeTypeEx();
5983
5984 test_VarUI1FromI1();
5985 test_VarUI1FromI2();
5986 test_VarUI1FromI4();
5987 test_VarUI1FromI8();
5988 test_VarUI1FromUI2();
5989 test_VarUI1FromUI4();
5990 test_VarUI1FromUI8();
5991 test_VarUI1FromBool();
5992 test_VarUI1FromR4();
5993 test_VarUI1FromR8();
5994 test_VarUI1FromDate();
5995 test_VarUI1FromCy();
5996 test_VarUI1FromDec();
5997 test_VarUI1FromStr();
5998 test_VarUI1Copy();
5999 test_VarUI1ChangeTypeEx();
6000
6001 test_VarI2FromI1();
6002 test_VarI2FromI4();
6003 test_VarI2FromI8();
6004 test_VarI2FromUI1();
6005 test_VarI2FromUI2();
6006 test_VarI2FromUI4();
6007 test_VarI2FromUI8();
6008 test_VarI2FromBool();
6009 test_VarI2FromR4();
6010 test_VarI2FromR8();
6011 test_VarI2FromDate();
6012 test_VarI2FromCy();
6013 test_VarI2FromDec();
6014 test_VarI2FromStr();
6015 test_VarI2Copy();
6016 test_VarI2ChangeTypeEx();
6017
6018 test_VarUI2FromI1();
6019 test_VarUI2FromI2();
6020 test_VarUI2FromI4();
6021 test_VarUI2FromI8();
6022 test_VarUI2FromUI1();
6023 test_VarUI2FromUI4();
6024 test_VarUI2FromUI8();
6025 test_VarUI2FromBool();
6026 test_VarUI2FromR4();
6027 test_VarUI2FromR8();
6028 test_VarUI2FromDate();
6029 test_VarUI2FromCy();
6030 test_VarUI2FromDec();
6031 test_VarUI2FromStr();
6032 test_VarUI2Copy();
6033 test_VarUI2ChangeTypeEx();
6034
6035 test_VarI4FromI1();
6036 test_VarI4FromI2();
6037 test_VarI4FromI8();
6038 test_VarI4FromUI1();
6039 test_VarI4FromUI2();
6040 test_VarI4FromUI4();
6041 test_VarI4FromUI8();
6042 test_VarI4FromBool();
6043 test_VarI4FromR4();
6044 test_VarI4FromR8();
6045 test_VarI4FromDate();
6046 test_VarI4FromCy();
6047 test_VarI4FromDec();
6048 test_VarI4FromStr();
6049 test_VarI4Copy();
6050 test_VarI4ChangeTypeEx();
6051
6052 test_VarUI4FromI1();
6053 test_VarUI4FromI2();
6054 test_VarUI4FromUI2();
6055 test_VarUI4FromI8();
6056 test_VarUI4FromUI1();
6057 test_VarUI4FromI4();
6058 test_VarUI4FromUI8();
6059 test_VarUI4FromBool();
6060 test_VarUI4FromR4();
6061 test_VarUI4FromR8();
6062 test_VarUI4FromDate();
6063 test_VarUI4FromCy();
6064 test_VarUI4FromDec();
6065 test_VarUI4FromStr();
6066 test_VarUI4Copy();
6067 test_VarUI4ChangeTypeEx();
6068
6069 test_VarI8FromI1();
6070 test_VarI8FromUI1();
6071 test_VarI8FromI2();
6072 test_VarI8FromUI2();
6073 test_VarI8FromUI4();
6074 test_VarI8FromR4();
6075 test_VarI8FromR8();
6076 test_VarI8FromBool();
6077 test_VarI8FromUI8();
6078 test_VarI8FromCy();
6079 test_VarI8FromDec();
6080 test_VarI8FromDate();
6081 test_VarI8FromStr();
6082 test_VarI8Copy();
6083 test_VarI8ChangeTypeEx();
6084
6085 test_VarUI8FromI1();
6086 test_VarUI8FromUI1();
6087 test_VarUI8FromI2();
6088 test_VarUI8FromUI2();
6089 test_VarUI8FromUI4();
6090 test_VarUI8FromR4();
6091 test_VarUI8FromR8();
6092 test_VarUI8FromBool();
6093 test_VarUI8FromI8();
6094 test_VarUI8FromCy();
6095 test_VarUI8FromDec();
6096 test_VarUI8FromDate();
6097 test_VarUI8FromStr();
6098 test_VarUI8Copy();
6099 test_VarUI8ChangeTypeEx();
6100
6101 test_VarR4FromI1();
6102 test_VarR4FromUI1();
6103 test_VarR4FromI2();
6104 test_VarR4FromUI2();
6105 test_VarR4FromI4();
6106 test_VarR4FromUI4();
6107 test_VarR4FromR8();
6108 test_VarR4FromBool();
6109 test_VarR4FromCy();
6110 test_VarR4FromI8();
6111 test_VarR4FromUI8();
6112 test_VarR4FromDec();
6113 test_VarR4FromDate();
6114 test_VarR4FromStr();
6115 test_VarR4Copy();
6116 test_VarR4ChangeTypeEx();
6117
6118 test_VarR8FromI1();
6119 test_VarR8FromUI1();
6120 test_VarR8FromI2();
6121 test_VarR8FromUI2();
6122 test_VarR8FromI4();
6123 test_VarR8FromUI4();
6124 test_VarR8FromR4();
6125 test_VarR8FromBool();
6126 test_VarR8FromCy();
6127 test_VarR8FromI8();
6128 test_VarR8FromUI8();
6129 test_VarR8FromDec();
6130 test_VarR8FromDate();
6131 test_VarR8FromStr();
6132 test_VarR8Copy();
6133 test_VarR8ChangeTypeEx();
6134 test_VarR8Round();
6135
6136 test_VarDateFromI1();
6137 test_VarDateFromUI1();
6138 test_VarDateFromI2();
6139 test_VarDateFromUI2();
6140 test_VarDateFromI4();
6141 test_VarDateFromUI4();
6142 test_VarDateFromR4();
6143 test_VarDateFromR8();
6144 test_VarDateFromBool();
6145 test_VarDateFromCy();
6146 test_VarDateFromI8();
6147 test_VarDateFromUI8();
6148 test_VarDateFromDec();
6149 test_VarDateFromStr();
6150 test_VarDateCopy();
6151 test_VarDateChangeTypeEx();
6152
6153 test_VarCyFromI1();
6154 test_VarCyFromUI1();
6155 test_VarCyFromI2();
6156 test_VarCyFromUI2();
6157 test_VarCyFromI4();
6158 test_VarCyFromUI4();
6159 test_VarCyFromR4();
6160 test_VarCyFromR8();
6161 test_VarCyFromBool();
6162 test_VarCyFromI8();
6163 test_VarCyFromUI8();
6164 test_VarCyFromDec();
6165 test_VarCyFromDate();
6166
6167 test_VarCyAdd();
6168 test_VarCyMul();
6169 test_VarCySub();
6170 test_VarCyAbs();
6171 test_VarCyNeg();
6172 test_VarCyMulI4();
6173 test_VarCyMulI8();
6174 test_VarCyCmp();
6175 test_VarCyCmpR8();
6176 test_VarCyRound();
6177 test_VarCyFix();
6178 test_VarCyInt();
6179
6180 test_VarDecFromI1();
6181 test_VarDecFromI2();
6182 test_VarDecFromI4();
6183 test_VarDecFromI8();
6184 test_VarDecFromUI1();
6185 test_VarDecFromUI2();
6186 test_VarDecFromUI4();
6187 test_VarDecFromUI8();
6188 test_VarDecFromR4();
6189 test_VarDecFromR8();
6190 test_VarDecFromDate();
6191 test_VarDecFromStr();
6192 test_VarDecFromCy();
6193 test_VarDecFromDate();
6194 test_VarDecFromBool();
6195
6196 test_VarDecAbs();
6197 test_VarDecNeg();
6198 test_VarDecAdd();
6199 test_VarDecSub();
6200 test_VarDecCmp();
6201 test_VarDecMul();
6202 test_VarDecDiv();
6203
6204 test_VarBoolFromI1();
6205 test_VarBoolFromUI1();
6206 test_VarBoolFromI2();
6207 test_VarBoolFromUI2();
6208 test_VarBoolFromI4();
6209 test_VarBoolFromUI4();
6210 test_VarBoolFromR4();
6211 test_VarBoolFromR8();
6212 test_VarBoolFromCy();
6213 test_VarBoolFromI8();
6214 test_VarBoolFromUI8();
6215 test_VarBoolFromDec();
6216 test_VarBoolFromDate();
6217 test_VarBoolFromStr();
6218 test_VarBoolCopy();
6219 test_VarBoolChangeTypeEx();
6220
6221 test_VarBstrFromR4();
6222 test_VarBstrFromDate();
6223 test_VarBstrFromCy();
6224 test_VarBstrFromDec();
6225 test_VarBstrCmp();
6226 test_SysStringLen();
6227 test_SysStringByteLen();
6228 test_SysAllocString();
6229 test_SysAllocStringLen();
6230 test_SysAllocStringByteLen();
6231 test_SysReAllocString();
6232 test_SysReAllocStringLen();
6233 test_BstrCopy();
6234 test_VarBstrCat();
6235
6236 test_IUnknownClear();
6237 test_IUnknownCopy();
6238 test_IUnknownChangeTypeEx();
6239
6240 test_IDispatchClear();
6241 test_IDispatchCopy();
6242 test_IDispatchChangeTypeEx();
6243
6244 test_ErrorChangeTypeEx();
6245 test_EmptyChangeTypeEx();
6246 test_NullChangeTypeEx();
6247 test_UintChangeTypeEx();
6248
6249 test_ClearCustData();
6250
6251 test_NullByRef();
6252 test_ChangeType_keep_dst();
6253 }
an attempt at megring old patches into wine