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