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