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