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