2 * Low level variant tests
4 * Copyright 2003 Jon Griffiths
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.
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.
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
21 #define WIN32_NO_STATUS
23 #define COM_NO_WINDOWS_H
28 #include <wine/test.h>
37 DEFINE_GUID(UUID_test_struct
, 0x4029f190, 0xca4a, 0x4611, 0xae,0xb9,0x67,0x39,0x83,0xcb,0x96,0xdd);
39 /* Some Visual C++ versions choke on __uint64 to float conversions.
40 * To fix this you need either VC++ 6.0 plus the processor pack
41 * or Visual C++ >=7.0.
44 # define HAS_UINT64_TO_FLOAT
47 # define HAS_UINT64_TO_FLOAT
50 # if defined(_mm_free)
51 /* _mm_free is defined if the Processor Pack has been installed */
52 # define HAS_UINT64_TO_FLOAT
58 static HMODULE hOleaut32
;
60 /* Get a conversion function ptr, return if function not available */
61 #define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
63 win_skip("function " # func " not available, not testing it\n"); return; }
65 /* Has I8/UI8 data type? */
67 /* Has proper locale conversions? */
68 static BOOL has_locales
;
70 /* Is vt a type unavailable to ancient versions? */
71 #define IS_MODERN_VTYPE(vt) (vt==VT_VARIANT||vt==VT_DECIMAL|| \
72 vt==VT_I1||vt==VT_UI2||vt==VT_UI4||vt == VT_INT||vt == VT_UINT)
74 /* Macros for converting and testing results */
75 #define CONVVARS(typ) HRESULT hres; CONV_TYPE out; typ in
77 #define _EXPECT_NO_OUT(res) ok(hres == res, "expected " #res ", got hres=0x%08x\n", hres)
78 #define EXPECT_OVERFLOW _EXPECT_NO_OUT(DISP_E_OVERFLOW)
79 #define EXPECT_MISMATCH _EXPECT_NO_OUT(DISP_E_TYPEMISMATCH)
80 #define EXPECT_BADVAR _EXPECT_NO_OUT(DISP_E_BADVARTYPE)
81 #define EXPECT_INVALID _EXPECT_NO_OUT(E_INVALIDARG)
82 #define EXPECT_LT _EXPECT_NO_OUT(VARCMP_LT)
83 #define EXPECT_GT _EXPECT_NO_OUT(VARCMP_GT)
84 #define EXPECT_EQ _EXPECT_NO_OUT(VARCMP_EQ)
86 #define _EXPECTRES(res, x, fs) \
87 ok(hres == S_OK && out == (CONV_TYPE)(x), "expected " #x ", got " fs "; hres=0x%08x\n", out, hres)
88 #define EXPECT(x) EXPECTRES(S_OK, (x))
89 #define EXPECT_DBL(x) \
90 ok(hres == S_OK && fabs(out-(x))<=1e-14*(x), "expected %16.16g, got %16.16g; hres=0x%08x\n", (x), out, hres)
92 #define CONVERT(func, val) in = val; hres = p##func(in, &out)
93 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT(i); };
94 #define OVERFLOWRANGE(func,start,end) for (i = start; i < end; i+=1) { CONVERT(func, i); EXPECT_OVERFLOW; };
96 #define CY_MULTIPLIER 10000
98 #define DATE_MIN -657434
99 #define DATE_MAX 2958465
101 #define CONVERT_I8(func,hi,lo) in = hi; in = (in << 32) | lo; hres = p##func(in, &out)
103 #define CONVERT_CY(func,val) in.int64 = (LONGLONG)(val * CY_MULTIPLIER); hres = p##func(in, &out)
105 #define CONVERT_CY64(func,hi,lo) S(in).Hi = hi; S(in).Lo = lo; in.int64 *= CY_MULTIPLIER; hres = p##func(in, &out)
107 #define SETDEC(dec, scl, sgn, hi, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
108 dec.Hi32 = (ULONG)hi; U1(dec).Lo64 = (ULONG64)lo
110 #define SETDEC64(dec, scl, sgn, hi, mid, lo) S(U(dec)).scale = (BYTE)scl; S(U(dec)).sign = (BYTE)sgn; \
111 dec.Hi32 = (ULONG)hi; S1(U1(dec)).Mid32 = mid; S1(U1(dec)).Lo32 = lo;
113 #define CONVERT_DEC(func,scl,sgn,hi,lo) SETDEC(in,scl,sgn,hi,lo); hres = p##func(&in, &out)
115 #define CONVERT_DEC64(func,scl,sgn,hi,mid,lo) SETDEC64(in,scl,sgn,hi,mid,lo); hres = p##func(&in, &out)
117 #define CONVERT_BADDEC(func) \
118 CONVERT_DEC(func,29,0,0,0); EXPECT_INVALID; \
119 CONVERT_DEC(func,0,0x1,0,0); EXPECT_INVALID; \
120 CONVERT_DEC(func,0,0x40,0,0); EXPECT_INVALID; \
121 CONVERT_DEC(func,0,0x7f,0,0); EXPECT_INVALID;
123 #define CONVERT_STR(func,str,flags) \
125 if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
126 hres = p##func(str ? buff : NULL,in,flags,&out)
128 #define COPYTEST(val, vt, srcval, dstval, srcref, dstref, fs) do { \
129 HRESULT hres; VARIANTARG vSrc, vDst; CONV_TYPE in = val; \
130 VariantInit(&vSrc); VariantInit(&vDst); \
131 V_VT(&vSrc) = vt; srcval = in; \
132 hres = VariantCopy(&vDst, &vSrc); \
133 ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
134 "copy hres 0x%X, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
135 V_VT(&vSrc) = vt|VT_BYREF; srcref = ∈ \
136 hres = VariantCopy(&vDst, &vSrc); \
137 ok(hres == S_OK && V_VT(&vDst) == (vt|VT_BYREF) && dstref == &in, \
138 "ref hres 0x%X, type %d, ref (%p) %p\n", hres, V_VT(&vDst), &in, dstref); \
139 hres = VariantCopyInd(&vDst, &vSrc); \
140 ok(hres == S_OK && V_VT(&vDst) == vt && dstval == in, \
141 "ind hres 0x%X, type %d, value (" fs ") " fs "\n", hres, V_VT(&vDst), val, dstval); \
144 #define CHANGETYPEEX(typ) hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, typ)
146 #define TYPETEST(typ,res,fs) CHANGETYPEEX(typ); \
147 ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
148 "hres=0x%X, type=%d (should be %d(" #typ ")), value=" fs " (should be " fs ")\n", \
149 hres, V_VT(&vDst), typ, (CONV_TYPE)res, in);
150 #define TYPETESTI8(typ,res) CHANGETYPEEX(typ); \
151 ok(hres == S_OK && V_VT(&vDst) == typ && (CONV_TYPE)res == in, \
152 "hres=0x%X, type=%d (should be %d(" #typ ")), value=%d (should be 1)\n", \
153 hres, V_VT(&vDst), typ, (int)res);
154 #define BADVAR(typ) CHANGETYPEEX(typ); EXPECT_BADVAR
155 #define MISMATCH(typ) CHANGETYPEEX(typ); EXPECT_MISMATCH
157 #define INITIAL_TYPETEST(vt, val, fs) \
158 VariantInit(&vSrc); \
159 VariantInit(&vDst); \
162 TYPETEST(VT_I1, V_I1(&vDst), fs); \
163 TYPETEST(VT_UI2, V_UI2(&vDst), fs); \
164 TYPETEST(VT_UI4, V_UI4(&vDst), fs); \
165 TYPETEST(VT_INT, V_INT(&vDst), fs); \
166 TYPETEST(VT_UINT, V_UINT(&vDst), fs); \
167 TYPETEST(VT_UI1, V_UI1(&vDst), fs); \
168 TYPETEST(VT_I2, V_I2(&vDst), fs); \
169 TYPETEST(VT_I4, V_I4(&vDst), fs); \
170 TYPETEST(VT_R4, V_R4(&vDst), fs); \
171 TYPETEST(VT_R8, V_R8(&vDst), fs); \
172 TYPETEST(VT_DATE, V_DATE(&vDst), fs); \
175 TYPETEST(VT_I8, V_I8(&vDst), fs); \
176 TYPETEST(VT_UI8, V_UI8(&vDst), fs); \
178 #define NEGATIVE_TYPETEST(vt, val, fs, vtneg, valneg) \
180 VariantInit(&vSrc); \
181 VariantInit(&vDst); \
184 TYPETEST(vtneg, valneg(&vDst), fs);
186 #define INITIAL_TYPETESTI8(vt, val) \
187 VariantInit(&vSrc); \
188 VariantInit(&vDst); \
191 TYPETESTI8(VT_I1, V_I1(&vDst)); \
192 TYPETESTI8(VT_UI1, V_UI1(&vDst)); \
193 TYPETESTI8(VT_I2, V_I2(&vDst)); \
194 TYPETESTI8(VT_UI2, V_UI2(&vDst)); \
195 TYPETESTI8(VT_I4, V_I4(&vDst)); \
196 TYPETESTI8(VT_UI4, V_UI4(&vDst)); \
197 TYPETESTI8(VT_INT, V_INT(&vDst)); \
198 TYPETESTI8(VT_UINT, V_UINT(&vDst)); \
199 TYPETESTI8(VT_R4, V_R4(&vDst)); \
200 TYPETESTI8(VT_R8, V_R8(&vDst)); \
201 TYPETESTI8(VT_DATE, V_DATE(&vDst)); \
202 TYPETESTI8(VT_I8, V_I8(&vDst)); \
203 TYPETESTI8(VT_UI8, V_UI8(&vDst))
205 #define COMMON_TYPETEST \
206 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_BOOL); \
207 ok(hres == S_OK && V_VT(&vDst) == VT_BOOL && \
208 (V_BOOL(&vDst) == VARIANT_TRUE || (V_VT(&vSrc) == VT_BOOL && V_BOOL(&vDst) == 1)), \
209 "->VT_BOOL hres=0x%X, type=%d (should be VT_BOOL), value %d (should be VARIANT_TRUE)\n", \
210 hres, V_VT(&vDst), V_BOOL(&vDst)); \
211 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_CY); \
212 ok(hres == S_OK && V_VT(&vDst) == VT_CY && V_CY(&vDst).int64 == CY_MULTIPLIER, \
213 "->VT_CY hres=0x%X, type=%d (should be VT_CY), value (%08x,%08x) (should be CY_MULTIPLIER)\n", \
214 hres, V_VT(&vDst), S(V_CY(&vDst)).Hi, S(V_CY(&vDst)).Lo); \
215 if (V_VT(&vSrc) != VT_DATE) \
217 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_BSTR); \
218 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
219 V_BSTR(&vDst) && V_BSTR(&vDst)[0] == '1' && V_BSTR(&vDst)[1] == '\0', \
220 "->VT_BSTR hres=0x%X, type=%d (should be VT_BSTR), *bstr='%c'\n", \
221 hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?'); \
223 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_DECIMAL); \
224 ok(hres == S_OK && V_VT(&vDst) == VT_DECIMAL && \
225 S(U(V_DECIMAL(&vDst))).sign == 0 && S(U(V_DECIMAL(&vDst))).scale == 0 && \
226 V_DECIMAL(&vDst).Hi32 == 0 && U1(V_DECIMAL(&vDst)).Lo64 == (ULONGLONG)in, \
227 "->VT_DECIMAL hres=0x%X, type=%d (should be VT_DECIMAL), sign=%d, scale=%d, hi=%u, lo=(%8x %8x),\n", \
228 hres, V_VT(&vDst), S(U(V_DECIMAL(&vDst))).sign, S(U(V_DECIMAL(&vDst))).scale, \
229 V_DECIMAL(&vDst).Hi32, S1(U1(V_DECIMAL(&vDst))).Mid32, S1(U1(V_DECIMAL(&vDst))).Lo32); \
230 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_EMPTY); \
231 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)); \
232 hres = VariantChangeTypeEx(&vDst, &vSrc, 0, 0, VT_NULL); \
233 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)); \
234 MISMATCH(VT_DISPATCH); \
235 MISMATCH(VT_ERROR); \
236 MISMATCH(VT_UNKNOWN); \
237 MISMATCH(VT_VARIANT); \
238 MISMATCH(VT_RECORD); \
240 BADVAR(VT_HRESULT); \
241 BADVAR(VT_SAFEARRAY); \
243 BADVAR(VT_USERDEFINED); \
247 BADVAR(VT_INT_PTR); \
248 BADVAR(VT_UINT_PTR); \
249 BADVAR(VT_FILETIME); \
252 BADVAR(VT_STORAGE); \
253 BADVAR(VT_STREAMED_OBJECT); \
254 BADVAR(VT_STORED_OBJECT); \
255 BADVAR(VT_BLOB_OBJECT); \
260 #define DEFINE_EXPECT(func) \
261 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
263 #define SET_EXPECT(func) \
264 do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
266 #define CHECK_EXPECT2(func) \
268 ok(expect_ ##func, "unexpected call " #func "\n"); \
269 called_ ## func = TRUE; \
272 #define CHECK_EXPECT(func) \
274 CHECK_EXPECT2(func); \
275 expect_ ## func = FALSE; \
278 #define CHECK_CALLED(func) \
280 ok(called_ ## func, "expected " #func "\n"); \
281 expect_ ## func = called_ ## func = FALSE; \
284 DEFINE_EXPECT(dispatch_invoke
);
286 /* Early versions of oleaut32 are missing many functions */
287 static HRESULT (WINAPI
*pVarI1FromUI1
)(BYTE
,signed char*);
288 static HRESULT (WINAPI
*pVarI1FromI2
)(SHORT
,signed char*);
289 static HRESULT (WINAPI
*pVarI1FromI4
)(LONG
,signed char*);
290 static HRESULT (WINAPI
*pVarI1FromR4
)(FLOAT
,signed char*);
291 static HRESULT (WINAPI
*pVarI1FromR8
)(double,signed char*);
292 static HRESULT (WINAPI
*pVarI1FromDate
)(DATE
,signed char*);
293 static HRESULT (WINAPI
*pVarI1FromCy
)(CY
,signed char*);
294 static HRESULT (WINAPI
*pVarI1FromStr
)(OLECHAR
*,LCID
,ULONG
,signed char*);
295 static HRESULT (WINAPI
*pVarI1FromBool
)(VARIANT_BOOL
,signed char*);
296 static HRESULT (WINAPI
*pVarI1FromUI2
)(USHORT
,signed char*);
297 static HRESULT (WINAPI
*pVarI1FromUI4
)(ULONG
,signed char*);
298 static HRESULT (WINAPI
*pVarI1FromDec
)(DECIMAL
*,signed char*);
299 static HRESULT (WINAPI
*pVarI1FromI8
)(LONG64
,signed char*);
300 static HRESULT (WINAPI
*pVarI1FromUI8
)(ULONG64
,signed char*);
301 static HRESULT (WINAPI
*pVarUI1FromI2
)(SHORT
,BYTE
*);
302 static HRESULT (WINAPI
*pVarUI1FromI4
)(LONG
,BYTE
*);
303 static HRESULT (WINAPI
*pVarUI1FromR4
)(FLOAT
,BYTE
*);
304 static HRESULT (WINAPI
*pVarUI1FromR8
)(double,BYTE
*);
305 static HRESULT (WINAPI
*pVarUI1FromCy
)(CY
,BYTE
*);
306 static HRESULT (WINAPI
*pVarUI1FromDate
)(DATE
,BYTE
*);
307 static HRESULT (WINAPI
*pVarUI1FromStr
)(OLECHAR
*,LCID
,ULONG
,BYTE
*);
308 static HRESULT (WINAPI
*pVarUI1FromBool
)(VARIANT_BOOL
,BYTE
*);
309 static HRESULT (WINAPI
*pVarUI1FromI1
)(signed char,BYTE
*);
310 static HRESULT (WINAPI
*pVarUI1FromUI2
)(USHORT
,BYTE
*);
311 static HRESULT (WINAPI
*pVarUI1FromUI4
)(ULONG
,BYTE
*);
312 static HRESULT (WINAPI
*pVarUI1FromDec
)(DECIMAL
*,BYTE
*);
313 static HRESULT (WINAPI
*pVarUI1FromI8
)(LONG64
,BYTE
*);
314 static HRESULT (WINAPI
*pVarUI1FromUI8
)(ULONG64
,BYTE
*);
315 static HRESULT (WINAPI
*pVarUI1FromDisp
)(IDispatch
*,LCID
,BYTE
*);
317 static HRESULT (WINAPI
*pVarI2FromUI1
)(BYTE
,SHORT
*);
318 static HRESULT (WINAPI
*pVarI2FromI4
)(LONG
,SHORT
*);
319 static HRESULT (WINAPI
*pVarI2FromR4
)(FLOAT
,SHORT
*);
320 static HRESULT (WINAPI
*pVarI2FromR8
)(double,SHORT
*);
321 static HRESULT (WINAPI
*pVarI2FromCy
)(CY
,SHORT
*);
322 static HRESULT (WINAPI
*pVarI2FromDate
)(DATE
,SHORT
*);
323 static HRESULT (WINAPI
*pVarI2FromStr
)(OLECHAR
*,LCID
,ULONG
,SHORT
*);
324 static HRESULT (WINAPI
*pVarI2FromBool
)(VARIANT_BOOL
,SHORT
*);
325 static HRESULT (WINAPI
*pVarI2FromI1
)(signed char,SHORT
*);
326 static HRESULT (WINAPI
*pVarI2FromUI2
)(USHORT
,SHORT
*);
327 static HRESULT (WINAPI
*pVarI2FromUI4
)(ULONG
,SHORT
*);
328 static HRESULT (WINAPI
*pVarI2FromDec
)(DECIMAL
*,SHORT
*);
329 static HRESULT (WINAPI
*pVarI2FromI8
)(LONG64
,SHORT
*);
330 static HRESULT (WINAPI
*pVarI2FromUI8
)(ULONG64
,SHORT
*);
331 static HRESULT (WINAPI
*pVarUI2FromUI1
)(BYTE
,USHORT
*);
332 static HRESULT (WINAPI
*pVarUI2FromI2
)(SHORT
,USHORT
*);
333 static HRESULT (WINAPI
*pVarUI2FromI4
)(LONG
,USHORT
*);
334 static HRESULT (WINAPI
*pVarUI2FromR4
)(FLOAT
,USHORT
*);
335 static HRESULT (WINAPI
*pVarUI2FromR8
)(double,USHORT
*);
336 static HRESULT (WINAPI
*pVarUI2FromDate
)(DATE
,USHORT
*);
337 static HRESULT (WINAPI
*pVarUI2FromCy
)(CY
,USHORT
*);
338 static HRESULT (WINAPI
*pVarUI2FromStr
)(OLECHAR
*,LCID
,ULONG
,USHORT
*);
339 static HRESULT (WINAPI
*pVarUI2FromBool
)(VARIANT_BOOL
,USHORT
*);
340 static HRESULT (WINAPI
*pVarUI2FromI1
)(signed char,USHORT
*);
341 static HRESULT (WINAPI
*pVarUI2FromUI4
)(ULONG
,USHORT
*);
342 static HRESULT (WINAPI
*pVarUI2FromDec
)(DECIMAL
*,USHORT
*);
343 static HRESULT (WINAPI
*pVarUI2FromI8
)(LONG64
,USHORT
*);
344 static HRESULT (WINAPI
*pVarUI2FromUI8
)(ULONG64
,USHORT
*);
346 static HRESULT (WINAPI
*pVarI4FromUI1
)(BYTE
,LONG
*);
347 static HRESULT (WINAPI
*pVarI4FromI2
)(SHORT
,LONG
*);
348 static HRESULT (WINAPI
*pVarI4FromR4
)(FLOAT
,LONG
*);
349 static HRESULT (WINAPI
*pVarI4FromR8
)(DOUBLE
,LONG
*);
350 static HRESULT (WINAPI
*pVarI4FromCy
)(CY
,LONG
*);
351 static HRESULT (WINAPI
*pVarI4FromDate
)(DATE
,LONG
*);
352 static HRESULT (WINAPI
*pVarI4FromStr
)(OLECHAR
*,LCID
,ULONG
,LONG
*);
353 static HRESULT (WINAPI
*pVarI4FromBool
)(VARIANT_BOOL
,LONG
*);
354 static HRESULT (WINAPI
*pVarI4FromI1
)(signed char,LONG
*);
355 static HRESULT (WINAPI
*pVarI4FromUI2
)(USHORT
,LONG
*);
356 static HRESULT (WINAPI
*pVarI4FromUI4
)(ULONG
,LONG
*);
357 static HRESULT (WINAPI
*pVarI4FromDec
)(DECIMAL
*,LONG
*);
358 static HRESULT (WINAPI
*pVarI4FromI8
)(LONG64
,LONG
*);
359 static HRESULT (WINAPI
*pVarI4FromUI8
)(ULONG64
,LONG
*);
360 static HRESULT (WINAPI
*pVarUI4FromUI1
)(BYTE
,ULONG
*);
361 static HRESULT (WINAPI
*pVarUI4FromI2
)(SHORT
,ULONG
*);
362 static HRESULT (WINAPI
*pVarUI4FromI4
)(LONG
,ULONG
*);
363 static HRESULT (WINAPI
*pVarUI4FromR4
)(FLOAT
,ULONG
*);
364 static HRESULT (WINAPI
*pVarUI4FromR8
)(DOUBLE
,ULONG
*);
365 static HRESULT (WINAPI
*pVarUI4FromDate
)(DATE
,ULONG
*);
366 static HRESULT (WINAPI
*pVarUI4FromCy
)(CY
,ULONG
*);
367 static HRESULT (WINAPI
*pVarUI4FromStr
)(OLECHAR
*,LCID
,ULONG
,ULONG
*);
368 static HRESULT (WINAPI
*pVarUI4FromBool
)(VARIANT_BOOL
,ULONG
*);
369 static HRESULT (WINAPI
*pVarUI4FromI1
)(signed char,ULONG
*);
370 static HRESULT (WINAPI
*pVarUI4FromUI2
)(USHORT
,ULONG
*);
371 static HRESULT (WINAPI
*pVarUI4FromDec
)(DECIMAL
*,ULONG
*);
372 static HRESULT (WINAPI
*pVarUI4FromI8
)(LONG64
,ULONG
*);
373 static HRESULT (WINAPI
*pVarUI4FromUI8
)(ULONG64
,ULONG
*);
375 static HRESULT (WINAPI
*pVarI8FromUI1
)(BYTE
,LONG64
*);
376 static HRESULT (WINAPI
*pVarI8FromI2
)(SHORT
,LONG64
*);
377 static HRESULT (WINAPI
*pVarI8FromR4
)(FLOAT
,LONG64
*);
378 static HRESULT (WINAPI
*pVarI8FromR8
)(double,LONG64
*);
379 static HRESULT (WINAPI
*pVarI8FromCy
)(CY
,LONG64
*);
380 static HRESULT (WINAPI
*pVarI8FromDate
)(DATE
,LONG64
*);
381 static HRESULT (WINAPI
*pVarI8FromStr
)(OLECHAR
*,LCID
,ULONG
,LONG64
*);
382 static HRESULT (WINAPI
*pVarI8FromBool
)(VARIANT_BOOL
,LONG64
*);
383 static HRESULT (WINAPI
*pVarI8FromI1
)(signed char,LONG64
*);
384 static HRESULT (WINAPI
*pVarI8FromUI2
)(USHORT
,LONG64
*);
385 static HRESULT (WINAPI
*pVarI8FromUI4
)(ULONG
,LONG64
*);
386 static HRESULT (WINAPI
*pVarI8FromDec
)(DECIMAL
*,LONG64
*);
387 static HRESULT (WINAPI
*pVarI8FromUI8
)(ULONG64
,LONG64
*);
388 static HRESULT (WINAPI
*pVarUI8FromI8
)(LONG64
,ULONG64
*);
389 static HRESULT (WINAPI
*pVarUI8FromUI1
)(BYTE
,ULONG64
*);
390 static HRESULT (WINAPI
*pVarUI8FromI2
)(SHORT
,ULONG64
*);
391 static HRESULT (WINAPI
*pVarUI8FromR4
)(FLOAT
,ULONG64
*);
392 static HRESULT (WINAPI
*pVarUI8FromR8
)(double,ULONG64
*);
393 static HRESULT (WINAPI
*pVarUI8FromCy
)(CY
,ULONG64
*);
394 static HRESULT (WINAPI
*pVarUI8FromDate
)(DATE
,ULONG64
*);
395 static HRESULT (WINAPI
*pVarUI8FromStr
)(OLECHAR
*,LCID
,ULONG
,ULONG64
*);
396 static HRESULT (WINAPI
*pVarUI8FromBool
)(VARIANT_BOOL
,ULONG64
*);
397 static HRESULT (WINAPI
*pVarUI8FromI1
)(signed char,ULONG64
*);
398 static HRESULT (WINAPI
*pVarUI8FromUI2
)(USHORT
,ULONG64
*);
399 static HRESULT (WINAPI
*pVarUI8FromUI4
)(ULONG
,ULONG64
*);
400 static HRESULT (WINAPI
*pVarUI8FromDec
)(DECIMAL
*,ULONG64
*);
402 static HRESULT (WINAPI
*pVarR4FromUI1
)(BYTE
,float*);
403 static HRESULT (WINAPI
*pVarR4FromI2
)(SHORT
,float*);
404 static HRESULT (WINAPI
*pVarR4FromI4
)(LONG
,float*);
405 static HRESULT (WINAPI
*pVarR4FromR8
)(double,float*);
406 static HRESULT (WINAPI
*pVarR4FromCy
)(CY
,float*);
407 static HRESULT (WINAPI
*pVarR4FromDate
)(DATE
,float*);
408 static HRESULT (WINAPI
*pVarR4FromStr
)(OLECHAR
*,LCID
,ULONG
,float*);
409 static HRESULT (WINAPI
*pVarR4FromBool
)(VARIANT_BOOL
,float*);
410 static HRESULT (WINAPI
*pVarR4FromI1
)(signed char,float*);
411 static HRESULT (WINAPI
*pVarR4FromUI2
)(USHORT
,float*);
412 static HRESULT (WINAPI
*pVarR4FromUI4
)(ULONG
,float*);
413 static HRESULT (WINAPI
*pVarR4FromDec
)(DECIMAL
*,float*);
414 static HRESULT (WINAPI
*pVarR4FromI8
)(LONG64
,float*);
415 static HRESULT (WINAPI
*pVarR4FromUI8
)(ULONG64
,float*);
417 static HRESULT (WINAPI
*pVarR8FromUI1
)(BYTE
,double*);
418 static HRESULT (WINAPI
*pVarR8FromI2
)(SHORT
,double*);
419 static HRESULT (WINAPI
*pVarR8FromI4
)(LONG
,double*);
420 static HRESULT (WINAPI
*pVarR8FromR4
)(FLOAT
,double*);
421 static HRESULT (WINAPI
*pVarR8FromCy
)(CY
,double*);
422 static HRESULT (WINAPI
*pVarR8FromDate
)(DATE
,double*);
423 static HRESULT (WINAPI
*pVarR8FromStr
)(OLECHAR
*,LCID
,ULONG
,double*);
424 static HRESULT (WINAPI
*pVarR8FromBool
)(VARIANT_BOOL
,double*);
425 static HRESULT (WINAPI
*pVarR8FromI1
)(signed char,double*);
426 static HRESULT (WINAPI
*pVarR8FromUI2
)(USHORT
,double*);
427 static HRESULT (WINAPI
*pVarR8FromUI4
)(ULONG
,double*);
428 static HRESULT (WINAPI
*pVarR8FromDec
)(DECIMAL
*,double*);
429 static HRESULT (WINAPI
*pVarR8FromI8
)(LONG64
,double*);
430 static HRESULT (WINAPI
*pVarR8FromUI8
)(ULONG64
,double*);
431 static HRESULT (WINAPI
*pVarR8Round
)(double,int,double*);
433 static HRESULT (WINAPI
*pVarDateFromUI1
)(BYTE
,DATE
*);
434 static HRESULT (WINAPI
*pVarDateFromI2
)(SHORT
,DATE
*);
435 static HRESULT (WINAPI
*pVarDateFromI4
)(LONG
,DATE
*);
436 static HRESULT (WINAPI
*pVarDateFromR4
)(FLOAT
,DATE
*);
437 static HRESULT (WINAPI
*pVarDateFromCy
)(CY
,DATE
*);
438 static HRESULT (WINAPI
*pVarDateFromR8
)(double,DATE
*);
439 static HRESULT (WINAPI
*pVarDateFromStr
)(OLECHAR
*,LCID
,ULONG
,DATE
*);
440 static HRESULT (WINAPI
*pVarDateFromBool
)(VARIANT_BOOL
,DATE
*);
441 static HRESULT (WINAPI
*pVarDateFromI1
)(signed char,DATE
*);
442 static HRESULT (WINAPI
*pVarDateFromUI2
)(USHORT
,DATE
*);
443 static HRESULT (WINAPI
*pVarDateFromUI4
)(ULONG
,DATE
*);
444 static HRESULT (WINAPI
*pVarDateFromDec
)(DECIMAL
*,DATE
*);
445 static HRESULT (WINAPI
*pVarDateFromI8
)(LONG64
,DATE
*);
446 static HRESULT (WINAPI
*pVarDateFromUI8
)(ULONG64
,DATE
*);
448 static HRESULT (WINAPI
*pVarCyFromUI1
)(BYTE
,CY
*);
449 static HRESULT (WINAPI
*pVarCyFromI2
)(SHORT
,CY
*);
450 static HRESULT (WINAPI
*pVarCyFromI4
)(LONG
,CY
*);
451 static HRESULT (WINAPI
*pVarCyFromR4
)(FLOAT
,CY
*);
452 static HRESULT (WINAPI
*pVarCyFromR8
)(double,CY
*);
453 static HRESULT (WINAPI
*pVarCyFromDate
)(DATE
,CY
*);
454 static HRESULT (WINAPI
*pVarCyFromBool
)(VARIANT_BOOL
,CY
*);
455 static HRESULT (WINAPI
*pVarCyFromI1
)(signed char,CY
*);
456 static HRESULT (WINAPI
*pVarCyFromUI2
)(USHORT
,CY
*);
457 static HRESULT (WINAPI
*pVarCyFromUI4
)(ULONG
,CY
*);
458 static HRESULT (WINAPI
*pVarCyFromDec
)(DECIMAL
*,CY
*);
459 static HRESULT (WINAPI
*pVarCyFromI8
)(LONG64
,CY
*);
460 static HRESULT (WINAPI
*pVarCyFromUI8
)(ULONG64
,CY
*);
461 static HRESULT (WINAPI
*pVarCyAdd
)(const CY
,const CY
,CY
*);
462 static HRESULT (WINAPI
*pVarCyMul
)(const CY
,const CY
,CY
*);
463 static HRESULT (WINAPI
*pVarCyMulI4
)(const CY
,LONG
,CY
*);
464 static HRESULT (WINAPI
*pVarCySub
)(const CY
,const CY
,CY
*);
465 static HRESULT (WINAPI
*pVarCyAbs
)(const CY
,CY
*);
466 static HRESULT (WINAPI
*pVarCyFix
)(const CY
,CY
*);
467 static HRESULT (WINAPI
*pVarCyInt
)(const CY
,CY
*);
468 static HRESULT (WINAPI
*pVarCyNeg
)(const CY
,CY
*);
469 static HRESULT (WINAPI
*pVarCyRound
)(const CY
,int,CY
*);
470 static HRESULT (WINAPI
*pVarCyCmp
)(const CY
,const CY
);
471 static HRESULT (WINAPI
*pVarCyCmpR8
)(const CY
,double);
472 static HRESULT (WINAPI
*pVarCyMulI8
)(const CY
,LONG64
,CY
*);
474 static HRESULT (WINAPI
*pVarDecFromUI1
)(BYTE
,DECIMAL
*);
475 static HRESULT (WINAPI
*pVarDecFromI2
)(SHORT
,DECIMAL
*);
476 static HRESULT (WINAPI
*pVarDecFromI4
)(LONG
,DECIMAL
*);
477 static HRESULT (WINAPI
*pVarDecFromI8
)(LONG64
,DECIMAL
*);
478 static HRESULT (WINAPI
*pVarDecFromR4
)(FLOAT
,DECIMAL
*);
479 static HRESULT (WINAPI
*pVarDecFromR8
)(DOUBLE
,DECIMAL
*);
480 static HRESULT (WINAPI
*pVarDecFromDate
)(DATE
,DECIMAL
*);
481 static HRESULT (WINAPI
*pVarDecFromStr
)(OLECHAR
*,LCID
,ULONG
,DECIMAL
*);
482 static HRESULT (WINAPI
*pVarDecFromBool
)(VARIANT_BOOL
,DECIMAL
*);
483 static HRESULT (WINAPI
*pVarDecFromI1
)(signed char,DECIMAL
*);
484 static HRESULT (WINAPI
*pVarDecFromUI2
)(USHORT
,DECIMAL
*);
485 static HRESULT (WINAPI
*pVarDecFromUI4
)(ULONG
,DECIMAL
*);
486 static HRESULT (WINAPI
*pVarDecFromUI8
)(ULONG64
,DECIMAL
*);
487 static HRESULT (WINAPI
*pVarDecFromCy
)(CY
,DECIMAL
*);
488 static HRESULT (WINAPI
*pVarDecAbs
)(const DECIMAL
*,DECIMAL
*);
489 static HRESULT (WINAPI
*pVarDecAdd
)(const DECIMAL
*,const DECIMAL
*,DECIMAL
*);
490 static HRESULT (WINAPI
*pVarDecSub
)(const DECIMAL
*,const DECIMAL
*,DECIMAL
*);
491 static HRESULT (WINAPI
*pVarDecMul
)(const DECIMAL
*,const DECIMAL
*,DECIMAL
*);
492 static HRESULT (WINAPI
*pVarDecDiv
)(const DECIMAL
*,const DECIMAL
*,DECIMAL
*);
493 static HRESULT (WINAPI
*pVarDecCmp
)(const DECIMAL
*,const DECIMAL
*);
494 static HRESULT (WINAPI
*pVarDecCmpR8
)(const DECIMAL
*,double);
495 static HRESULT (WINAPI
*pVarDecNeg
)(const DECIMAL
*,DECIMAL
*);
496 static HRESULT (WINAPI
*pVarDecRound
)(const DECIMAL
*,int,DECIMAL
*);
498 static HRESULT (WINAPI
*pVarBoolFromUI1
)(BYTE
,VARIANT_BOOL
*);
499 static HRESULT (WINAPI
*pVarBoolFromI2
)(SHORT
,VARIANT_BOOL
*);
500 static HRESULT (WINAPI
*pVarBoolFromI4
)(LONG
,VARIANT_BOOL
*);
501 static HRESULT (WINAPI
*pVarBoolFromR4
)(FLOAT
,VARIANT_BOOL
*);
502 static HRESULT (WINAPI
*pVarBoolFromR8
)(DOUBLE
,VARIANT_BOOL
*);
503 static HRESULT (WINAPI
*pVarBoolFromDate
)(DATE
,VARIANT_BOOL
*);
504 static HRESULT (WINAPI
*pVarBoolFromCy
)(CY
,VARIANT_BOOL
*);
505 static HRESULT (WINAPI
*pVarBoolFromStr
)(OLECHAR
*,LCID
,ULONG
,VARIANT_BOOL
*);
506 static HRESULT (WINAPI
*pVarBoolFromI1
)(signed char,VARIANT_BOOL
*);
507 static HRESULT (WINAPI
*pVarBoolFromUI2
)(USHORT
,VARIANT_BOOL
*);
508 static HRESULT (WINAPI
*pVarBoolFromUI4
)(ULONG
,VARIANT_BOOL
*);
509 static HRESULT (WINAPI
*pVarBoolFromDec
)(DECIMAL
*,VARIANT_BOOL
*);
510 static HRESULT (WINAPI
*pVarBoolFromI8
)(LONG64
,VARIANT_BOOL
*);
511 static HRESULT (WINAPI
*pVarBoolFromUI8
)(ULONG64
,VARIANT_BOOL
*);
513 static HRESULT (WINAPI
*pVarBstrFromR4
)(FLOAT
,LCID
,ULONG
,BSTR
*);
514 static HRESULT (WINAPI
*pVarBstrFromDate
)(DATE
,LCID
,ULONG
,BSTR
*);
515 static HRESULT (WINAPI
*pVarBstrFromCy
)(CY
,LCID
,ULONG
,BSTR
*);
516 static HRESULT (WINAPI
*pVarBstrFromDec
)(DECIMAL
*,LCID
,ULONG
,BSTR
*);
517 static HRESULT (WINAPI
*pVarBstrCmp
)(BSTR
,BSTR
,LCID
,ULONG
);
518 static HRESULT (WINAPI
*pVarBstrCat
)(BSTR
,BSTR
,BSTR
*);
520 static INT (WINAPI
*pSystemTimeToVariantTime
)(LPSYSTEMTIME
,double*);
521 static void (WINAPI
*pClearCustData
)(LPCUSTDATA
);
523 /* Internal representation of a BSTR */
524 typedef struct tagINTERNAL_BSTR
528 } INTERNAL_BSTR
, *LPINTERNAL_BSTR
;
532 IDispatch IDispatch_iface
;
538 static inline DummyDispatch
*impl_from_IDispatch(IDispatch
*iface
)
540 return CONTAINING_RECORD(iface
, DummyDispatch
, IDispatch_iface
);
543 static ULONG WINAPI
DummyDispatch_AddRef(IDispatch
*iface
)
545 DummyDispatch
*This
= impl_from_IDispatch(iface
);
546 return InterlockedIncrement(&This
->ref
);
549 static ULONG WINAPI
DummyDispatch_Release(IDispatch
*iface
)
551 DummyDispatch
*This
= impl_from_IDispatch(iface
);
552 return InterlockedDecrement(&This
->ref
);
555 static HRESULT WINAPI
DummyDispatch_QueryInterface(IDispatch
*iface
,
561 if (IsEqualIID(riid
, &IID_IDispatch
) ||
562 IsEqualIID(riid
, &IID_IUnknown
))
565 IDispatch_AddRef(iface
);
568 return *ppvObject
? S_OK
: E_NOINTERFACE
;
571 static HRESULT WINAPI
DummyDispatch_GetTypeInfoCount(IDispatch
*iface
, UINT
*pctinfo
)
573 ok(0, "Unexpected call\n");
577 static HRESULT WINAPI
DummyDispatch_GetTypeInfo(IDispatch
*iface
, UINT tinfo
, LCID lcid
, ITypeInfo
**ti
)
579 ok(0, "Unexpected call\n");
583 static HRESULT WINAPI
DummyDispatch_GetIDsOfNames(IDispatch
*iface
, REFIID riid
, LPOLESTR
*names
,
584 UINT cnames
, LCID lcid
, DISPID
*dispid
)
586 ok(0, "Unexpected call\n");
590 static HRESULT WINAPI
DummyDispatch_Invoke(IDispatch
*iface
,
591 DISPID dispid
, REFIID riid
,
592 LCID lcid
, WORD wFlags
,
598 DummyDispatch
*This
= impl_from_IDispatch(iface
);
600 CHECK_EXPECT(dispatch_invoke
);
602 ok(dispid
== DISPID_VALUE
, "got dispid %d\n", dispid
);
603 ok(IsEqualIID(riid
, &IID_NULL
), "go riid %s\n", wine_dbgstr_guid(riid
));
604 ok(wFlags
== DISPATCH_PROPERTYGET
, "Flags wrong\n");
606 ok(params
->rgvarg
== NULL
, "got %p\n", params
->rgvarg
);
607 ok(params
->rgdispidNamedArgs
== NULL
, "got %p\n", params
->rgdispidNamedArgs
);
608 ok(params
->cArgs
== 0, "got %d\n", params
->cArgs
);
609 ok(params
->cNamedArgs
== 0, "got %d\n", params
->cNamedArgs
);
611 ok(res
!= NULL
, "got %p\n", res
);
612 ok(V_VT(res
) == VT_EMPTY
, "got %d\n", V_VT(res
));
613 ok(ei
== NULL
, "got %p\n", ei
);
614 ok(arg_err
== NULL
, "got %p\n", arg_err
);
616 if (This
->bFailInvoke
)
617 return E_OUTOFMEMORY
;
619 V_VT(res
) = This
->vt
;
620 if (This
->vt
== VT_UI1
)
623 memset(res
, 0, sizeof(*res
));
628 static const IDispatchVtbl DummyDispatch_VTable
=
630 DummyDispatch_QueryInterface
,
631 DummyDispatch_AddRef
,
632 DummyDispatch_Release
,
633 DummyDispatch_GetTypeInfoCount
,
634 DummyDispatch_GetTypeInfo
,
635 DummyDispatch_GetIDsOfNames
,
639 static void init_test_dispatch(LONG ref
, VARTYPE vt
, DummyDispatch
*dispatch
)
641 dispatch
->IDispatch_iface
.lpVtbl
= &DummyDispatch_VTable
;
644 dispatch
->bFailInvoke
= FALSE
;
652 #define CONV_TYPE signed char
654 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
656 static void test_VarI1FromI2(void)
661 CHECKPTR(VarI1FromI2
);
662 OVERFLOWRANGE(VarI1FromI2
, -32768, -128);
663 CONVERTRANGE(VarI1FromI2
, -128, 128);
664 OVERFLOWRANGE(VarI1FromI2
, 129, 32768);
667 static void test_VarI1FromI4(void)
672 CHECKPTR(VarI1FromI4
);
673 CONVERT(VarI1FromI4
, -129); EXPECT_OVERFLOW
;
674 CONVERTRANGE(VarI1FromI4
, -128, 128);
675 CONVERT(VarI1FromI4
, 128); EXPECT_OVERFLOW
;
678 static void test_VarI1FromI8(void)
683 CHECKPTR(VarI1FromI8
);
684 CONVERT(VarI1FromI8
, -129); EXPECT_OVERFLOW
;
685 CONVERTRANGE(VarI1FromI8
, -127, 128);
686 CONVERT(VarI1FromI8
, 128); EXPECT_OVERFLOW
;
689 static void test_VarI1FromUI1(void)
694 CHECKPTR(VarI1FromUI1
);
695 CONVERTRANGE(VarI1FromUI1
, 0, 127);
696 OVERFLOWRANGE(VarI1FromUI1
, 128, 255);
699 static void test_VarI1FromUI2(void)
704 CHECKPTR(VarI1FromUI2
);
705 CONVERTRANGE(VarI1FromUI2
, 0, 127);
706 OVERFLOWRANGE(VarI1FromUI2
, 128, 32768);
709 static void test_VarI1FromUI4(void)
714 CHECKPTR(VarI1FromUI4
);
715 CONVERTRANGE(VarI1FromUI4
, 0, 127);
716 CONVERT(VarI1FromUI4
, 128); EXPECT_OVERFLOW
;
719 static void test_VarI1FromUI8(void)
724 CHECKPTR(VarI1FromUI8
);
725 CONVERTRANGE(VarI1FromUI8
, 0, 127);
726 CONVERT(VarI1FromUI8
, 128); EXPECT_OVERFLOW
;
729 static void test_VarI1FromBool(void)
731 CONVVARS(VARIANT_BOOL
);
734 CHECKPTR(VarI1FromBool
);
735 /* Note that conversions from bool wrap around! */
736 CONVERT(VarI1FromBool
, -129); EXPECT(127);
737 CONVERTRANGE(VarI1FromBool
, -128, 128);
738 CONVERT(VarI1FromBool
, 128); EXPECT(-128);
741 static void test_VarI1FromR4(void)
745 CHECKPTR(VarI1FromR4
);
746 CONVERT(VarI1FromR4
, -129.0f
); EXPECT_OVERFLOW
;
747 CONVERT(VarI1FromR4
, -128.51f
); EXPECT_OVERFLOW
;
748 CONVERT(VarI1FromR4
, -128.5f
); EXPECT(-128);
749 CONVERT(VarI1FromR4
, -128.0f
); EXPECT(-128);
750 CONVERT(VarI1FromR4
, -1.0f
); EXPECT(-1);
751 CONVERT(VarI1FromR4
, 0.0f
); EXPECT(0);
752 CONVERT(VarI1FromR4
, 1.0f
); EXPECT(1);
753 CONVERT(VarI1FromR4
, 127.0f
); EXPECT(127);
754 CONVERT(VarI1FromR4
, 127.49f
); EXPECT(127);
755 CONVERT(VarI1FromR4
, 127.5f
); EXPECT_OVERFLOW
;
756 CONVERT(VarI1FromR4
, 128.0f
); EXPECT_OVERFLOW
;
758 CONVERT(VarI1FromR4
, -1.5f
); EXPECT(-2);
759 CONVERT(VarI1FromR4
, -0.6f
); EXPECT(-1);
760 CONVERT(VarI1FromR4
, -0.5f
); EXPECT(0);
761 CONVERT(VarI1FromR4
, -0.4f
); EXPECT(0);
762 CONVERT(VarI1FromR4
, 0.4f
); EXPECT(0);
763 CONVERT(VarI1FromR4
, 0.5f
); EXPECT(0);
764 CONVERT(VarI1FromR4
, 0.6f
); EXPECT(1);
765 CONVERT(VarI1FromR4
, 1.5f
); EXPECT(2);
768 static void test_VarI1FromR8(void)
772 CHECKPTR(VarI1FromR8
);
773 CONVERT(VarI1FromR8
, -129.0); EXPECT_OVERFLOW
;
774 CONVERT(VarI1FromR8
, -128.51); EXPECT_OVERFLOW
;
775 CONVERT(VarI1FromR8
, -128.5); EXPECT(-128);
776 CONVERT(VarI1FromR8
, -128.0); EXPECT(-128);
777 CONVERT(VarI1FromR8
, -1.0); EXPECT(-1);
778 CONVERT(VarI1FromR8
, 0.0); EXPECT(0);
779 CONVERT(VarI1FromR8
, 1.0); EXPECT(1);
780 CONVERT(VarI1FromR8
, 127.0); EXPECT(127);
781 CONVERT(VarI1FromR8
, 127.49); EXPECT(127);
782 CONVERT(VarI1FromR8
, 127.5); EXPECT_OVERFLOW
;
783 CONVERT(VarI1FromR8
, 128.0); EXPECT_OVERFLOW
;
785 CONVERT(VarI1FromR8
, -1.5); EXPECT(-2);
786 CONVERT(VarI1FromR8
, -0.6); EXPECT(-1);
787 CONVERT(VarI1FromR8
, -0.5); EXPECT(0);
788 CONVERT(VarI1FromR8
, -0.4); EXPECT(0);
789 CONVERT(VarI1FromR8
, 0.4); EXPECT(0);
790 CONVERT(VarI1FromR8
, 0.5); EXPECT(0);
791 CONVERT(VarI1FromR8
, 0.6); EXPECT(1);
792 CONVERT(VarI1FromR8
, 1.5); EXPECT(2);
795 static void test_VarI1FromDate(void)
799 CHECKPTR(VarI1FromDate
);
800 CONVERT(VarI1FromDate
, -129.0); EXPECT_OVERFLOW
;
801 CONVERT(VarI1FromDate
, -128.0); EXPECT(-128);
802 CONVERT(VarI1FromDate
, -1.0); EXPECT(-1);
803 CONVERT(VarI1FromDate
, 0.0); EXPECT(0);
804 CONVERT(VarI1FromDate
, 1.0); EXPECT(1);
805 CONVERT(VarI1FromDate
, 127.0); EXPECT(127);
806 CONVERT(VarI1FromDate
, 128.0); EXPECT_OVERFLOW
;
808 CONVERT(VarI1FromDate
, -1.5); EXPECT(-2);
809 CONVERT(VarI1FromDate
, -0.6); EXPECT(-1);
810 CONVERT(VarI1FromDate
, -0.5); EXPECT(0);
811 CONVERT(VarI1FromDate
, -0.4); EXPECT(0);
812 CONVERT(VarI1FromDate
, 0.4); EXPECT(0);
813 CONVERT(VarI1FromDate
, 0.5); EXPECT(0);
814 CONVERT(VarI1FromDate
, 0.6); EXPECT(1);
815 CONVERT(VarI1FromDate
, 1.5); EXPECT(2);
818 static void test_VarI1FromCy(void)
822 CHECKPTR(VarI1FromCy
);
823 CONVERT_CY(VarI1FromCy
,-129); EXPECT_OVERFLOW
;
824 CONVERT_CY(VarI1FromCy
,-128); EXPECT(128);
825 CONVERT_CY(VarI1FromCy
,-1); EXPECT(-1);
826 CONVERT_CY(VarI1FromCy
,0); EXPECT(0);
827 CONVERT_CY(VarI1FromCy
,1); EXPECT(1);
828 CONVERT_CY(VarI1FromCy
,127); EXPECT(127);
829 CONVERT_CY(VarI1FromCy
,128); EXPECT_OVERFLOW
;
831 CONVERT_CY(VarI1FromCy
,-1.5); EXPECT(-2);
832 CONVERT_CY(VarI1FromCy
,-0.6); EXPECT(-1);
833 CONVERT_CY(VarI1FromCy
,-0.5); EXPECT(0);
834 CONVERT_CY(VarI1FromCy
,-0.4); EXPECT(0);
835 CONVERT_CY(VarI1FromCy
,0.4); EXPECT(0);
836 CONVERT_CY(VarI1FromCy
,0.5); EXPECT(0);
837 CONVERT_CY(VarI1FromCy
,0.6); EXPECT(1);
838 CONVERT_CY(VarI1FromCy
,1.5); EXPECT(2);
841 static void test_VarI1FromDec(void)
845 CHECKPTR(VarI1FromDec
);
847 CONVERT_BADDEC(VarI1FromDec
);
849 CONVERT_DEC(VarI1FromDec
,0,0x80,0,129); EXPECT_OVERFLOW
;
850 CONVERT_DEC(VarI1FromDec
,0,0x80,0,128); EXPECT(-128);
851 CONVERT_DEC(VarI1FromDec
,0,0x80,0,1); EXPECT(-1);
852 CONVERT_DEC(VarI1FromDec
,0,0,0,0); EXPECT(0);
853 CONVERT_DEC(VarI1FromDec
,0,0,0,1); EXPECT(1);
854 CONVERT_DEC(VarI1FromDec
,0,0,0,127); EXPECT(127);
855 CONVERT_DEC(VarI1FromDec
,0,0,0,128); EXPECT_OVERFLOW
;
857 CONVERT_DEC(VarI1FromDec
,2,0x80,0,12800); EXPECT(-128);
858 CONVERT_DEC(VarI1FromDec
,2,0,0,12700); EXPECT(127);
861 static void test_VarI1FromStr(void)
866 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
868 CHECKPTR(VarI1FromStr
);
870 CONVERT_STR(VarI1FromStr
,NULL
, 0); EXPECT_MISMATCH
;
871 CONVERT_STR(VarI1FromStr
,"0", 0); EXPECT(0);
872 CONVERT_STR(VarI1FromStr
,"-129", 0); EXPECT_OVERFLOW
;
873 CONVERT_STR(VarI1FromStr
,"-128", 0); EXPECT(-128);
874 CONVERT_STR(VarI1FromStr
,"127", 0); EXPECT(127);
875 CONVERT_STR(VarI1FromStr
,"128", 0); EXPECT_OVERFLOW
;
877 CONVERT_STR(VarI1FromStr
,"-1.5", LOCALE_NOUSEROVERRIDE
); EXPECT(-2);
878 CONVERT_STR(VarI1FromStr
,"-0.6", LOCALE_NOUSEROVERRIDE
); EXPECT(-1);
879 CONVERT_STR(VarI1FromStr
,"-0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
880 CONVERT_STR(VarI1FromStr
,"-0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
881 CONVERT_STR(VarI1FromStr
,"0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
882 CONVERT_STR(VarI1FromStr
,"0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
883 CONVERT_STR(VarI1FromStr
,"0.6", LOCALE_NOUSEROVERRIDE
); EXPECT(1);
884 CONVERT_STR(VarI1FromStr
,"1.5", LOCALE_NOUSEROVERRIDE
); EXPECT(2);
887 static void test_VarI1Copy(void)
889 COPYTEST(1, VT_I1
, V_I1(&vSrc
), V_I1(&vDst
), V_I1REF(&vSrc
), V_I1REF(&vDst
), "%d");
892 static void test_VarI1ChangeTypeEx(void)
896 VARIANTARG vSrc
, vDst
;
900 INITIAL_TYPETEST(VT_I1
, V_I1
, "%d");
902 NEGATIVE_TYPETEST(VT_I1
, V_I1
, "%d", VT_UI1
, V_UI1
);
906 #define CONV_TYPE BYTE
908 static void test_VarUI1FromI1(void)
910 CONVVARS(signed char);
913 CHECKPTR(VarUI1FromI1
);
914 OVERFLOWRANGE(VarUI1FromI1
, -128, 0);
915 CONVERTRANGE(VarUI1FromI1
, 0, 128);
918 static void test_VarUI1FromI2(void)
923 CHECKPTR(VarUI1FromI2
);
924 OVERFLOWRANGE(VarUI1FromI2
, -32768, 0);
925 CONVERTRANGE(VarUI1FromI2
, 0, 256);
926 OVERFLOWRANGE(VarUI1FromI2
, 256, 32768);
929 static void test_VarUI1FromI4(void)
934 CHECKPTR(VarUI1FromI4
);
935 CONVERT(VarUI1FromI4
, -1); EXPECT_OVERFLOW
;
936 CONVERTRANGE(VarUI1FromI4
, 0, 256);
937 CONVERT(VarUI1FromI4
, 256); EXPECT_OVERFLOW
;
940 static void test_VarUI1FromI8(void)
945 CHECKPTR(VarUI1FromI8
);
946 CONVERT(VarUI1FromI8
, -1); EXPECT_OVERFLOW
;
947 CONVERTRANGE(VarUI1FromI8
, 0, 256);
948 CONVERT(VarUI1FromI8
, 256); EXPECT_OVERFLOW
;
951 static void test_VarUI1FromUI2(void)
956 CHECKPTR(VarUI1FromUI2
);
957 CONVERTRANGE(VarUI1FromUI2
, 0, 256);
958 OVERFLOWRANGE(VarUI1FromUI2
, 256, 65536);
961 static void test_VarUI1FromUI4(void)
966 CHECKPTR(VarUI1FromUI4
);
967 CONVERTRANGE(VarUI1FromUI4
, 0, 256);
968 CONVERT(VarUI1FromUI4
, 256); EXPECT_OVERFLOW
;
971 static void test_VarUI1FromUI8(void)
976 CHECKPTR(VarUI1FromUI8
);
977 CONVERTRANGE(VarUI1FromUI8
, 0, 256);
978 CONVERT(VarUI1FromUI8
, 256); EXPECT_OVERFLOW
;
981 static void test_VarUI1FromBool(void)
983 CONVVARS(VARIANT_BOOL
);
986 CHECKPTR(VarUI1FromBool
);
987 /* Note that conversions from bool overflow! */
988 CONVERT(VarUI1FromBool
, -1); EXPECT(255);
989 CONVERTRANGE(VarUI1FromBool
, 0, 256);
990 CONVERT(VarUI1FromBool
, 256); EXPECT(0);
993 static void test_VarUI1FromR4(void)
997 CHECKPTR(VarUI1FromR4
);
998 CONVERT(VarUI1FromR4
, -1.0f
); EXPECT_OVERFLOW
;
999 CONVERT(VarUI1FromR4
, -0.51f
); EXPECT_OVERFLOW
;
1000 CONVERT(VarUI1FromR4
, -0.5f
); EXPECT(0);
1001 CONVERT(VarUI1FromR4
, 0.0f
); EXPECT(0);
1002 CONVERT(VarUI1FromR4
, 1.0f
); EXPECT(1);
1003 CONVERT(VarUI1FromR4
, 255.0f
); EXPECT(255);
1004 CONVERT(VarUI1FromR4
, 255.49f
); EXPECT(255);
1005 CONVERT(VarUI1FromR4
, 255.5f
); EXPECT_OVERFLOW
;
1006 CONVERT(VarUI1FromR4
, 256.0f
); EXPECT_OVERFLOW
;
1009 CONVERT(VarUI1FromR4
, -1.5f
); EXPECT_OVERFLOW
;
1010 CONVERT(VarUI1FromR4
, -0.6f
); EXPECT_OVERFLOW
;
1011 CONVERT(VarUI1FromR4
, -0.5f
); EXPECT(0);
1012 CONVERT(VarUI1FromR4
, -0.4f
); EXPECT(0);
1013 CONVERT(VarUI1FromR4
, 0.4f
); EXPECT(0);
1014 CONVERT(VarUI1FromR4
, 0.5f
); EXPECT(0);
1015 CONVERT(VarUI1FromR4
, 0.6f
); EXPECT(1);
1016 CONVERT(VarUI1FromR4
, 1.5f
); EXPECT(2);
1019 static void test_VarUI1FromR8(void)
1023 CHECKPTR(VarUI1FromR8
);
1024 CONVERT(VarUI1FromR8
, -1.0); EXPECT_OVERFLOW
;
1025 CONVERT(VarUI1FromR8
, -0.51); EXPECT_OVERFLOW
;
1026 CONVERT(VarUI1FromR8
, -0.5); EXPECT(0);
1027 CONVERT(VarUI1FromR8
, 0.0); EXPECT(0);
1028 CONVERT(VarUI1FromR8
, 1.0); EXPECT(1);
1029 CONVERT(VarUI1FromR8
, 255.0); EXPECT(255);
1030 CONVERT(VarUI1FromR8
, 255.49); EXPECT(255);
1031 CONVERT(VarUI1FromR8
, 255.5); EXPECT_OVERFLOW
;
1032 CONVERT(VarUI1FromR8
, 256.0); EXPECT_OVERFLOW
;
1035 CONVERT(VarUI1FromR8
, -1.5); EXPECT_OVERFLOW
;
1036 CONVERT(VarUI1FromR8
, -0.6); EXPECT_OVERFLOW
;
1037 CONVERT(VarUI1FromR8
, -0.5); EXPECT(0);
1038 CONVERT(VarUI1FromR8
, -0.4); EXPECT(0);
1039 CONVERT(VarUI1FromR8
, 0.4); EXPECT(0);
1040 CONVERT(VarUI1FromR8
, 0.5); EXPECT(0);
1041 CONVERT(VarUI1FromR8
, 0.6); EXPECT(1);
1042 CONVERT(VarUI1FromR8
, 1.5); EXPECT(2);
1045 static void test_VarUI1FromDate(void)
1049 CHECKPTR(VarUI1FromDate
);
1050 CONVERT(VarUI1FromDate
, -1.0); EXPECT_OVERFLOW
;
1051 CONVERT(VarUI1FromDate
, 0.0); EXPECT(0);
1052 CONVERT(VarUI1FromDate
, 1.0); EXPECT(1);
1053 CONVERT(VarUI1FromDate
, 255.0); EXPECT(255);
1054 CONVERT(VarUI1FromDate
, 256.0); EXPECT_OVERFLOW
;
1057 CONVERT(VarUI1FromDate
, -1.5); EXPECT_OVERFLOW
;
1058 CONVERT(VarUI1FromDate
, -0.6); EXPECT_OVERFLOW
;
1059 CONVERT(VarUI1FromDate
, -0.5); EXPECT(0);
1060 CONVERT(VarUI1FromDate
, -0.4); EXPECT(0);
1061 CONVERT(VarUI1FromDate
, 0.4); EXPECT(0);
1062 CONVERT(VarUI1FromDate
, 0.5); EXPECT(0);
1063 CONVERT(VarUI1FromDate
, 0.6); EXPECT(1);
1064 CONVERT(VarUI1FromDate
, 1.5); EXPECT(2);
1067 static void test_VarUI1FromCy(void)
1071 CHECKPTR(VarUI1FromCy
);
1072 CONVERT_CY(VarUI1FromCy
,-1); EXPECT_OVERFLOW
;
1073 CONVERT_CY(VarUI1FromCy
,0); EXPECT(0);
1074 CONVERT_CY(VarUI1FromCy
,1); EXPECT(1);
1075 CONVERT_CY(VarUI1FromCy
,255); EXPECT(255);
1076 CONVERT_CY(VarUI1FromCy
,256); EXPECT_OVERFLOW
;
1079 CONVERT_CY(VarUI1FromCy
,-1.5); EXPECT_OVERFLOW
;
1080 CONVERT_CY(VarUI1FromCy
,-0.6); EXPECT_OVERFLOW
;
1081 CONVERT_CY(VarUI1FromCy
,-0.5); EXPECT(0);
1082 CONVERT_CY(VarUI1FromCy
,-0.4); EXPECT(0);
1083 CONVERT_CY(VarUI1FromCy
,0.4); EXPECT(0);
1084 CONVERT_CY(VarUI1FromCy
,0.5); EXPECT(0);
1085 CONVERT_CY(VarUI1FromCy
,0.6); EXPECT(1);
1086 CONVERT_CY(VarUI1FromCy
,1.5); EXPECT(2);
1089 static void test_VarUI1FromDec(void)
1093 CHECKPTR(VarUI1FromDec
);
1095 CONVERT_BADDEC(VarUI1FromDec
);
1097 CONVERT_DEC(VarUI1FromDec
,0,0x80,0,1); EXPECT_OVERFLOW
;
1098 CONVERT_DEC(VarUI1FromDec
,0,0,0,0); EXPECT(0);
1099 CONVERT_DEC(VarUI1FromDec
,0,0,0,1); EXPECT(1);
1100 CONVERT_DEC(VarUI1FromDec
,0,0,0,255); EXPECT(255);
1101 CONVERT_DEC(VarUI1FromDec
,0,0,0,256); EXPECT_OVERFLOW
;
1103 CONVERT_DEC(VarUI1FromDec
,2,0x80,0,100); EXPECT_OVERFLOW
;
1104 CONVERT_DEC(VarUI1FromDec
,2,0,0,25500); EXPECT(255);
1107 static void test_VarUI1FromStr(void)
1112 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
1114 CHECKPTR(VarUI1FromStr
);
1116 CONVERT_STR(VarUI1FromStr
,NULL
, 0); EXPECT_MISMATCH
;
1117 CONVERT_STR(VarUI1FromStr
,"0", 0); EXPECT(0);
1118 CONVERT_STR(VarUI1FromStr
,"-1", 0); EXPECT_OVERFLOW
;
1119 CONVERT_STR(VarUI1FromStr
,"255", 0); EXPECT(255);
1120 CONVERT_STR(VarUI1FromStr
,"256", 0); EXPECT_OVERFLOW
;
1123 CONVERT_STR(VarUI1FromStr
,"-1.5", LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
1124 CONVERT_STR(VarUI1FromStr
,"-0.6", LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
1125 CONVERT_STR(VarUI1FromStr
,"-0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1126 CONVERT_STR(VarUI1FromStr
,"-0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1127 CONVERT_STR(VarUI1FromStr
,"0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1128 CONVERT_STR(VarUI1FromStr
,"0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1129 CONVERT_STR(VarUI1FromStr
,"0.6", LOCALE_NOUSEROVERRIDE
); EXPECT(1);
1130 CONVERT_STR(VarUI1FromStr
,"1.5", LOCALE_NOUSEROVERRIDE
); EXPECT(2);
1133 static void test_VarUI1FromDisp(void)
1135 DummyDispatch dispatch
;
1137 VARIANTARG vSrc
, vDst
;
1139 CHECKPTR(VarUI1FromDisp
);
1142 * Conversions from IDispatch should get the default 'value' property
1143 * from the IDispatch pointer and return it. The following tests this.
1144 * However, I can't get these tests to return a valid value under native
1145 * oleaut32, regardless of the value returned in response to the Invoke()
1146 * call (early versions of oleaut32 call AddRef/Release, but not Invoke.
1147 * I'm obviously missing something, as these conversions work fine
1148 * when called through VBA on an object to get its default value property.
1150 * Should this test be corrected so that it works under native it should be
1151 * generalised and the remaining types checked as well.
1153 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
1158 init_test_dispatch(1, VT_UI1
, &dispatch
);
1159 V_VT(&vSrc
) = VT_DISPATCH
;
1160 V_DISPATCH(&vSrc
) = &dispatch
.IDispatch_iface
;
1162 SET_EXPECT(dispatch_invoke
);
1164 hres
= pVarUI1FromDisp(&dispatch
.IDispatch_iface
, in
, &out
);
1165 ok(broken(hres
== DISP_E_BADVARTYPE
) || hres
== S_OK
, "got 0x%08x\n", hres
);
1166 ok(broken(out
== 10) || out
== 1, "got %d\n", out
);
1167 CHECK_CALLED(dispatch_invoke
);
1169 SET_EXPECT(dispatch_invoke
);
1170 V_VT(&vDst
) = VT_EMPTY
;
1172 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, in
, 0, VT_UI1
);
1173 ok(hres
== S_OK
, "got 0x%08x\n", hres
);
1174 ok(V_VT(&vDst
) == VT_UI1
, "got %d\n", V_VT(&vDst
));
1175 ok(V_UI1(&vDst
) == 1, "got %d\n", V_UI1(&vDst
));
1176 CHECK_CALLED(dispatch_invoke
);
1178 dispatch
.bFailInvoke
= TRUE
;
1180 SET_EXPECT(dispatch_invoke
);
1182 hres
= pVarUI1FromDisp(&dispatch
.IDispatch_iface
, in
, &out
);
1183 ok(hres
== DISP_E_TYPEMISMATCH
, "got 0x%08x\n", hres
);
1184 ok(out
== 10, "got %d\n", out
);
1185 CHECK_CALLED(dispatch_invoke
);
1187 SET_EXPECT(dispatch_invoke
);
1188 V_VT(&vDst
) = VT_EMPTY
;
1189 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, in
, 0, VT_UI1
);
1190 ok(hres
== DISP_E_TYPEMISMATCH
, "got 0x%08x\n", hres
);
1191 ok(V_VT(&vDst
) == VT_EMPTY
, "got %d\n", V_VT(&vDst
));
1192 CHECK_CALLED(dispatch_invoke
);
1195 static void test_VarUI1Copy(void)
1197 COPYTEST(1, VT_UI1
, V_UI1(&vSrc
), V_UI1(&vDst
), V_UI1REF(&vSrc
), V_UI1REF(&vDst
), "%d");
1200 static void test_VarUI1ChangeTypeEx(void)
1204 VARIANTARG vSrc
, vDst
;
1208 INITIAL_TYPETEST(VT_UI1
, V_UI1
, "%d");
1210 NEGATIVE_TYPETEST(VT_UI1
, V_UI1
, "%d", VT_I1
, V_I1
);
1218 #define CONV_TYPE SHORT
1220 static void test_VarI2FromI1(void)
1222 CONVVARS(signed char);
1225 CHECKPTR(VarI2FromI1
);
1226 CONVERTRANGE(VarI2FromI1
, -128, 128);
1229 static void test_VarI2FromI4(void)
1234 CHECKPTR(VarI2FromI4
);
1235 CONVERT(VarI2FromI4
, -32769); EXPECT_OVERFLOW
;
1236 CONVERTRANGE(VarI2FromI4
, -32768, 32768);
1237 CONVERT(VarI2FromI4
, 32768); EXPECT_OVERFLOW
;
1240 static void test_VarI2FromI8(void)
1244 CHECKPTR(VarI2FromI8
);
1245 CONVERT(VarI2FromI8
, -32769); EXPECT_OVERFLOW
;
1246 CONVERT(VarI2FromI8
, -32768); EXPECT(-32768);
1247 CONVERT(VarI2FromI8
, 32767); EXPECT(32767);
1248 CONVERT(VarI2FromI8
, 32768); EXPECT_OVERFLOW
;
1251 static void test_VarI2FromUI1(void)
1256 CHECKPTR(VarI2FromUI1
);
1257 CONVERTRANGE(VarI2FromUI1
, 0, 256);
1260 static void test_VarI2FromUI2(void)
1265 CHECKPTR(VarI2FromUI2
);
1266 CONVERTRANGE(VarI2FromUI2
, 0, 32768);
1267 CONVERT(VarI2FromUI2
, 32768); EXPECT_OVERFLOW
;
1270 static void test_VarI2FromUI4(void)
1275 CHECKPTR(VarI2FromUI4
);
1276 CONVERTRANGE(VarI2FromUI4
, 0, 32768);
1277 CONVERT(VarI2FromUI4
, 32768); EXPECT_OVERFLOW
;
1280 static void test_VarI2FromUI8(void)
1285 CHECKPTR(VarI2FromUI8
);
1286 CONVERTRANGE(VarI2FromUI8
, 0, 32768);
1287 CONVERT(VarI2FromUI8
, 32768); EXPECT_OVERFLOW
;
1290 static void test_VarI2FromBool(void)
1292 CONVVARS(VARIANT_BOOL
);
1295 CHECKPTR(VarI2FromBool
);
1296 CONVERTRANGE(VarI2FromBool
, -32768, 32768);
1299 static void test_VarI2FromR4(void)
1303 CHECKPTR(VarI2FromR4
);
1304 CONVERT(VarI2FromR4
, -32769.0f
); EXPECT_OVERFLOW
;
1305 CONVERT(VarI2FromR4
, -32768.51f
); EXPECT_OVERFLOW
;
1306 CONVERT(VarI2FromR4
, -32768.5f
); EXPECT(-32768);
1307 CONVERT(VarI2FromR4
, -32768.0f
); EXPECT(-32768);
1308 CONVERT(VarI2FromR4
, -1.0f
); EXPECT(-1);
1309 CONVERT(VarI2FromR4
, 0.0f
); EXPECT(0);
1310 CONVERT(VarI2FromR4
, 1.0f
); EXPECT(1);
1311 CONVERT(VarI2FromR4
, 32767.0f
); EXPECT(32767);
1312 CONVERT(VarI2FromR4
, 32767.49f
); EXPECT(32767);
1313 CONVERT(VarI2FromR4
, 32767.5f
); EXPECT_OVERFLOW
;
1314 CONVERT(VarI2FromR4
, 32768.0f
); EXPECT_OVERFLOW
;
1317 CONVERT(VarI2FromR4
, -1.5f
); EXPECT(-2);
1318 CONVERT(VarI2FromR4
, -0.6f
); EXPECT(-1);
1319 CONVERT(VarI2FromR4
, -0.5f
); EXPECT(0);
1320 CONVERT(VarI2FromR4
, -0.4f
); EXPECT(0);
1321 CONVERT(VarI2FromR4
, 0.4f
); EXPECT(0);
1322 CONVERT(VarI2FromR4
, 0.5f
); EXPECT(0);
1323 CONVERT(VarI2FromR4
, 0.6f
); EXPECT(1);
1324 CONVERT(VarI2FromR4
, 1.5f
); EXPECT(2);
1327 static void test_VarI2FromR8(void)
1331 CHECKPTR(VarI2FromR8
);
1332 CONVERT(VarI2FromR8
, -32769.0); EXPECT_OVERFLOW
;
1333 CONVERT(VarI2FromR8
, -32768.51); EXPECT_OVERFLOW
;
1334 CONVERT(VarI2FromR8
, -32768.5); EXPECT(-32768);
1335 CONVERT(VarI2FromR8
, -32768.0); EXPECT(-32768);
1336 CONVERT(VarI2FromR8
, -1.0); EXPECT(-1);
1337 CONVERT(VarI2FromR8
, 0.0); EXPECT(0);
1338 CONVERT(VarI2FromR8
, 1.0); EXPECT(1);
1339 CONVERT(VarI2FromR8
, 32767.0); EXPECT(32767);
1340 CONVERT(VarI2FromR8
, 32767.49); EXPECT(32767);
1341 CONVERT(VarI2FromR8
, 32767.5); EXPECT_OVERFLOW
;
1342 CONVERT(VarI2FromR8
, 32768.0); EXPECT_OVERFLOW
;
1345 CONVERT(VarI2FromR8
, -1.5); EXPECT(-2);
1346 CONVERT(VarI2FromR8
, -0.6); EXPECT(-1);
1347 CONVERT(VarI2FromR8
, -0.5); EXPECT(0);
1348 CONVERT(VarI2FromR8
, -0.4); EXPECT(0);
1349 CONVERT(VarI2FromR8
, 0.4); EXPECT(0);
1350 CONVERT(VarI2FromR8
, 0.5); EXPECT(0);
1351 CONVERT(VarI2FromR8
, 0.6); EXPECT(1);
1352 CONVERT(VarI2FromR8
, 1.5); EXPECT(2);
1355 static void test_VarI2FromDate(void)
1359 CHECKPTR(VarI2FromDate
);
1360 CONVERT(VarI2FromDate
, -32769.0); EXPECT_OVERFLOW
;
1361 CONVERT(VarI2FromDate
, -32768.0); EXPECT(-32768);
1362 CONVERT(VarI2FromDate
, -1.0); EXPECT(-1);
1363 CONVERT(VarI2FromDate
, 0.0); EXPECT(0);
1364 CONVERT(VarI2FromDate
, 1.0); EXPECT(1);
1365 CONVERT(VarI2FromDate
, 32767.0); EXPECT(32767);
1366 CONVERT(VarI2FromDate
, 32768.0); EXPECT_OVERFLOW
;
1369 CONVERT(VarI2FromDate
, -1.5); EXPECT(-2);
1370 CONVERT(VarI2FromDate
, -0.6); EXPECT(-1);
1371 CONVERT(VarI2FromDate
, -0.5); EXPECT(0);
1372 CONVERT(VarI2FromDate
, -0.4); EXPECT(0);
1373 CONVERT(VarI2FromDate
, 0.4); EXPECT(0);
1374 CONVERT(VarI2FromDate
, 0.5); EXPECT(0);
1375 CONVERT(VarI2FromDate
, 0.6); EXPECT(1);
1376 CONVERT(VarI2FromDate
, 1.5); EXPECT(2);
1379 static void test_VarI2FromCy(void)
1383 CHECKPTR(VarI2FromCy
);
1384 CONVERT_CY(VarI2FromCy
,-32769); EXPECT_OVERFLOW
;
1385 CONVERT_CY(VarI2FromCy
,-32768); EXPECT(32768);
1386 CONVERT_CY(VarI2FromCy
,-1); EXPECT(-1);
1387 CONVERT_CY(VarI2FromCy
,0); EXPECT(0);
1388 CONVERT_CY(VarI2FromCy
,1); EXPECT(1);
1389 CONVERT_CY(VarI2FromCy
,32767); EXPECT(32767);
1390 CONVERT_CY(VarI2FromCy
,32768); EXPECT_OVERFLOW
;
1393 CONVERT_CY(VarI2FromCy
,-1.5); EXPECT(-2);
1394 CONVERT_CY(VarI2FromCy
,-0.6); EXPECT(-1);
1395 CONVERT_CY(VarI2FromCy
,-0.5); EXPECT(0);
1396 CONVERT_CY(VarI2FromCy
,-0.4); EXPECT(0);
1397 CONVERT_CY(VarI2FromCy
,0.4); EXPECT(0);
1398 CONVERT_CY(VarI2FromCy
,0.5); EXPECT(0);
1399 CONVERT_CY(VarI2FromCy
,0.6); EXPECT(1);
1400 CONVERT_CY(VarI2FromCy
,1.5); EXPECT(2);
1403 static void test_VarI2FromDec(void)
1407 CHECKPTR(VarI2FromDec
);
1409 CONVERT_BADDEC(VarI2FromDec
);
1411 CONVERT_DEC(VarI2FromDec
,0,0x80,0,32769); EXPECT_OVERFLOW
;
1412 CONVERT_DEC(VarI2FromDec
,0,0x80,0,32768); EXPECT(-32768);
1413 CONVERT_DEC(VarI2FromDec
,0,0x80,0,1); EXPECT(-1);
1414 CONVERT_DEC(VarI2FromDec
,0,0,0,0); EXPECT(0);
1415 CONVERT_DEC(VarI2FromDec
,0,0,0,1); EXPECT(1);
1416 CONVERT_DEC(VarI2FromDec
,0,0,0,32767); EXPECT(32767);
1417 CONVERT_DEC(VarI2FromDec
,0,0,0,32768); EXPECT_OVERFLOW
;
1419 CONVERT_DEC(VarI2FromDec
,2,0x80,0,3276800); EXPECT(-32768);
1420 CONVERT_DEC(VarI2FromDec
,2,0,0,3276700); EXPECT(32767);
1421 CONVERT_DEC(VarI2FromDec
,2,0,0,3276800); EXPECT_OVERFLOW
;
1424 static void test_VarI2FromStr(void)
1429 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
1431 CHECKPTR(VarI2FromStr
);
1433 CONVERT_STR(VarI2FromStr
,NULL
, 0); EXPECT_MISMATCH
;
1434 CONVERT_STR(VarI2FromStr
,"0", 0); EXPECT(0);
1435 CONVERT_STR(VarI2FromStr
,"-32769", 0); EXPECT_OVERFLOW
;
1436 CONVERT_STR(VarI2FromStr
,"-32768", 0); EXPECT(-32768);
1437 CONVERT_STR(VarI2FromStr
,"32767", 0); EXPECT(32767);
1438 CONVERT_STR(VarI2FromStr
,"32768", 0); EXPECT_OVERFLOW
;
1441 CONVERT_STR(VarI2FromStr
,"-1.5", LOCALE_NOUSEROVERRIDE
); EXPECT(-2);
1442 CONVERT_STR(VarI2FromStr
,"-0.6", LOCALE_NOUSEROVERRIDE
); EXPECT(-1);
1443 CONVERT_STR(VarI2FromStr
,"-0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1444 CONVERT_STR(VarI2FromStr
,"-0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1445 CONVERT_STR(VarI2FromStr
,"0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1446 CONVERT_STR(VarI2FromStr
,"0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1447 CONVERT_STR(VarI2FromStr
,"0.6", LOCALE_NOUSEROVERRIDE
); EXPECT(1);
1448 CONVERT_STR(VarI2FromStr
,"1.5", LOCALE_NOUSEROVERRIDE
); EXPECT(2);
1451 static void test_VarI2Copy(void)
1453 COPYTEST(1, VT_I2
, V_I2(&vSrc
), V_I2(&vDst
), V_I2REF(&vSrc
), V_I2REF(&vDst
), "%d");
1456 static void test_VarI2ChangeTypeEx(void)
1460 VARIANTARG vSrc
, vDst
;
1464 INITIAL_TYPETEST(VT_I2
, V_I2
, "%d");
1466 NEGATIVE_TYPETEST(VT_I2
, V_I2
, "%d", VT_UI2
, V_UI2
);
1470 #define CONV_TYPE USHORT
1472 static void test_VarUI2FromI1(void)
1474 CONVVARS(signed char);
1477 CHECKPTR(VarUI2FromI1
);
1478 OVERFLOWRANGE(VarUI2FromI1
, -128, 0);
1479 CONVERTRANGE(VarUI2FromI1
, 0, 128);
1482 static void test_VarUI2FromI2(void)
1487 CHECKPTR(VarUI2FromI2
);
1488 OVERFLOWRANGE(VarUI2FromI2
, -32768, 0);
1489 CONVERTRANGE(VarUI2FromI2
, 0, 32768);
1492 static void test_VarUI2FromI4(void)
1497 CHECKPTR(VarUI2FromI4
);
1498 OVERFLOWRANGE(VarUI2FromI4
, -32768, 0);
1499 CONVERT(VarUI2FromI4
, 0); EXPECT(0);
1500 CONVERT(VarUI2FromI4
, 65535); EXPECT(65535);
1501 CONVERT(VarUI2FromI4
, 65536); EXPECT_OVERFLOW
;
1504 static void test_VarUI2FromI8(void)
1509 CHECKPTR(VarUI2FromI8
);
1510 OVERFLOWRANGE(VarUI2FromI8
, -32768, 0);
1511 CONVERT(VarUI2FromI8
, 0); EXPECT(0);
1512 CONVERT(VarUI2FromI8
, 65535); EXPECT(65535);
1513 CONVERT(VarUI2FromI8
, 65536); EXPECT_OVERFLOW
;
1516 static void test_VarUI2FromUI1(void)
1521 CHECKPTR(VarUI2FromUI1
);
1522 CONVERTRANGE(VarUI2FromUI1
, 0, 256);
1525 static void test_VarUI2FromUI4(void)
1529 CHECKPTR(VarUI2FromUI4
);
1530 CONVERT(VarUI2FromUI4
, 0); EXPECT(0);
1531 CONVERT(VarUI2FromUI4
, 65535); EXPECT(65535);
1532 CONVERT(VarUI2FromUI4
, 65536); EXPECT_OVERFLOW
;
1535 static void test_VarUI2FromUI8(void)
1539 CHECKPTR(VarUI2FromUI8
);
1540 CONVERT(VarUI2FromUI8
, 0); EXPECT(0);
1541 CONVERT(VarUI2FromUI8
, 65535); EXPECT(65535);
1542 CONVERT(VarUI2FromUI8
, 65536); EXPECT_OVERFLOW
;
1545 static void test_VarUI2FromBool(void)
1547 CONVVARS(VARIANT_BOOL
);
1550 CHECKPTR(VarUI2FromBool
);
1551 CONVERT(VarUI2FromBool
, -1); EXPECT(65535); /* Wraps! */
1552 CONVERTRANGE(VarUI2FromBool
, 0, 32768);
1555 static void test_VarUI2FromR4(void)
1559 CHECKPTR(VarUI2FromR4
);
1560 CONVERT(VarUI2FromR4
, -1.0f
); EXPECT_OVERFLOW
;
1561 CONVERT(VarUI2FromR4
, -0.51f
); EXPECT_OVERFLOW
;
1562 CONVERT(VarUI2FromR4
, -0.5f
); EXPECT(0);
1563 CONVERT(VarUI2FromR4
, 0.0f
); EXPECT(0);
1564 CONVERT(VarUI2FromR4
, 1.0f
); EXPECT(1);
1565 CONVERT(VarUI2FromR4
, 65535.0f
); EXPECT(65535);
1566 CONVERT(VarUI2FromR4
, 65535.49f
); EXPECT(65535);
1567 CONVERT(VarUI2FromR4
, 65535.5f
); EXPECT_OVERFLOW
;
1568 CONVERT(VarUI2FromR4
, 65536.0f
); EXPECT_OVERFLOW
;
1571 CONVERT(VarUI2FromR4
, -1.5f
); EXPECT_OVERFLOW
;
1572 CONVERT(VarUI2FromR4
, -0.6f
); EXPECT_OVERFLOW
;
1573 CONVERT(VarUI2FromR4
, -0.5f
); EXPECT(0);
1574 CONVERT(VarUI2FromR4
, -0.4f
); EXPECT(0);
1575 CONVERT(VarUI2FromR4
, 0.4f
); EXPECT(0);
1576 CONVERT(VarUI2FromR4
, 0.5f
); EXPECT(0);
1577 CONVERT(VarUI2FromR4
, 0.6f
); EXPECT(1);
1578 CONVERT(VarUI2FromR4
, 1.5f
); EXPECT(2);
1581 static void test_VarUI2FromR8(void)
1585 CHECKPTR(VarUI2FromR8
);
1586 CONVERT(VarUI2FromR8
, -1.0); EXPECT_OVERFLOW
;
1587 CONVERT(VarUI2FromR8
, -0.51); EXPECT_OVERFLOW
;
1588 CONVERT(VarUI2FromR8
, -0.5); EXPECT(0);
1589 CONVERT(VarUI2FromR8
, 0.0); EXPECT(0);
1590 CONVERT(VarUI2FromR8
, 1.0); EXPECT(1);
1591 CONVERT(VarUI2FromR8
, 65535.0); EXPECT(65535);
1592 CONVERT(VarUI2FromR8
, 65535.49); EXPECT(65535);
1593 CONVERT(VarUI2FromR8
, 65535.5); EXPECT_OVERFLOW
;
1594 CONVERT(VarUI2FromR8
, 65536.0); EXPECT_OVERFLOW
;
1597 CONVERT(VarUI2FromR8
, -1.5); EXPECT_OVERFLOW
;
1598 CONVERT(VarUI2FromR8
, -0.6); EXPECT_OVERFLOW
;
1599 CONVERT(VarUI2FromR8
, -0.5); EXPECT(0);
1600 CONVERT(VarUI2FromR8
, -0.4); EXPECT(0);
1601 CONVERT(VarUI2FromR8
, 0.4); EXPECT(0);
1602 CONVERT(VarUI2FromR8
, 0.5); EXPECT(0);
1603 CONVERT(VarUI2FromR8
, 0.6); EXPECT(1);
1604 CONVERT(VarUI2FromR8
, 1.5); EXPECT(2);
1607 static void test_VarUI2FromDate(void)
1611 CHECKPTR(VarUI2FromDate
);
1612 CONVERT(VarUI2FromDate
, -1.0); EXPECT_OVERFLOW
;
1613 CONVERT(VarUI2FromDate
, 0.0); EXPECT(0);
1614 CONVERT(VarUI2FromDate
, 1.0); EXPECT(1);
1615 CONVERT(VarUI2FromDate
, 65535.0); EXPECT(65535);
1616 CONVERT(VarUI2FromDate
, 65536.0); EXPECT_OVERFLOW
;
1619 CONVERT(VarUI2FromDate
, -1.5); EXPECT_OVERFLOW
;
1620 CONVERT(VarUI2FromDate
, -0.6); EXPECT_OVERFLOW
;
1621 CONVERT(VarUI2FromDate
, -0.5); EXPECT(0);
1622 CONVERT(VarUI2FromDate
, -0.4); EXPECT(0);
1623 CONVERT(VarUI2FromDate
, 0.4); EXPECT(0);
1624 CONVERT(VarUI2FromDate
, 0.5); EXPECT(0);
1625 CONVERT(VarUI2FromDate
, 0.6); EXPECT(1);
1626 CONVERT(VarUI2FromDate
, 1.5); EXPECT(2);
1629 static void test_VarUI2FromCy(void)
1633 CHECKPTR(VarUI2FromCy
);
1634 CONVERT_CY(VarUI2FromCy
,-1); EXPECT_OVERFLOW
;
1635 CONVERT_CY(VarUI2FromCy
,0); EXPECT(0);
1636 CONVERT_CY(VarUI2FromCy
,1); EXPECT(1);
1637 CONVERT_CY(VarUI2FromCy
,65535); EXPECT(65535);
1638 CONVERT_CY(VarUI2FromCy
,65536); EXPECT_OVERFLOW
;
1641 CONVERT_CY(VarUI2FromCy
,-1.5); EXPECT_OVERFLOW
;
1642 CONVERT_CY(VarUI2FromCy
,-0.6); EXPECT_OVERFLOW
;
1643 CONVERT_CY(VarUI2FromCy
,-0.5); EXPECT(0);
1644 CONVERT_CY(VarUI2FromCy
,-0.4); EXPECT(0);
1645 CONVERT_CY(VarUI2FromCy
,0.4); EXPECT(0);
1646 CONVERT_CY(VarUI2FromCy
,0.5); EXPECT(0);
1647 CONVERT_CY(VarUI2FromCy
,0.6); EXPECT(1);
1648 CONVERT_CY(VarUI2FromCy
,1.5); EXPECT(2);
1651 static void test_VarUI2FromDec(void)
1655 CHECKPTR(VarUI2FromDec
);
1657 CONVERT_BADDEC(VarUI2FromDec
);
1659 CONVERT_DEC(VarUI2FromDec
,0,0x80,0,1); EXPECT_OVERFLOW
;
1660 CONVERT_DEC(VarUI2FromDec
,0,0,0,0); EXPECT(0);
1661 CONVERT_DEC(VarUI2FromDec
,0,0,0,1); EXPECT(1);
1662 CONVERT_DEC(VarUI2FromDec
,0,0,0,65535); EXPECT(65535);
1663 CONVERT_DEC(VarUI2FromDec
,0,0,0,65536); EXPECT_OVERFLOW
;
1665 CONVERT_DEC(VarUI2FromDec
,2,0x80,0,100); EXPECT_OVERFLOW
;
1666 CONVERT_DEC(VarUI2FromDec
,2,0,0,6553500); EXPECT(65535);
1667 CONVERT_DEC(VarUI2FromDec
,2,0,0,6553600); EXPECT_OVERFLOW
;
1670 static void test_VarUI2FromStr(void)
1675 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
1677 CHECKPTR(VarUI2FromStr
);
1679 CONVERT_STR(VarUI2FromStr
,NULL
, 0); EXPECT_MISMATCH
;
1680 CONVERT_STR(VarUI2FromStr
,"0", 0); EXPECT(0);
1681 CONVERT_STR(VarUI2FromStr
,"-1", 0); EXPECT_OVERFLOW
;
1682 CONVERT_STR(VarUI2FromStr
,"65535", 0); EXPECT(65535);
1683 CONVERT_STR(VarUI2FromStr
,"65536", 0); EXPECT_OVERFLOW
;
1686 CONVERT_STR(VarUI2FromStr
,"-1.5", LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
1687 CONVERT_STR(VarUI2FromStr
,"-0.6", LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
1688 CONVERT_STR(VarUI2FromStr
,"-0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1689 CONVERT_STR(VarUI2FromStr
,"-0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1690 CONVERT_STR(VarUI2FromStr
,"0.4", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1691 CONVERT_STR(VarUI2FromStr
,"0.5", LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1692 CONVERT_STR(VarUI2FromStr
,"0.6", LOCALE_NOUSEROVERRIDE
); EXPECT(1);
1693 CONVERT_STR(VarUI2FromStr
,"1.5", LOCALE_NOUSEROVERRIDE
); EXPECT(2);
1696 static void test_VarUI2Copy(void)
1698 COPYTEST(1, VT_UI2
, V_UI2(&vSrc
), V_UI2(&vDst
), V_UI2REF(&vSrc
), V_UI2REF(&vDst
), "%d");
1701 static void test_VarUI2ChangeTypeEx(void)
1705 VARIANTARG vSrc
, vDst
;
1709 INITIAL_TYPETEST(VT_UI2
, V_UI2
, "%d");
1711 NEGATIVE_TYPETEST(VT_UI2
, V_UI2
, "%d", VT_I2
, V_I2
);
1719 #define CONV_TYPE LONG
1721 static void test_VarI4FromI1(void)
1723 CONVVARS(signed char);
1726 CHECKPTR(VarI4FromI1
);
1727 CONVERTRANGE(VarI4FromI1
, -128, 128);
1730 static void test_VarI4FromI2(void)
1735 CHECKPTR(VarI4FromI2
);
1736 CONVERTRANGE(VarI4FromI2
, -32768, 32768);
1739 static void test_VarI4FromI8(void)
1743 CHECKPTR(VarI4FromI8
);
1744 CHECKPTR(VarI4FromDec
);
1746 CONVERT(VarI4FromI8
, -1); EXPECT(-1);
1747 CONVERT(VarI4FromI8
, 0); EXPECT(0);
1748 CONVERT(VarI4FromI8
, 1); EXPECT(1);
1750 CONVERT_I8(VarI4FromI8
, -1, 2147483647ul); EXPECT_OVERFLOW
;
1751 CONVERT_I8(VarI4FromI8
, -1, 2147483648ul); EXPECT(-2147483647 - 1);
1752 CONVERT_I8(VarI4FromI8
, 0, 2147483647ul); EXPECT(2147483647);
1753 CONVERT_I8(VarI4FromI8
, 0, 2147483648ul); EXPECT_OVERFLOW
;
1756 static void test_VarI4FromUI1(void)
1761 CHECKPTR(VarI4FromUI1
);
1762 CONVERTRANGE(VarI4FromUI1
, 0, 256);
1765 static void test_VarI4FromUI2(void)
1770 CHECKPTR(VarI4FromUI2
);
1771 CONVERTRANGE(VarI4FromUI2
, 0, 65536);
1774 static void test_VarI4FromUI4(void)
1778 CHECKPTR(VarI4FromUI4
);
1779 CONVERT(VarI4FromUI4
, 0); EXPECT(0);
1780 CONVERT(VarI4FromUI4
, 1); EXPECT(1);
1781 CONVERT(VarI4FromUI4
, 2147483647); EXPECT(2147483647);
1782 CONVERT(VarI4FromUI4
, 2147483648ul); EXPECT_OVERFLOW
;
1785 static void test_VarI4FromUI8(void)
1789 CHECKPTR(VarI4FromUI8
);
1790 CONVERT(VarI4FromUI8
, 0); EXPECT(0);
1791 CONVERT(VarI4FromUI8
, 1); EXPECT(1);
1792 CONVERT(VarI4FromUI8
, 2147483647); EXPECT(2147483647);
1793 CONVERT(VarI4FromUI8
, 2147483648ul); EXPECT_OVERFLOW
;
1796 static void test_VarI4FromBool(void)
1798 CONVVARS(VARIANT_BOOL
);
1801 CHECKPTR(VarI4FromBool
);
1802 CONVERTRANGE(VarI4FromBool
, -32768, 32768);
1805 static void test_VarI4FromR4(void)
1809 CHECKPTR(VarI4FromR4
);
1811 /* min/max values are not exactly representable in a float */
1812 CONVERT(VarI4FromR4
, -1.0f
); EXPECT(-1);
1813 CONVERT(VarI4FromR4
, 0.0f
); EXPECT(0);
1814 CONVERT(VarI4FromR4
, 1.0f
); EXPECT(1);
1816 CONVERT(VarI4FromR4
, -1.5f
); EXPECT(-2);
1817 CONVERT(VarI4FromR4
, -0.6f
); EXPECT(-1);
1818 CONVERT(VarI4FromR4
, -0.5f
); EXPECT(0);
1819 CONVERT(VarI4FromR4
, -0.4f
); EXPECT(0);
1820 CONVERT(VarI4FromR4
, 0.4f
); EXPECT(0);
1821 CONVERT(VarI4FromR4
, 0.5f
); EXPECT(0);
1822 CONVERT(VarI4FromR4
, 0.6f
); EXPECT(1);
1823 CONVERT(VarI4FromR4
, 1.5f
); EXPECT(2);
1826 static void test_VarI4FromR8(void)
1830 CHECKPTR(VarI4FromR8
);
1831 CONVERT(VarI4FromR8
, -2147483649.0); EXPECT_OVERFLOW
;
1832 CONVERT(VarI4FromR8
, -2147483648.51); EXPECT_OVERFLOW
;
1833 CONVERT(VarI4FromR8
, -2147483648.5); EXPECT(-2147483647 - 1);
1834 CONVERT(VarI4FromR8
, -2147483648.0); EXPECT(-2147483647 - 1);
1835 CONVERT(VarI4FromR8
, -1.0); EXPECT(-1);
1836 CONVERT(VarI4FromR8
, 0.0); EXPECT(0);
1837 CONVERT(VarI4FromR8
, 1.0); EXPECT(1);
1838 CONVERT(VarI4FromR8
, 2147483647.0); EXPECT(2147483647);
1839 CONVERT(VarI4FromR8
, 2147483647.49); EXPECT(2147483647);
1840 CONVERT(VarI4FromR8
, 2147483647.5); EXPECT_OVERFLOW
;
1841 CONVERT(VarI4FromR8
, 2147483648.0); EXPECT_OVERFLOW
;
1843 CONVERT(VarI4FromR8
, -1.5); EXPECT(-2);
1844 CONVERT(VarI4FromR8
, -0.6); EXPECT(-1);
1845 CONVERT(VarI4FromR8
, -0.5); EXPECT(0);
1846 CONVERT(VarI4FromR8
, -0.4); EXPECT(0);
1847 CONVERT(VarI4FromR8
, 0.4); EXPECT(0);
1848 CONVERT(VarI4FromR8
, 0.5); EXPECT(0);
1849 CONVERT(VarI4FromR8
, 0.6); EXPECT(1);
1850 CONVERT(VarI4FromR8
, 1.5); EXPECT(2);
1853 static void test_VarI4FromDate(void)
1857 CHECKPTR(VarI4FromDate
);
1858 CONVERT(VarI4FromDate
, -2147483649.0); EXPECT_OVERFLOW
;
1859 CONVERT(VarI4FromDate
, -2147483648.0); EXPECT(-2147483647 - 1);
1860 CONVERT(VarI4FromDate
, -1.0); EXPECT(-1);
1861 CONVERT(VarI4FromDate
, 0.0); EXPECT(0);
1862 CONVERT(VarI4FromDate
, 1.0); EXPECT(1);
1863 CONVERT(VarI4FromDate
, 2147483647.0); EXPECT(2147483647);
1864 CONVERT(VarI4FromDate
, 2147483648.0); EXPECT_OVERFLOW
;
1866 CONVERT(VarI4FromDate
, -1.5); EXPECT(-2);
1867 CONVERT(VarI4FromDate
, -0.6); EXPECT(-1);
1868 CONVERT(VarI4FromDate
, -0.5); EXPECT(0);
1869 CONVERT(VarI4FromDate
, -0.4); EXPECT(0);
1870 CONVERT(VarI4FromDate
, 0.4); EXPECT(0);
1871 CONVERT(VarI4FromDate
, 0.5); EXPECT(0);
1872 CONVERT(VarI4FromDate
, 0.6); EXPECT(1);
1873 CONVERT(VarI4FromDate
, 1.5); EXPECT(2);
1876 static void test_VarI4FromCy(void)
1880 CHECKPTR(VarI4FromCy
);
1881 CONVERT_CY(VarI4FromCy
,-1); EXPECT(-1);
1882 CONVERT_CY(VarI4FromCy
,0); EXPECT(0);
1883 CONVERT_CY(VarI4FromCy
,1); EXPECT(1);
1885 CONVERT_CY64(VarI4FromCy
,-1,2147483647ul); EXPECT_OVERFLOW
;
1886 CONVERT_CY64(VarI4FromCy
,-1,2147483648ul); EXPECT(-2147483647 - 1);
1887 CONVERT_CY64(VarI4FromCy
,0,2147483647ul); EXPECT(2147483647ul);
1888 CONVERT_CY64(VarI4FromCy
,0,2147483648ul); EXPECT_OVERFLOW
;
1890 CONVERT_CY(VarI4FromCy
,-1.5); EXPECT(-2);
1891 CONVERT_CY(VarI4FromCy
,-0.6); EXPECT(-1);
1892 CONVERT_CY(VarI4FromCy
,-0.5); EXPECT(0);
1893 CONVERT_CY(VarI4FromCy
,-0.4); EXPECT(0);
1894 CONVERT_CY(VarI4FromCy
,0.4); EXPECT(0);
1895 CONVERT_CY(VarI4FromCy
,0.5); EXPECT(0);
1896 CONVERT_CY(VarI4FromCy
,0.6); EXPECT(1);
1897 CONVERT_CY(VarI4FromCy
,1.5); EXPECT(2);
1900 static void test_VarI4FromDec(void)
1904 CHECKPTR(VarI4FromDec
);
1906 CONVERT_BADDEC(VarI4FromDec
);
1908 CONVERT_DEC(VarI4FromDec
,0,0x80,0,1); EXPECT(-1);
1909 CONVERT_DEC(VarI4FromDec
,0,0,0,0); EXPECT(0);
1910 CONVERT_DEC(VarI4FromDec
,0,0,0,1); EXPECT(1);
1912 CONVERT_DEC64(VarI4FromDec
,0,0x80,0,0,2147483649ul); EXPECT_OVERFLOW
;
1913 CONVERT_DEC64(VarI4FromDec
,0,0x80,0,0,2147483648ul); EXPECT(-2147483647 - 1);
1914 CONVERT_DEC64(VarI4FromDec
,0,0,0,0,2147483647ul); EXPECT(2147483647ul);
1915 CONVERT_DEC64(VarI4FromDec
,0,0,0,0,2147483648ul); EXPECT_OVERFLOW
;
1917 CONVERT_DEC64(VarI4FromDec
,2,0x80,0,50,100); EXPECT_OVERFLOW
;
1918 CONVERT_DEC64(VarI4FromDec
,2,0x80,0,50,0); EXPECT(-2147483647 - 1);
1919 CONVERT_DEC64(VarI4FromDec
,2,0,0,49,4294967196ul); EXPECT(2147483647);
1920 CONVERT_DEC64(VarI4FromDec
,2,0,0,50,0); EXPECT_OVERFLOW
;
1923 static void test_VarI4FromStr(void)
1928 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
1930 CHECKPTR(VarI4FromStr
);
1932 CONVERT_STR(VarI4FromStr
,NULL
,0); EXPECT_MISMATCH
;
1933 CONVERT_STR(VarI4FromStr
,"0",0); EXPECT(0);
1934 CONVERT_STR(VarI4FromStr
,"-2147483649",0); EXPECT_OVERFLOW
;
1935 CONVERT_STR(VarI4FromStr
,"-2147483648",0); EXPECT(-2147483647 -1);
1936 CONVERT_STR(VarI4FromStr
,"2147483647",0); EXPECT(2147483647);
1937 CONVERT_STR(VarI4FromStr
,"2147483648",0); EXPECT_OVERFLOW
;
1940 CONVERT_STR(VarI4FromStr
,"-1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(-2);
1941 CONVERT_STR(VarI4FromStr
,"-0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(-1);
1942 CONVERT_STR(VarI4FromStr
,"-0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1943 CONVERT_STR(VarI4FromStr
,"-0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1944 CONVERT_STR(VarI4FromStr
,"0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1945 CONVERT_STR(VarI4FromStr
,"0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
1946 CONVERT_STR(VarI4FromStr
,"0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(1);
1947 CONVERT_STR(VarI4FromStr
,"1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(2);
1950 static void test_VarI4Copy(void)
1952 COPYTEST(1, VT_I4
, V_I4(&vSrc
), V_I4(&vDst
), V_I4REF(&vSrc
), V_I4REF(&vDst
), "%d");
1955 static void test_VarI4ChangeTypeEx(void)
1959 VARIANTARG vSrc
, vDst
;
1963 INITIAL_TYPETEST(VT_I4
, V_I4
, "%d");
1965 NEGATIVE_TYPETEST(VT_I4
, V_I4
, "%d", VT_UI4
, V_UI4
);
1969 #define CONV_TYPE ULONG
1971 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%u")
1973 static void test_VarUI4FromI1(void)
1975 CONVVARS(signed char);
1978 CHECKPTR(VarUI4FromI1
);
1979 OVERFLOWRANGE(VarUI4FromI1
, -127, 0);
1980 CONVERTRANGE(VarUI4FromI1
, 0, 128);
1983 static void test_VarUI4FromI2(void)
1988 CHECKPTR(VarUI4FromI2
);
1989 OVERFLOWRANGE(VarUI4FromI2
, -32768, 0);
1990 CONVERTRANGE(VarUI4FromI2
, 0, 32768);
1993 static void test_VarUI4FromUI2(void)
1998 CHECKPTR(VarUI4FromUI2
);
1999 CONVERTRANGE(VarUI4FromUI2
, 0, 65536);
2002 static void test_VarUI4FromI8(void)
2006 CHECKPTR(VarUI4FromI8
);
2007 CONVERT(VarUI4FromI8
, -1); EXPECT_OVERFLOW
;
2008 CONVERT(VarUI4FromI8
, 0); EXPECT(0);
2009 CONVERT(VarUI4FromI8
, 1); EXPECT(1);
2010 CONVERT(VarUI4FromI8
, 4294967295ul); EXPECT(4294967295ul);
2011 CONVERT_I8(VarUI4FromI8
, 1, 0); EXPECT_OVERFLOW
;
2014 static void test_VarUI4FromUI1(void)
2019 CHECKPTR(VarUI4FromUI1
);
2020 CONVERTRANGE(VarUI4FromUI1
, 0, 256);
2023 static void test_VarUI4FromI4(void)
2027 CHECKPTR(VarUI4FromI4
);
2028 CONVERT(VarUI4FromI4
, -1); EXPECT_OVERFLOW
;
2029 CONVERT(VarUI4FromI4
, 0); EXPECT(0);
2030 CONVERT(VarUI4FromI4
, 1); EXPECT(1);
2031 CONVERT(VarUI4FromI4
, 2147483647); EXPECT(2147483647);
2034 static void test_VarUI4FromUI8(void)
2038 CHECKPTR(VarUI4FromUI8
);
2039 CONVERT(VarUI4FromUI8
, 0); EXPECT(0);
2040 CONVERT(VarUI4FromUI8
, 1); EXPECT(1);
2041 CONVERT(VarUI4FromI8
, 4294967295ul); EXPECT(4294967295ul);
2042 CONVERT_I8(VarUI4FromI8
, 1, 0); EXPECT_OVERFLOW
;
2045 static void test_VarUI4FromBool(void)
2047 CONVVARS(VARIANT_BOOL
);
2050 CHECKPTR(VarUI4FromBool
);
2051 CONVERTRANGE(VarUI4FromBool
, -32768, 32768);
2054 static void test_VarUI4FromR4(void)
2058 CHECKPTR(VarUI4FromR4
);
2059 /* We can't test max values as they are not exactly representable in a float */
2060 CONVERT(VarUI4FromR4
, -1.0f
); EXPECT_OVERFLOW
;
2061 CONVERT(VarUI4FromR4
, -0.51f
); EXPECT_OVERFLOW
;
2062 CONVERT(VarUI4FromR4
, -0.5f
); EXPECT(0);
2063 CONVERT(VarUI4FromR4
, 0.0f
); EXPECT(0);
2064 CONVERT(VarUI4FromR4
, 1.0f
); EXPECT(1);
2066 CONVERT(VarUI4FromR4
, -1.5f
); EXPECT_OVERFLOW
;
2067 CONVERT(VarUI4FromR4
, -0.6f
); EXPECT_OVERFLOW
;
2068 CONVERT(VarUI4FromR4
, -0.5f
); EXPECT(0);
2069 CONVERT(VarUI4FromR4
, -0.4f
); EXPECT(0);
2070 CONVERT(VarUI4FromR4
, 0.4f
); EXPECT(0);
2071 CONVERT(VarUI4FromR4
, 0.5f
); EXPECT(0);
2072 CONVERT(VarUI4FromR4
, 0.6f
); EXPECT(1);
2073 CONVERT(VarUI4FromR4
, 1.5f
); EXPECT(2);
2077 static void test_VarUI4FromR8(void)
2081 CHECKPTR(VarUI4FromR8
);
2082 CONVERT(VarUI4FromR8
, -1.0); EXPECT_OVERFLOW
;
2083 CONVERT(VarUI4FromR4
, -0.51f
); EXPECT_OVERFLOW
;
2084 CONVERT(VarUI4FromR4
, -0.5f
); EXPECT(0);
2085 CONVERT(VarUI4FromR8
, 0.0); EXPECT(0);
2086 CONVERT(VarUI4FromR8
, 1.0); EXPECT(1);
2087 CONVERT(VarUI4FromR8
, 4294967295.0); EXPECT(4294967295ul);
2088 CONVERT(VarUI4FromR8
, 4294967295.49); EXPECT(4294967295ul);
2089 CONVERT(VarUI4FromR8
, 4294967295.5); EXPECT_OVERFLOW
;
2090 CONVERT(VarUI4FromR8
, 4294967296.0); EXPECT_OVERFLOW
;
2092 CONVERT(VarUI4FromR8
, -1.5); EXPECT_OVERFLOW
;
2093 CONVERT(VarUI4FromR8
, -0.6); EXPECT_OVERFLOW
;
2094 CONVERT(VarUI4FromR8
, -0.5); EXPECT(0);
2095 CONVERT(VarUI4FromR8
, -0.4); EXPECT(0);
2096 CONVERT(VarUI4FromR8
, 0.4); EXPECT(0);
2097 CONVERT(VarUI4FromR8
, 0.5); EXPECT(0);
2098 CONVERT(VarUI4FromR8
, 0.6); EXPECT(1);
2099 CONVERT(VarUI4FromR8
, 1.5); EXPECT(2);
2102 static void test_VarUI4FromDate(void)
2106 CHECKPTR(VarUI4FromDate
);
2107 CONVERT(VarUI4FromDate
, -1.0); EXPECT_OVERFLOW
;
2108 CONVERT(VarUI4FromDate
, 0.0); EXPECT(0);
2109 CONVERT(VarUI4FromDate
, 1.0); EXPECT(1);
2110 CONVERT(VarUI4FromDate
, 4294967295.0); EXPECT(4294967295ul);
2111 CONVERT(VarUI4FromDate
, 4294967296.0); EXPECT_OVERFLOW
;
2113 CONVERT(VarUI4FromDate
, -1.5); EXPECT_OVERFLOW
;
2114 CONVERT(VarUI4FromDate
, -0.6); EXPECT_OVERFLOW
;
2115 CONVERT(VarUI4FromDate
, -0.5); EXPECT(0);
2116 CONVERT(VarUI4FromDate
, -0.4); EXPECT(0);
2117 CONVERT(VarUI4FromDate
, 0.4); EXPECT(0);
2118 CONVERT(VarUI4FromDate
, 0.5); EXPECT(0);
2119 CONVERT(VarUI4FromDate
, 0.6); EXPECT(1);
2120 CONVERT(VarUI4FromDate
, 1.5); EXPECT(2);
2123 static void test_VarUI4FromCy(void)
2127 CHECKPTR(VarUI4FromCy
);
2128 CONVERT_CY(VarUI4FromCy
,-1); EXPECT_OVERFLOW
;
2129 CONVERT_CY(VarUI4FromCy
,0); EXPECT(0);
2130 CONVERT_CY(VarUI4FromCy
,1); EXPECT(1);
2131 CONVERT_CY64(VarUI4FromCy
,0,4294967295ul); EXPECT(4294967295ul);
2132 CONVERT_CY64(VarUI4FromCy
,1,0); EXPECT_OVERFLOW
;
2134 CONVERT_CY(VarUI4FromCy
,-1.5); EXPECT_OVERFLOW
;
2135 CONVERT_CY(VarUI4FromCy
,-0.6); EXPECT_OVERFLOW
;
2136 CONVERT_CY(VarUI4FromCy
,-0.5); EXPECT(0);
2137 CONVERT_CY(VarUI4FromCy
,-0.4); EXPECT(0);
2138 CONVERT_CY(VarUI4FromCy
,0.4); EXPECT(0);
2139 CONVERT_CY(VarUI4FromCy
,0.5); EXPECT(0);
2140 CONVERT_CY(VarUI4FromCy
,0.6); EXPECT(1);
2141 CONVERT_CY(VarUI4FromCy
,1.5); EXPECT(2);
2144 static void test_VarUI4FromDec(void)
2148 CHECKPTR(VarUI4FromDec
);
2150 CONVERT_BADDEC(VarUI4FromDec
);
2152 CONVERT_DEC(VarUI4FromDec
,0,0x80,0,1); EXPECT_OVERFLOW
;
2153 CONVERT_DEC(VarUI4FromDec
,0,0,0,0); EXPECT(0);
2154 CONVERT_DEC(VarUI4FromDec
,0,0,0,1); EXPECT(1);
2155 CONVERT_DEC64(VarUI4FromDec
,0,0,0,0,4294967295ul); EXPECT(4294967295ul);
2156 CONVERT_DEC64(VarUI4FromDec
,0,0,0,1,0); EXPECT_OVERFLOW
;
2158 CONVERT_DEC64(VarUI4FromDec
,2,0,0,99,4294967196ul); EXPECT(4294967295ul);
2159 CONVERT_DEC64(VarUI4FromDec
,2,0,0,100,0); EXPECT_OVERFLOW
;
2162 static void test_VarUI4FromStr(void)
2167 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
2169 CHECKPTR(VarUI4FromStr
);
2171 CONVERT_STR(VarUI4FromStr
,NULL
,0); EXPECT_MISMATCH
;
2172 CONVERT_STR(VarUI4FromStr
,"-1",0); EXPECT_OVERFLOW
;
2173 CONVERT_STR(VarUI4FromStr
,"0",0); EXPECT(0);
2174 CONVERT_STR(VarUI4FromStr
,"4294967295",0); EXPECT(4294967295ul);
2175 CONVERT_STR(VarUI4FromStr
,"4294967296",0); EXPECT_OVERFLOW
;
2178 CONVERT_STR(VarUI4FromStr
,"-1.5",LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
2179 CONVERT_STR(VarUI4FromStr
,"-0.6",LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
2180 CONVERT_STR(VarUI4FromStr
,"-0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
2181 CONVERT_STR(VarUI4FromStr
,"-0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
2182 CONVERT_STR(VarUI4FromStr
,"0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
2183 CONVERT_STR(VarUI4FromStr
,"0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(0);
2184 CONVERT_STR(VarUI4FromStr
,"0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(1);
2185 CONVERT_STR(VarUI4FromStr
,"1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(2);
2188 static void test_VarUI4Copy(void)
2190 COPYTEST(1u, VT_UI4
, V_UI4(&vSrc
), V_UI4(&vDst
), V_UI4REF(&vSrc
), V_UI4REF(&vDst
), "%u");
2193 static void test_VarUI4ChangeTypeEx(void)
2197 VARIANTARG vSrc
, vDst
;
2201 INITIAL_TYPETEST(VT_UI4
, V_UI4
, "%u");
2203 NEGATIVE_TYPETEST(VT_UI4
, V_UI4
, "%u", VT_I4
, V_I4
);
2211 #define CONV_TYPE LONG64
2213 #define EXPECTI8(x) \
2214 ok((hres == S_OK && out == (CONV_TYPE)(x)), \
2215 "expected " #x "(%u,%u), got (%u,%u); hres=0x%08x\n", \
2216 (ULONG)((LONG64)(x) >> 32), (ULONG)((x) & 0xffffffff), \
2217 (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)
2219 #define EXPECTI864(x,y) \
2220 ok(hres == S_OK && (out >> 32) == (CONV_TYPE)(x) && (out & 0xffffffff) == (CONV_TYPE)(y), \
2221 "expected " #x "(%u,%u), got (%u,%u); hres=0x%08x\n", \
2222 (ULONG)(x), (ULONG)(y), \
2223 (ULONG)(out >> 32), (ULONG)(out & 0xffffffff), hres)
2225 static void test_VarI8FromI1(void)
2227 CONVVARS(signed char);
2230 CHECKPTR(VarI8FromI1
);
2231 for (i
= -128; i
< 128; i
++)
2233 CONVERT(VarI8FromI1
,i
); EXPECTI8(i
);
2237 static void test_VarI8FromUI1(void)
2242 CHECKPTR(VarI8FromUI1
);
2243 for (i
= 0; i
< 256; i
++)
2245 CONVERT(VarI8FromUI1
,i
); EXPECTI8(i
);
2249 static void test_VarI8FromI2(void)
2254 CHECKPTR(VarI8FromI2
);
2255 for (i
= -32768; i
< 32768; i
++)
2257 CONVERT(VarI8FromI2
,i
); EXPECTI8(i
);
2261 static void test_VarI8FromUI2(void)
2266 CHECKPTR(VarI8FromUI2
);
2267 for (i
= -0; i
< 65535; i
++)
2269 CONVERT(VarI8FromUI2
,i
); EXPECTI8(i
);
2273 static void test_VarI8FromUI4(void)
2277 CHECKPTR(VarI8FromUI4
);
2278 CONVERT(VarI8FromUI4
, 0); EXPECTI8(0);
2279 CONVERT(VarI8FromUI4
, 1); EXPECTI8(1);
2280 CONVERT(VarI8FromUI4
, 4294967295ul); EXPECTI8(4294967295ul);
2283 static void test_VarI8FromR4(void)
2287 CHECKPTR(VarI8FromR4
);
2289 CONVERT(VarI8FromR4
, -128.0f
); EXPECTI8(-128);
2290 CONVERT(VarI8FromR4
, -1.0f
); EXPECTI8(-1);
2291 CONVERT(VarI8FromR4
, 0.0f
); EXPECTI8(0);
2292 CONVERT(VarI8FromR4
, 1.0f
); EXPECTI8(1);
2293 CONVERT(VarI8FromR4
, 127.0f
); EXPECTI8(127);
2295 CONVERT(VarI8FromR4
, -1.5f
); EXPECTI8(-2);
2296 CONVERT(VarI8FromR4
, -0.6f
); EXPECTI8(-1);
2297 CONVERT(VarI8FromR4
, -0.5f
); EXPECTI8(0);
2298 CONVERT(VarI8FromR4
, -0.4f
); EXPECTI8(0);
2299 CONVERT(VarI8FromR4
, 0.4f
); EXPECTI8(0);
2300 CONVERT(VarI8FromR4
, 0.5f
); EXPECTI8(0);
2301 CONVERT(VarI8FromR4
, 0.6f
); EXPECTI8(1);
2302 CONVERT(VarI8FromR4
, 1.5f
); EXPECTI8(2);
2305 static void test_VarI8FromR8(void)
2309 CHECKPTR(VarI8FromR8
);
2310 CONVERT(VarI8FromR8
, -128.0); EXPECTI8(-128);
2311 CONVERT(VarI8FromR8
, -1.0); EXPECTI8(-1);
2312 CONVERT(VarI8FromR8
, 0.0); EXPECTI8(0);
2313 CONVERT(VarI8FromR8
, 1.0); EXPECTI8(1);
2314 CONVERT(VarI8FromR8
, 127.0); EXPECTI8(127);
2316 CONVERT(VarI8FromR8
, -1.5); EXPECTI8(-2);
2317 CONVERT(VarI8FromR8
, -0.6); EXPECTI8(-1);
2318 CONVERT(VarI8FromR8
, -0.5); EXPECTI8(0);
2319 CONVERT(VarI8FromR8
, -0.4); EXPECTI8(0);
2320 CONVERT(VarI8FromR8
, 0.4); EXPECTI8(0);
2321 CONVERT(VarI8FromR8
, 0.5); EXPECTI8(0);
2322 CONVERT(VarI8FromR8
, 0.6); EXPECTI8(1);
2323 CONVERT(VarI8FromR8
, 1.5); EXPECTI8(2);
2326 static void test_VarI8FromDate(void)
2330 CHECKPTR(VarI8FromDate
);
2331 CONVERT(VarI8FromDate
, -128.0); EXPECTI8(-128);
2332 CONVERT(VarI8FromDate
, -1.0); EXPECTI8(-1);
2333 CONVERT(VarI8FromDate
, 0.0); EXPECTI8(0);
2334 CONVERT(VarI8FromDate
, 1.0); EXPECTI8(1);
2335 CONVERT(VarI8FromDate
, 127.0); EXPECTI8(127);
2337 CONVERT(VarI8FromDate
, -1.5); EXPECTI8(-2);
2338 CONVERT(VarI8FromDate
, -0.6); EXPECTI8(-1);
2339 CONVERT(VarI8FromDate
, -0.5); EXPECTI8(0);
2340 CONVERT(VarI8FromDate
, -0.4); EXPECTI8(0);
2341 CONVERT(VarI8FromDate
, 0.4); EXPECTI8(0);
2342 CONVERT(VarI8FromDate
, 0.5); EXPECTI8(0);
2343 CONVERT(VarI8FromDate
, 0.6); EXPECTI8(1);
2344 CONVERT(VarI8FromDate
, 1.5); EXPECTI8(2);
2347 static void test_VarI8FromBool(void)
2349 CONVVARS(VARIANT_BOOL
);
2352 CHECKPTR(VarI8FromBool
);
2353 for (i
= -32768; i
< 32768; i
++)
2355 CONVERT(VarI8FromBool
,i
); EXPECTI8(i
);
2359 static void test_VarI8FromUI8(void)
2363 CHECKPTR(VarI8FromUI8
);
2364 CONVERT(VarI8FromUI8
, 0); EXPECTI8(0);
2365 CONVERT(VarI8FromUI8
, 1); EXPECTI8(1);
2366 CONVERT_I8(VarI8FromUI8
, 0x7fffffff, 0xffffffff); EXPECTI864(0x7fffffff, 0xffffffff);
2367 CONVERT_I8(VarI8FromUI8
, 0x80000000, 0); EXPECT_OVERFLOW
;
2370 static void test_VarI8FromCy(void)
2374 CHECKPTR(VarI8FromCy
);
2375 CONVERT_CY(VarI8FromCy
,-128); EXPECTI8(-129);
2376 CONVERT_CY(VarI8FromCy
,-1); EXPECTI8(-2);
2377 CONVERT_CY(VarI8FromCy
,0); EXPECTI8(0);
2378 CONVERT_CY(VarI8FromCy
,1); EXPECTI8(1);
2379 CONVERT_CY(VarI8FromCy
,127); EXPECTI8(127);
2381 CONVERT_CY(VarI8FromCy
,-1.5); EXPECTI8(-2);
2382 CONVERT_CY(VarI8FromCy
,-0.6); EXPECTI8(-1);
2383 CONVERT_CY(VarI8FromCy
,-0.5); EXPECTI8(-1);
2384 CONVERT_CY(VarI8FromCy
,-0.4); EXPECTI8(-1);
2385 CONVERT_CY(VarI8FromCy
,0.4); EXPECTI8(0);
2386 CONVERT_CY(VarI8FromCy
,0.5); EXPECTI8(0);
2387 CONVERT_CY(VarI8FromCy
,0.6); EXPECTI8(1);
2388 CONVERT_CY(VarI8FromCy
,1.5); EXPECTI8(2);
2391 static void test_VarI8FromDec(void)
2395 CHECKPTR(VarI8FromDec
);
2397 CONVERT_BADDEC(VarI8FromDec
);
2399 CONVERT_DEC(VarI8FromDec
,0,0x80,0,128); EXPECTI8(-128);
2400 CONVERT_DEC(VarI8FromDec
,0,0x80,0,1); EXPECTI8(-1);
2401 CONVERT_DEC(VarI8FromDec
,0,0,0,0); EXPECTI8(0);
2402 CONVERT_DEC(VarI8FromDec
,0,0,0,1); EXPECTI8(1);
2403 CONVERT_DEC(VarI8FromDec
,0,0,0,127); EXPECTI8(127);
2405 CONVERT_DEC(VarI8FromDec
,2,0x80,0,12700); EXPECTI8(-127);
2406 CONVERT_DEC(VarI8FromDec
,2,0,0,12700); EXPECTI8(127);
2409 static void test_VarI8FromStr(void)
2414 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
2416 CHECKPTR(VarI8FromStr
);
2418 CONVERT_STR(VarI8FromStr
,NULL
,0); EXPECT_MISMATCH
;
2419 CONVERT_STR(VarI8FromStr
,"0",0); EXPECTI8(0);
2420 CONVERT_STR(VarI8FromStr
,"-1",0); EXPECTI8(-1);
2421 CONVERT_STR(VarI8FromStr
,"2147483647",0); EXPECTI8(2147483647);
2423 CONVERT_STR(VarI8FromStr
,"-1.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(-2);
2424 CONVERT_STR(VarI8FromStr
,"-0.6",LOCALE_NOUSEROVERRIDE
); EXPECTI8(-1);
2425 CONVERT_STR(VarI8FromStr
,"-0.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2426 CONVERT_STR(VarI8FromStr
,"-0.4",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2427 CONVERT_STR(VarI8FromStr
,"0.4",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2428 CONVERT_STR(VarI8FromStr
,"0.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2429 CONVERT_STR(VarI8FromStr
,"0.6",LOCALE_NOUSEROVERRIDE
); EXPECTI8(1);
2430 CONVERT_STR(VarI8FromStr
,"1.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(2);
2433 static void test_VarI8Copy(void)
2436 VARIANTARG vSrc
, vDst
;
2441 win_skip("I8 and UI8 data types are not available\n");
2447 V_VT(&vSrc
) = VT_I8
;
2449 hres
= VariantCopy(&vDst
, &vSrc
);
2450 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_I8
&& V_I8(&vDst
) == in
,
2451 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2452 hres
, V_VT(&vDst
), (UINT
)(in
>> 32), (UINT
)in
, (UINT
)(V_I8(&vDst
) >> 32), (UINT
)V_I8(&vDst
) );
2453 V_VT(&vSrc
) = VT_I8
|VT_BYREF
;
2454 V_I8REF(&vSrc
) = &in
;
2455 hres
= VariantCopy(&vDst
, &vSrc
);
2456 ok(hres
== S_OK
&& V_VT(&vDst
) == (VT_I8
|VT_BYREF
) && V_I8REF(&vDst
) == &in
,
2457 "ref hres 0x%X, type %d, ref (%p) %p\n", hres
, V_VT(&vDst
), &in
, V_I8REF(&vDst
));
2458 hres
= VariantCopyInd(&vDst
, &vSrc
);
2459 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_I8
&& V_I8(&vDst
) == in
,
2460 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2461 hres
, V_VT(&vDst
), (UINT
)(in
>> 32), (UINT
)in
, (UINT
)(V_I8(&vDst
) >> 32), (UINT
)V_I8(&vDst
) );
2464 static void test_VarI8ChangeTypeEx(void)
2468 VARIANTARG vSrc
, vDst
;
2472 win_skip("I8 and UI8 data types are not available\n");
2478 INITIAL_TYPETESTI8(VT_I8
, V_I8
);
2482 /* Adapt the test macros to UI8 */
2484 #define CONV_TYPE ULONG64
2486 static void test_VarUI8FromI1(void)
2488 CONVVARS(signed char);
2491 CHECKPTR(VarUI8FromI1
);
2492 for (i
= -128; i
< 128; i
++)
2494 CONVERT(VarUI8FromI1
,i
);
2502 static void test_VarUI8FromUI1(void)
2507 CHECKPTR(VarUI8FromUI1
);
2508 for (i
= 0; i
< 256; i
++)
2510 CONVERT(VarUI8FromUI1
,i
); EXPECTI8(i
);
2514 static void test_VarUI8FromI2(void)
2519 CHECKPTR(VarUI8FromI2
);
2520 for (i
= -32768; i
< 32768; i
++)
2522 CONVERT(VarUI8FromI2
,i
);
2530 static void test_VarUI8FromUI2(void)
2535 CHECKPTR(VarUI8FromUI2
);
2536 for (i
= 0; i
< 65535; i
++)
2538 CONVERT(VarUI8FromUI2
,i
); EXPECTI8(i
);
2542 static void test_VarUI8FromUI4(void)
2546 CHECKPTR(VarUI8FromUI4
);
2547 CONVERT(VarUI8FromUI4
, 0); EXPECTI8(0);
2548 CONVERT(VarUI8FromUI4
, 0xffffffff); EXPECTI8(0xffffffff);
2551 static void test_VarUI8FromR4(void)
2555 CHECKPTR(VarUI8FromR4
);
2556 CONVERT(VarUI8FromR4
, -1.0f
); EXPECT_OVERFLOW
;
2557 CONVERT(VarUI8FromR4
, 0.0f
); EXPECTI8(0);
2558 CONVERT(VarUI8FromR4
, 1.0f
); EXPECTI8(1);
2559 CONVERT(VarUI8FromR4
, 255.0f
); EXPECTI8(255);
2561 CONVERT(VarUI8FromR4
, -1.5f
); EXPECT_OVERFLOW
;
2562 CONVERT(VarUI8FromR4
, -0.6f
); EXPECT_OVERFLOW
;
2563 CONVERT(VarUI8FromR4
, -0.5f
); EXPECTI8(0);
2564 CONVERT(VarUI8FromR4
, -0.4f
); EXPECTI8(0);
2565 CONVERT(VarUI8FromR4
, 0.4f
); EXPECTI8(0);
2566 CONVERT(VarUI8FromR4
, 0.5f
); EXPECTI8(0);
2567 CONVERT(VarUI8FromR4
, 0.6f
); EXPECTI8(1);
2568 CONVERT(VarUI8FromR4
, 1.5f
); EXPECTI8(2);
2571 static void test_VarUI8FromR8(void)
2575 CHECKPTR(VarUI8FromR8
);
2576 CONVERT(VarUI8FromR8
, -1.0); EXPECT_OVERFLOW
;
2577 CONVERT(VarUI8FromR8
, 0.0); EXPECTI8(0);
2578 CONVERT(VarUI8FromR8
, 1.0); EXPECTI8(1);
2579 CONVERT(VarUI8FromR8
, 255.0); EXPECTI8(255);
2581 CONVERT(VarUI8FromR8
, -1.5); EXPECT_OVERFLOW
;
2582 CONVERT(VarUI8FromR8
, -0.6); EXPECT_OVERFLOW
;
2583 CONVERT(VarUI8FromR8
, -0.5); EXPECTI8(0);
2584 CONVERT(VarUI8FromR8
, -0.4); EXPECTI8(0);
2585 CONVERT(VarUI8FromR8
, 0.4); EXPECTI8(0);
2586 CONVERT(VarUI8FromR8
, 0.5); EXPECTI8(0);
2587 CONVERT(VarUI8FromR8
, 0.6); EXPECTI8(1);
2588 CONVERT(VarUI8FromR8
, 1.5); EXPECTI8(2);
2591 static void test_VarUI8FromDate(void)
2595 CHECKPTR(VarUI8FromDate
);
2596 CONVERT(VarUI8FromDate
, -1.0); EXPECT_OVERFLOW
;
2597 CONVERT(VarUI8FromDate
, 0.0); EXPECTI8(0);
2598 CONVERT(VarUI8FromDate
, 1.0); EXPECTI8(1);
2599 CONVERT(VarUI8FromDate
, 255.0); EXPECTI8(255);
2601 CONVERT(VarUI8FromDate
, -1.5); EXPECT_OVERFLOW
;
2602 CONVERT(VarUI8FromDate
, -0.6); EXPECT_OVERFLOW
;
2603 CONVERT(VarUI8FromDate
, -0.5); EXPECTI8(0);
2604 CONVERT(VarUI8FromDate
, -0.4); EXPECTI8(0);
2605 CONVERT(VarUI8FromDate
, 0.4); EXPECTI8(0);
2606 CONVERT(VarUI8FromDate
, 0.5); EXPECTI8(0);
2607 CONVERT(VarUI8FromDate
, 0.6); EXPECTI8(1);
2608 CONVERT(VarUI8FromDate
, 1.5); EXPECTI8(2);
2611 static void test_VarUI8FromBool(void)
2613 CONVVARS(VARIANT_BOOL
);
2616 CHECKPTR(VarUI8FromBool
);
2617 for (i
= -32768; i
< 32768; i
++)
2619 CONVERT(VarUI8FromBool
, i
); EXPECTI8(i
);
2623 static void test_VarUI8FromI8(void)
2627 CHECKPTR(VarUI8FromI8
);
2628 CONVERT(VarUI8FromI8
, -1); EXPECT_OVERFLOW
;
2629 CONVERT(VarUI8FromI8
, 0); EXPECTI8(0);
2630 CONVERT(VarUI8FromI8
, 1); EXPECTI8(1);
2633 static void test_VarUI8FromCy(void)
2637 CHECKPTR(VarUI8FromCy
);
2638 CONVERT_CY(VarUI8FromCy
,-1); EXPECT_OVERFLOW
;
2639 CONVERT_CY(VarUI8FromCy
,0); EXPECTI8(0);
2640 CONVERT_CY(VarUI8FromCy
,1); EXPECTI8(1);
2641 CONVERT_CY(VarUI8FromCy
,255); EXPECTI8(255);
2643 CONVERT_CY(VarUI8FromCy
,-1.5); EXPECT_OVERFLOW
;
2644 CONVERT_CY(VarUI8FromCy
,-0.6); EXPECT_OVERFLOW
;
2645 CONVERT_CY(VarUI8FromCy
,-0.5); EXPECTI8(0);
2646 CONVERT_CY(VarUI8FromCy
,-0.4); EXPECTI8(0);
2647 CONVERT_CY(VarUI8FromCy
,0.4); EXPECTI8(0);
2648 CONVERT_CY(VarUI8FromCy
,0.5); EXPECTI8(0);
2649 CONVERT_CY(VarUI8FromCy
,0.6); EXPECTI8(1);
2650 CONVERT_CY(VarUI8FromCy
,1.5); EXPECTI8(2);
2653 static void test_VarUI8FromDec(void)
2657 CHECKPTR(VarUI8FromDec
);
2659 CONVERT_BADDEC(VarUI8FromDec
);
2661 /* This returns 1 under native; Wine fixes this bug and returns overflow */
2664 CONVERT_DEC(VarUI8FromDec
,0,0x80,0,1);
2667 CONVERT_DEC(VarUI8FromDec
,0,0,0,0); EXPECTI8(0);
2668 CONVERT_DEC(VarUI8FromDec
,0,0,0,1); EXPECTI8(1);
2669 CONVERT_DEC(VarUI8FromDec
,0,0,0,255); EXPECTI8(255);
2671 CONVERT_DEC(VarUI8FromDec
,2,0x80,0,100); EXPECT_OVERFLOW
;
2672 CONVERT_DEC(VarUI8FromDec
,2,0,0,25500); EXPECTI8(255);
2675 static void test_VarUI8FromStr(void)
2680 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
2682 CHECKPTR(VarUI8FromStr
);
2684 CONVERT_STR(VarUI8FromStr
,NULL
,0); EXPECT_MISMATCH
;
2685 CONVERT_STR(VarUI8FromStr
,"0",0); EXPECTI8(0);
2686 CONVERT_STR(VarUI8FromStr
,"-1",0); EXPECT_OVERFLOW
;
2687 CONVERT_STR(VarUI8FromStr
,"2147483647",0); EXPECTI8(2147483647);
2688 CONVERT_STR(VarUI8FromStr
,"18446744073709551614",0); EXPECTI864(0xFFFFFFFF,0xFFFFFFFE);
2689 CONVERT_STR(VarUI8FromStr
,"18446744073709551615",0); EXPECTI864(0xFFFFFFFF,0xFFFFFFFF);
2690 CONVERT_STR(VarUI8FromStr
,"18446744073709551616",0); EXPECT_OVERFLOW
;
2692 CONVERT_STR(VarUI8FromStr
,"-1.5",LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
2693 CONVERT_STR(VarUI8FromStr
,"-0.6",LOCALE_NOUSEROVERRIDE
); EXPECT_OVERFLOW
;
2694 CONVERT_STR(VarUI8FromStr
,"-0.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2695 CONVERT_STR(VarUI8FromStr
,"-0.4",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2696 CONVERT_STR(VarUI8FromStr
,"0.4",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2697 CONVERT_STR(VarUI8FromStr
,"0.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(0);
2698 CONVERT_STR(VarUI8FromStr
,"0.6",LOCALE_NOUSEROVERRIDE
); EXPECTI8(1);
2699 CONVERT_STR(VarUI8FromStr
,"1.5",LOCALE_NOUSEROVERRIDE
); EXPECTI8(2);
2702 static void test_VarUI8Copy(void)
2705 VARIANTARG vSrc
, vDst
;
2710 win_skip("I8 and UI8 data types are not available\n");
2716 V_VT(&vSrc
) = VT_UI8
;
2718 hres
= VariantCopy(&vDst
, &vSrc
);
2719 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_UI8
&& V_UI8(&vDst
) == in
,
2720 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2721 hres
, V_VT(&vDst
), (UINT
)(in
>> 32), (UINT
)in
, (UINT
)(V_UI8(&vDst
) >> 32), (UINT
)V_UI8(&vDst
) );
2722 V_VT(&vSrc
) = VT_UI8
|VT_BYREF
;
2723 V_UI8REF(&vSrc
) = &in
;
2724 hres
= VariantCopy(&vDst
, &vSrc
);
2725 ok(hres
== S_OK
&& V_VT(&vDst
) == (VT_UI8
|VT_BYREF
) && V_UI8REF(&vDst
) == &in
,
2726 "ref hres 0x%X, type %d, ref (%p) %p\n", hres
, V_VT(&vDst
), &in
, V_UI8REF(&vDst
));
2727 hres
= VariantCopyInd(&vDst
, &vSrc
);
2728 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_UI8
&& V_UI8(&vDst
) == in
,
2729 "copy hres 0x%X, type %d, value (%x%08x) %x%08x\n",
2730 hres
, V_VT(&vDst
), (UINT
)(in
>> 32), (UINT
)in
, (UINT
)(V_UI8(&vDst
) >> 32), (UINT
)V_UI8(&vDst
) );
2733 static void test_VarUI8ChangeTypeEx(void)
2737 VARIANTARG vSrc
, vDst
;
2741 win_skip("I8 and UI8 data types are not available\n");
2747 INITIAL_TYPETESTI8(VT_UI8
, V_UI8
);
2756 #define CONV_TYPE float
2758 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%15.15f")
2760 static void test_VarR4FromI1(void)
2762 CONVVARS(signed char);
2765 CHECKPTR(VarR4FromI1
);
2766 CONVERTRANGE(VarR4FromI1
, -128, 128);
2769 static void test_VarR4FromUI1(void)
2774 CHECKPTR(VarR4FromUI1
);
2775 CONVERTRANGE(VarR4FromUI1
, 0, 256);
2778 static void test_VarR4FromI2(void)
2783 CHECKPTR(VarR4FromI2
);
2784 CONVERTRANGE(VarR4FromI2
, -32768, 32768);
2787 static void test_VarR4FromUI2(void)
2792 CHECKPTR(VarR4FromUI2
);
2793 CONVERTRANGE(VarR4FromUI2
, 0, 65536);
2796 static void test_VarR4FromI4(void)
2800 CHECKPTR(VarR4FromI4
);
2801 CONVERT(VarR4FromI4
, -2147483647-1); EXPECT(-2147483648.0f
);
2802 CONVERT(VarR4FromI4
, -1); EXPECT(-1.0f
);
2803 CONVERT(VarR4FromI4
, 0); EXPECT(0.0f
);
2804 CONVERT(VarR4FromI4
, 1); EXPECT(1.0f
);
2805 CONVERT(VarR4FromI4
, 2147483647); EXPECT(2147483647.0f
);
2808 static void test_VarR4FromUI4(void)
2810 CONVVARS(unsigned int);
2812 CHECKPTR(VarR4FromUI4
);
2813 CONVERT(VarR4FromUI4
, 0); EXPECT(0.0f
);
2814 CONVERT(VarR4FromUI4
, 1); EXPECT(1.0f
);
2815 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
2816 CONVERT(VarR4FromUI4
, 0xffffffff); EXPECT(4294967296.0f
);
2820 static void test_VarR4FromR8(void)
2824 CHECKPTR(VarR4FromR8
);
2825 CONVERT(VarR4FromR8
, -1.0); EXPECT(-1.0f
);
2826 CONVERT(VarR4FromR8
, 0.0); EXPECT(0.0f
);
2827 CONVERT(VarR4FromR8
, 1.0); EXPECT(1.0f
);
2828 CONVERT(VarR4FromR8
, 1.5); EXPECT(1.5f
);
2830 /* Skip rounding tests - no rounding is done */
2833 static void test_VarR4FromBool(void)
2835 CONVVARS(VARIANT_BOOL
);
2837 CHECKPTR(VarR4FromBool
);
2838 CONVERT(VarR4FromBool
, VARIANT_TRUE
); EXPECT(VARIANT_TRUE
* 1.0f
);
2839 CONVERT(VarR4FromBool
, VARIANT_FALSE
); EXPECT(VARIANT_FALSE
* 1.0f
);
2842 static void test_VarR4FromCy(void)
2846 CHECKPTR(VarR4FromCy
);
2847 CONVERT_CY(VarR4FromCy
,-32768); EXPECT(-32768.0f
);
2848 CONVERT_CY(VarR4FromCy
,-1); EXPECT(-1.0f
);
2849 CONVERT_CY(VarR4FromCy
,0); EXPECT(0.0f
);
2850 CONVERT_CY(VarR4FromCy
,1); EXPECT(1.0f
);
2851 CONVERT_CY(VarR4FromCy
,32768); EXPECT(32768.0f
);
2853 CONVERT_CY(VarR4FromCy
,-1.5); EXPECT(-1.5f
);
2854 CONVERT_CY(VarR4FromCy
,-0.6); EXPECT(-0.6f
);
2855 CONVERT_CY(VarR4FromCy
,-0.5); EXPECT(-0.5f
);
2856 CONVERT_CY(VarR4FromCy
,-0.4); EXPECT(-0.4f
);
2857 CONVERT_CY(VarR4FromCy
,0.4); EXPECT(0.4f
);
2858 CONVERT_CY(VarR4FromCy
,0.5); EXPECT(0.5f
);
2859 CONVERT_CY(VarR4FromCy
,0.6); EXPECT(0.6f
);
2860 CONVERT_CY(VarR4FromCy
,1.5); EXPECT(1.5f
);
2863 static void test_VarR4FromI8(void)
2867 CHECKPTR(VarR4FromI8
);
2868 CONVERT(VarR4FromI8
, -1); EXPECT(-1.0f
);
2869 CONVERT(VarR4FromI8
, 0); EXPECT(0.0f
);
2870 CONVERT(VarR4FromI8
, 1); EXPECT(1.0f
);
2873 static void test_VarR4FromUI8(void)
2877 CHECKPTR(VarR4FromUI8
);
2878 CONVERT(VarR4FromUI8
, 0); EXPECT(0.0f
);
2879 CONVERT(VarR4FromUI8
, 1); EXPECT(1.0f
);
2882 static void test_VarR4FromDec(void)
2886 CHECKPTR(VarR4FromDec
);
2888 CONVERT_BADDEC(VarR4FromDec
);
2890 CONVERT_DEC(VarR4FromDec
,0,0x80,0,32768); EXPECT(-32768.0f
);
2891 CONVERT_DEC(VarR4FromDec
,0,0x80,0,1); EXPECT(-1.0f
);
2892 CONVERT_DEC(VarR4FromDec
,0,0,0,0); EXPECT(0.0f
);
2893 CONVERT_DEC(VarR4FromDec
,0,0,0,1); EXPECT(1.0f
);
2894 CONVERT_DEC(VarR4FromDec
,0,0,0,32767); EXPECT(32767.0f
);
2896 CONVERT_DEC(VarR4FromDec
,2,0x80,0,3276800); EXPECT(-32768.0f
);
2897 CONVERT_DEC(VarR4FromDec
,2,0,0,3276700); EXPECT(32767.0f
);
2898 CONVERT_DEC(VarR4FromDec
,10,0,0,3276700); EXPECT(0.00032767f
);
2900 CONVERT_DEC(VarR4FromDec
,0,0,1,0); EXPECT(18446744073709551616.0f
);
2903 static void test_VarR4FromDate(void)
2907 CHECKPTR(VarR4FromDate
);
2908 CONVERT(VarR4FromDate
, -1.0); EXPECT(-1.0f
);
2909 CONVERT(VarR4FromDate
, 0.0); EXPECT(0.0f
);
2910 CONVERT(VarR4FromDate
, 1.0); EXPECT(1.0f
);
2913 static void test_VarR4FromStr(void)
2918 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
2920 CHECKPTR(VarR4FromStr
);
2922 CONVERT_STR(VarR4FromStr
,NULL
,0); EXPECT_MISMATCH
;
2923 CONVERT_STR(VarR4FromStr
,"-1", 0); EXPECT(-1.0f
);
2924 CONVERT_STR(VarR4FromStr
,"0", 0); EXPECT(0.0f
);
2925 CONVERT_STR(VarR4FromStr
,"1", 0); EXPECT(1.0f
);
2927 CONVERT_STR(VarR4FromStr
,"-1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(-1.5f
);
2928 CONVERT_STR(VarR4FromStr
,"-0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(-0.6f
);
2929 CONVERT_STR(VarR4FromStr
,"-0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(-0.5f
);
2930 CONVERT_STR(VarR4FromStr
,"-0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(-0.4f
);
2931 CONVERT_STR(VarR4FromStr
,"0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(0.4f
);
2932 CONVERT_STR(VarR4FromStr
,"0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(0.5f
);
2933 CONVERT_STR(VarR4FromStr
,"0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(0.6f
);
2934 CONVERT_STR(VarR4FromStr
,"1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(1.5f
);
2937 static void test_VarR4Copy(void)
2939 COPYTEST(77665544.0f
, VT_R4
, V_R4(&vSrc
), V_R4(&vDst
), V_R4REF(&vSrc
),V_R4REF(&vDst
), "%15.15f");
2942 static void test_VarR4ChangeTypeEx(void)
2944 #ifdef HAS_UINT64_TO_FLOAT
2947 VARIANTARG vSrc
, vDst
;
2951 INITIAL_TYPETEST(VT_R4
, V_R4
, "%f");
2961 #define CONV_TYPE double
2963 static void test_VarR8FromI1(void)
2965 CONVVARS(signed char);
2968 CHECKPTR(VarR8FromI1
);
2969 CONVERTRANGE(VarR8FromI1
, -128, 128);
2972 static void test_VarR8FromUI1(void)
2977 CHECKPTR(VarR8FromUI1
);
2978 CONVERTRANGE(VarR8FromUI1
, 0, 256);
2981 static void test_VarR8FromI2(void)
2986 CHECKPTR(VarR8FromI2
);
2987 CONVERTRANGE(VarR8FromI2
, -32768, 32768);
2990 static void test_VarR8FromUI2(void)
2995 CHECKPTR(VarR8FromUI2
);
2996 CONVERTRANGE(VarR8FromUI2
, 0, 65536);
2999 static void test_VarR8FromI4(void)
3003 CHECKPTR(VarR8FromI4
);
3004 CONVERT(VarR8FromI4
, -2147483647-1); EXPECT(-2147483648.0);
3005 CONVERT(VarR8FromI4
, -1); EXPECT(-1.0);
3006 CONVERT(VarR8FromI4
, 0); EXPECT(0.0);
3007 CONVERT(VarR8FromI4
, 1); EXPECT(1.0);
3008 CONVERT(VarR8FromI4
, 0x7fffffff); EXPECT(2147483647.0);
3011 static void test_VarR8FromUI4(void)
3013 CONVVARS(unsigned int);
3015 CHECKPTR(VarR8FromUI4
);
3016 CONVERT(VarR8FromUI4
, 0); EXPECT(0.0);
3017 CONVERT(VarR8FromUI4
, 1); EXPECT(1.0);
3018 CONVERT(VarR8FromUI4
, 0xffffffff); EXPECT(4294967295.0);
3021 static void test_VarR8FromR4(void)
3025 CHECKPTR(VarR8FromR4
);
3026 CONVERT(VarR8FromR4
, -1.0f
); EXPECT(-1.0);
3027 CONVERT(VarR8FromR4
, 0.0f
); EXPECT(0.0);
3028 CONVERT(VarR8FromR4
, 1.0f
); EXPECT(1.0);
3029 CONVERT(VarR8FromR4
, 1.5f
); EXPECT(1.5);
3031 /* Skip rounding tests - no rounding is done */
3034 static void test_VarR8FromBool(void)
3036 CONVVARS(VARIANT_BOOL
);
3038 CHECKPTR(VarR8FromBool
);
3039 CONVERT(VarR8FromBool
, VARIANT_TRUE
); EXPECT(VARIANT_TRUE
* 1.0);
3040 CONVERT(VarR8FromBool
, VARIANT_FALSE
); EXPECT(VARIANT_FALSE
* 1.0);
3043 static void test_VarR8FromCy(void)
3047 CHECKPTR(VarR8FromCy
);
3048 CONVERT_CY(VarR8FromCy
,-32769); EXPECT(-32769.0);
3049 CONVERT_CY(VarR8FromCy
,-32768); EXPECT(-32768.0);
3050 CONVERT_CY(VarR8FromCy
,-1); EXPECT(-1.0);
3051 CONVERT_CY(VarR8FromCy
,0); EXPECT(0.0);
3052 CONVERT_CY(VarR8FromCy
,1); EXPECT(1.0);
3053 CONVERT_CY(VarR8FromCy
,32767); EXPECT(32767.0);
3054 CONVERT_CY(VarR8FromCy
,32768); EXPECT(32768.0);
3056 CONVERT_CY(VarR8FromCy
,-1.5); EXPECT(-1.5);
3057 CONVERT_CY(VarR8FromCy
,-0.6); EXPECT(-0.6);
3058 CONVERT_CY(VarR8FromCy
,-0.5); EXPECT(-0.5);
3059 CONVERT_CY(VarR8FromCy
,-0.4); EXPECT(-0.4);
3060 CONVERT_CY(VarR8FromCy
,0.4); EXPECT(0.4);
3061 CONVERT_CY(VarR8FromCy
,0.5); EXPECT(0.5);
3062 CONVERT_CY(VarR8FromCy
,0.6); EXPECT(0.6);
3063 CONVERT_CY(VarR8FromCy
,1.5); EXPECT(1.5);
3066 static void test_VarR8FromI8(void)
3070 CHECKPTR(VarR8FromI8
);
3071 CONVERT(VarR8FromI8
, -1); EXPECT(-1.0);
3072 CONVERT(VarR8FromI8
, 0); EXPECT(0.0);
3073 CONVERT(VarR8FromI8
, 1); EXPECT(1.0);
3074 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3075 CONVERT_I8(VarR8FromI8
, 0x7fffffff,0xffffffff); EXPECT(9223372036854775808.0);
3079 static void test_VarR8FromUI8(void)
3083 CHECKPTR(VarR8FromUI8
);
3084 CONVERT(VarR8FromUI8
, 0); EXPECT(0.0);
3085 CONVERT(VarR8FromUI8
, 1); EXPECT(1.0);
3086 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3087 CONVERT_I8(VarR8FromUI8
, 0x80000000,0); EXPECT(9223372036854775808.0);
3091 static void test_VarR8FromDec(void)
3095 CHECKPTR(VarR8FromDec
);
3097 CONVERT_BADDEC(VarR8FromDec
);
3099 CONVERT_DEC(VarR8FromDec
,0,0x80,0,32768); EXPECT(-32768.0);
3100 CONVERT_DEC(VarR8FromDec
,0,0x80,0,1); EXPECT(-1.0);
3101 CONVERT_DEC(VarR8FromDec
,0,0,0,0); EXPECT(0.0);
3102 CONVERT_DEC(VarR8FromDec
,0,0,0,1); EXPECT(1.0);
3103 CONVERT_DEC(VarR8FromDec
,0,0,0,32767); EXPECT(32767.0);
3105 CONVERT_DEC(VarR8FromDec
,2,0x80,0,3276800); EXPECT(-32768.0);
3106 CONVERT_DEC(VarR8FromDec
,2,0,0,3276700); EXPECT(32767.0);
3108 CONVERT_DEC(VarR8FromDec
,0,0,1,0); EXPECT(18446744073709551616.0);
3111 static void test_VarR8FromDate(void)
3115 CHECKPTR(VarR8FromDate
);
3116 CONVERT(VarR8FromDate
, -1.0); EXPECT(-1.0);
3117 CONVERT(VarR8FromDate
, -0.0); EXPECT(0.0);
3118 CONVERT(VarR8FromDate
, 1.0); EXPECT(1.0);
3121 static void test_VarR8FromStr(void)
3126 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
3128 CHECKPTR(VarR8FromStr
);
3130 CONVERT_STR(VarR8FromStr
,NULL
,0); EXPECT_MISMATCH
;
3131 CONVERT_STR(VarR8FromStr
,"",0); EXPECT_MISMATCH
;
3132 CONVERT_STR(VarR8FromStr
," ",0); EXPECT_MISMATCH
;
3134 CONVERT_STR(VarR8FromStr
,"0",LOCALE_NOUSEROVERRIDE
); EXPECT(0.0);
3135 CONVERT_STR(VarR8FromStr
,"-1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(-1.5);
3136 CONVERT_STR(VarR8FromStr
,"-0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(-0.6);
3137 CONVERT_STR(VarR8FromStr
,"-0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(-0.5);
3138 CONVERT_STR(VarR8FromStr
,"-0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(-0.4);
3139 CONVERT_STR(VarR8FromStr
,"0.4",LOCALE_NOUSEROVERRIDE
); EXPECT(0.4);
3140 CONVERT_STR(VarR8FromStr
,"0.5",LOCALE_NOUSEROVERRIDE
); EXPECT(0.5);
3141 CONVERT_STR(VarR8FromStr
,"0.6",LOCALE_NOUSEROVERRIDE
); EXPECT(0.6);
3142 CONVERT_STR(VarR8FromStr
,"1.5",LOCALE_NOUSEROVERRIDE
); EXPECT(1.5);
3144 /* We already have exhaustive tests for number parsing, so skip those tests here */
3147 static void test_VarR8Copy(void)
3149 COPYTEST(77665544.0, VT_R8
, V_R8(&vSrc
), V_R8(&vDst
), V_R8REF(&vSrc
),V_R8REF(&vDst
), "%16.16g");
3152 static void test_VarR8ChangeTypeEx(void)
3154 #ifdef HAS_UINT64_TO_FLOAT
3157 VARIANTARG vSrc
, vDst
;
3161 INITIAL_TYPETEST(VT_R8
, V_R8
, "%g");
3166 #define MATHRND(l, r) left = l; right = r; hres = pVarR8Round(left, right, &out)
3168 static void test_VarR8Round(void)
3171 double left
= 0.0, out
;
3174 CHECKPTR(VarR8Round
);
3175 MATHRND(0.5432, 5); EXPECT(0.5432);
3176 MATHRND(0.5432, 4); EXPECT(0.5432);
3177 MATHRND(0.5432, 3); EXPECT(0.543);
3178 MATHRND(0.5432, 2); EXPECT(0.54);
3179 MATHRND(0.5432, 1); EXPECT(0.5);
3180 MATHRND(0.5532, 0); EXPECT(1);
3181 MATHRND(0.5532, -1); EXPECT_INVALID
;
3183 MATHRND(0.5568, 5); EXPECT(0.5568);
3184 MATHRND(0.5568, 4); EXPECT(0.5568);
3185 MATHRND(0.5568, 3); EXPECT(0.557);
3186 MATHRND(0.5568, 2); EXPECT(0.56);
3187 MATHRND(0.5568, 1); EXPECT(0.6);
3188 MATHRND(0.5568, 0); EXPECT(1);
3189 MATHRND(0.5568, -1); EXPECT_INVALID
;
3191 MATHRND(0.4999, 0); EXPECT(0);
3192 MATHRND(0.5000, 0); EXPECT(0);
3193 MATHRND(0.5001, 0); EXPECT(1);
3194 MATHRND(1.4999, 0); EXPECT(1);
3195 MATHRND(1.5000, 0); EXPECT(2);
3196 MATHRND(1.5001, 0); EXPECT(2);
3204 #define CONV_TYPE DATE
3206 static void test_VarDateFromI1(void)
3208 CONVVARS(signed char);
3211 CHECKPTR(VarDateFromI1
);
3212 CONVERTRANGE(VarDateFromI1
, -128, 128);
3215 static void test_VarDateFromUI1(void)
3220 CHECKPTR(VarDateFromUI1
);
3221 CONVERTRANGE(VarDateFromUI1
, 0, 256);
3224 static void test_VarDateFromI2(void)
3229 CHECKPTR(VarDateFromI2
);
3230 CONVERTRANGE(VarDateFromI2
, -32768, 32768);
3233 static void test_VarDateFromUI2(void)
3238 CHECKPTR(VarDateFromUI2
);
3239 CONVERTRANGE(VarDateFromUI2
, 0, 65536);
3242 static void test_VarDateFromI4(void)
3246 CHECKPTR(VarDateFromI4
);
3247 CONVERT(VarDateFromI4
, DATE_MIN
-1);
3248 if (hres
!= DISP_E_TYPEMISMATCH
) /* Early versions return this, incorrectly */
3250 CONVERT(VarDateFromI4
, DATE_MIN
); EXPECT(DATE_MIN
);
3251 CONVERT(VarDateFromI4
, -1); EXPECT(-1.0);
3252 CONVERT(VarDateFromI4
, 0); EXPECT(0.0);
3253 CONVERT(VarDateFromI4
, 1); EXPECT(1.0);
3254 CONVERT(VarDateFromI4
, DATE_MAX
); EXPECT(DATE_MAX
);
3255 CONVERT(VarDateFromI4
, DATE_MAX
+1);
3256 if (hres
!= DISP_E_TYPEMISMATCH
) /* Early versions return this, incorrectly */
3260 static void test_VarDateFromUI4(void)
3262 CONVVARS(unsigned int);
3264 CHECKPTR(VarDateFromUI4
);
3265 CONVERT(VarDateFromUI4
, 0); EXPECT(0.0);
3266 CONVERT(VarDateFromUI4
, 1); EXPECT(1.0);
3267 CONVERT(VarDateFromUI4
, DATE_MAX
); EXPECT(DATE_MAX
);
3268 CONVERT(VarDateFromUI4
, DATE_MAX
+1);
3269 if (hres
!= DISP_E_TYPEMISMATCH
) /* Early versions return this, incorrectly */
3273 static void test_VarDateFromR4(void)
3277 CHECKPTR(VarDateFromR4
);
3278 CONVERT(VarDateFromR4
, -1.0f
); EXPECT(-1.0);
3279 CONVERT(VarDateFromR4
, 0.0f
); EXPECT(0.0);
3280 CONVERT(VarDateFromR4
, 1.0f
); EXPECT(1.0);
3281 CONVERT(VarDateFromR4
, 1.5f
); EXPECT(1.5);
3284 static void test_VarDateFromR8(void)
3288 CHECKPTR(VarDateFromR8
);
3289 CONVERT(VarDateFromR8
, -1.0f
); EXPECT(-1.0);
3290 CONVERT(VarDateFromR8
, 0.0f
); EXPECT(0.0);
3291 CONVERT(VarDateFromR8
, 1.0f
); EXPECT(1.0);
3292 CONVERT(VarDateFromR8
, 1.5f
); EXPECT(1.5);
3295 static void test_VarDateFromBool(void)
3297 CONVVARS(VARIANT_BOOL
);
3299 CHECKPTR(VarDateFromBool
);
3300 CONVERT(VarDateFromBool
, VARIANT_TRUE
); EXPECT(VARIANT_TRUE
* 1.0);
3301 CONVERT(VarDateFromBool
, VARIANT_FALSE
); EXPECT(VARIANT_FALSE
* 1.0);
3304 static void test_VarDateFromCy(void)
3308 CHECKPTR(VarDateFromCy
);
3309 CONVERT_CY(VarDateFromCy
,-32769); EXPECT(-32769.0);
3310 CONVERT_CY(VarDateFromCy
,-32768); EXPECT(-32768.0);
3311 CONVERT_CY(VarDateFromCy
,-1); EXPECT(-1.0);
3312 CONVERT_CY(VarDateFromCy
,0); EXPECT(0.0);
3313 CONVERT_CY(VarDateFromCy
,1); EXPECT(1.0);
3314 CONVERT_CY(VarDateFromCy
,32767); EXPECT(32767.0);
3315 CONVERT_CY(VarDateFromCy
,32768); EXPECT(32768.0);
3317 CONVERT_CY(VarDateFromCy
,-1.5); EXPECT(-1.5);
3318 CONVERT_CY(VarDateFromCy
,-0.6); EXPECT(-0.6);
3319 CONVERT_CY(VarDateFromCy
,-0.5); EXPECT(-0.5);
3320 CONVERT_CY(VarDateFromCy
,-0.4); EXPECT(-0.4);
3321 CONVERT_CY(VarDateFromCy
,0.4); EXPECT(0.4);
3322 CONVERT_CY(VarDateFromCy
,0.5); EXPECT(0.5);
3323 CONVERT_CY(VarDateFromCy
,0.6); EXPECT(0.6);
3324 CONVERT_CY(VarDateFromCy
,1.5); EXPECT(1.5);
3327 static void test_VarDateFromI8(void)
3331 CHECKPTR(VarDateFromI8
);
3332 CONVERT(VarDateFromI8
, DATE_MIN
-1); EXPECT_OVERFLOW
;
3333 CONVERT(VarDateFromI8
, DATE_MIN
); EXPECT(DATE_MIN
);
3334 CONVERT(VarDateFromI8
, -1); EXPECT(-1.0);
3335 CONVERT(VarDateFromI8
, 0); EXPECT(0.0);
3336 CONVERT(VarDateFromI8
, 1); EXPECT(1.0);
3337 CONVERT(VarDateFromI8
, DATE_MAX
); EXPECT(DATE_MAX
);
3338 CONVERT(VarDateFromI8
, DATE_MAX
+1); EXPECT_OVERFLOW
;
3341 static void test_VarDateFromUI8(void)
3345 CHECKPTR(VarDateFromUI8
);
3346 CONVERT(VarDateFromUI8
, 0); EXPECT(0.0);
3347 CONVERT(VarDateFromUI8
, 1); EXPECT(1.0);
3348 CONVERT(VarDateFromUI8
, DATE_MAX
); EXPECT(DATE_MAX
);
3349 CONVERT(VarDateFromUI8
, DATE_MAX
+1); EXPECT_OVERFLOW
;
3352 static void test_VarDateFromDec(void)
3356 CHECKPTR(VarDateFromDec
);
3358 CONVERT_BADDEC(VarDateFromDec
);
3360 CONVERT_DEC(VarDateFromDec
,0,0x80,0,32768); EXPECT(-32768.0);
3361 CONVERT_DEC(VarDateFromDec
,0,0x80,0,1); EXPECT(-1.0);
3362 CONVERT_DEC(VarDateFromDec
,0,0,0,0); EXPECT(0.0);
3363 CONVERT_DEC(VarDateFromDec
,0,0,0,1); EXPECT(1.0);
3364 CONVERT_DEC(VarDateFromDec
,0,0,0,32767); EXPECT(32767.0);
3366 CONVERT_DEC(VarDateFromDec
,2,0x80,0,3276800); EXPECT(-32768.0);
3367 CONVERT_DEC(VarDateFromDec
,2,0,0,3276700); EXPECT(32767.0);
3371 buff[0] = '\0'; out = 0.0; \
3372 if (str) MultiByteToWideChar(CP_ACP,0,str,-1,buff,sizeof(buff)/sizeof(WCHAR)); \
3373 hres = pVarDateFromStr(str ? buff : NULL,lcid,LOCALE_NOUSEROVERRIDE,&out)
3375 #define MKRELDATE(day,mth) st.wMonth = mth; st.wDay = day; \
3376 pSystemTimeToVariantTime(&st,&relative)
3378 static const char * const BadDateStrings
[] =
3380 "True", "False", /* Plain text */
3381 "0.", ".0", "-1.1", "1.1-", /* Partial specifications */
3382 "1;2;3", "1*2*3", "1@2@3", "1#2#3", "(1:2)","<1:2>","1|2|3", /* Bad chars */
3383 "0", "1", /* 1 element */
3384 "0.60", "24.00", "0:60", "24:00", "1 2 am", "1 am 2", /* 2 elements */
3385 "1.5 2", "1 5.2", "2 32 3", "1 2 am 3", /* 3 elements */
3386 "1 2.3 4", "1.2.3 4", "1 2.3.4", "1.2 3.4", "1.2.3.4", "1 2 3 4",
3387 "1 am 2 3.4", "1 2 am 3.4", "1.2 3 am 4", "1.2 3 4 am", /* 4 elements */
3388 "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",
3389 "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",
3390 "1.2.3 4 am 5", "1.2.3 4 5 am", "1.2 3 am 4 5",
3391 "1.2 3 4 am 5", "1.2 3 4 5 am", "1 am 2 3.4.5", "1 2 am 3.4.5",
3392 "1 am 2 3 4.5", "1 2 am 3 4.5", "1 2 3 am 4.5", /* 5 elements */
3394 "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",
3395 "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",
3396 "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",
3397 "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",
3399 /* following throws an exception on winME */
3400 "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",
3402 "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",
3404 /* following throws an exception on winME */
3405 "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",
3407 "1 2 am 3 4.5.6", "1 2 3 am 4.5.6"
3410 static void test_VarDateFromStr(void)
3419 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
3421 CHECKPTR(VarDateFromStr
);
3422 CHECKPTR(SystemTimeToVariantTime
);
3424 /* Some date formats are relative, so we need to find the current year */
3426 st
.wHour
= st
.wMinute
= st
.wSecond
= st
.wMilliseconds
= 0;
3427 DFS(NULL
); EXPECT_MISMATCH
;
3429 /* Floating point number are not recognised */
3432 EXPECT_DBL(0.0); /* Very old versions accept this string */
3436 /* 1 element - can only be a time, and only if it has am/pm */
3437 DFS("1 am"); EXPECT_DBL(0.04166666666666666);
3439 /* A decimal point is treated as a time separator.
3440 * The following are converted as hours/minutes.
3442 DFS("0.1"); EXPECT_DBL(0.0006944444444444445);
3443 DFS("0.40"); EXPECT_DBL(0.02777777777777778);
3444 DFS("2.5"); EXPECT_DBL(0.08680555555555555);
3445 /* A colon acts as a decimal point */
3446 DFS("0:1"); EXPECT_DBL(0.0006944444444444445);
3447 DFS("0:20"); EXPECT_DBL(0.01388888888888889);
3448 DFS("0:40"); EXPECT_DBL(0.02777777777777778);
3449 DFS("3:5"); EXPECT_DBL(0.1284722222222222);
3450 /* Check the am/pm limits */
3451 DFS("00:00 AM"); EXPECT_DBL(0.0);
3452 DFS("00:00 a"); EXPECT_DBL(0.0);
3453 DFS("12:59 AM"); EXPECT_DBL(0.04097222222222222);
3454 DFS("12:59 A"); EXPECT_DBL(0.04097222222222222);
3455 DFS("00:00 pm"); EXPECT_DBL(0.5);
3456 DFS("00:00 p"); EXPECT_DBL(0.5);
3457 DFS("12:59 pm"); EXPECT_DBL(0.5409722222222222);
3458 DFS("12:59 p"); EXPECT_DBL(0.5409722222222222);
3459 /* AM/PM is ignored if hours > 12 */
3460 DFS("13:00 AM"); EXPECT_DBL(0.5416666666666666);
3461 DFS("13:00 PM"); EXPECT_DBL(0.5416666666666666);
3463 /* Space, dash and slash all indicate a date format. */
3464 /* If both numbers are valid month values => month/day of current year */
3465 DFS("1 2"); MKRELDATE(2,1); EXPECT_DBL(relative
);
3466 DFS("2 1"); MKRELDATE(1,2); EXPECT_DBL(relative
);
3467 /* one number not valid month, is a valid day, other number valid month:
3468 * that number becomes the day.
3470 DFS("14 1"); MKRELDATE(14,1); EXPECT_DBL(relative
);
3471 DFS("1 14"); EXPECT_DBL(relative
);
3472 /* If the numbers can't be day/month, they are assumed to be year/month */
3473 DFS("30 2"); EXPECT_DBL(10990.0);
3474 DFS("2 30"); EXPECT_DBL(10990.0);
3475 DFS("32 49"); EXPECT_MISMATCH
; /* Can't be any format */
3476 DFS("0 49"); EXPECT_MISMATCH
; /* Can't be any format */
3477 /* If a month name is given the other number is the day */
3478 DFS("Jan 2"); MKRELDATE(2,1); EXPECT_DBL(relative
);
3479 DFS("2 Jan"); EXPECT_DBL(relative
);
3480 /* Unless it can't be, in which case it becomes the year */
3481 DFS("Jan 35"); EXPECT_DBL(12785.0);
3482 DFS("35 Jan"); EXPECT_DBL(12785.0);
3483 DFS("Jan-35"); EXPECT_DBL(12785.0);
3484 DFS("35-Jan"); EXPECT_DBL(12785.0);
3485 DFS("Jan/35"); EXPECT_DBL(12785.0);
3486 DFS("35/Jan"); EXPECT_DBL(12785.0);
3488 /* 3 numbers and time separator => h:m:s */
3489 DFS("0.1.0"); EXPECT_DBL(0.0006944444444444445);
3490 DFS("1.5.2"); EXPECT_DBL(0.04516203703703704);
3491 /* 3 numbers => picks date giving preference to lcid format */
3492 DFS("1 2 3"); EXPECT_DBL(37623.0);
3493 DFS("14 2 3"); EXPECT_DBL(41673.0);
3494 DFS("2 14 3"); EXPECT_DBL(37666.0);
3495 DFS("2 3 14"); EXPECT_DBL(41673.0);
3496 DFS("32 2 3"); EXPECT_DBL(11722.0);
3497 DFS("2 3 32"); EXPECT_DBL(11722.0);
3498 DFS("1 2 29"); EXPECT_DBL(47120.0);
3499 /* After 30, two digit dates are expected to be in the 1900's */
3500 DFS("1 2 30"); EXPECT_DBL(10960.0);
3501 DFS("1 2 31"); EXPECT_DBL(11325.0);
3502 DFS("3 am 1 2"); MKRELDATE(2,1); relative
+= 0.125; EXPECT_DBL(relative
);
3503 DFS("1 2 3 am"); EXPECT_DBL(relative
);
3505 /* 4 elements -interpreted as 2 digit date & time */
3506 DFS("1.2 3 4"); MKRELDATE(4,3); relative
+= 0.04305555556; EXPECT_DBL(relative
);
3507 DFS("3 4 1.2"); EXPECT_DBL(relative
);
3508 /* 5 elements - interpreted as 2 & 3 digit date/times */
3509 DFS("1.2.3 4 5"); MKRELDATE(5,4); relative
+= 0.04309027778; EXPECT_DBL(relative
);
3510 DFS("1.2 3 4 5"); EXPECT_DBL(38415.04305555556);
3512 /* following throws an exception on winME */
3513 DFS("1 2 3.4.5"); MKRELDATE(2,1); relative
+= 0.12783564815; EXPECT_DBL(relative
);
3515 DFS("1 2 3 4.5"); EXPECT_DBL(37623.17013888889);
3516 /* 6 elements - interpreted as 3 digit date/times */
3517 DFS("1.2.3 4 5 6"); EXPECT_DBL(38812.04309027778);
3518 DFS("1 2 3 4.5.6"); EXPECT_DBL(37623.17020833334);
3520 for (i
= 0; i
< sizeof(BadDateStrings
)/sizeof(char*); i
++)
3522 DFS(BadDateStrings
[i
]); EXPECT_MISMATCH
;
3525 /* Some normal-ish strings */
3526 DFS("2 January, 1970"); EXPECT_DBL(25570.0);
3527 DFS("2 January 1970"); EXPECT_DBL(25570.0);
3528 DFS("2 Jan 1970"); EXPECT_DBL(25570.0);
3529 DFS("2/Jan/1970"); EXPECT_DBL(25570.0);
3530 DFS("2-Jan-1970"); EXPECT_DBL(25570.0);
3531 DFS("1 2 1970"); EXPECT_DBL(25570.0);
3532 DFS("1/2/1970"); EXPECT_DBL(25570.0);
3533 DFS("1-2-1970"); EXPECT_DBL(25570.0);
3534 DFS("13-1-1970"); EXPECT_DBL(25581.0);
3535 DFS("1970-1-13"); EXPECT_DBL(25581.0);
3536 /* Native fails "1999 January 3, 9AM". I consider that a bug in native */
3538 /* test a non-english data string */
3539 DFS("02.01.1970"); EXPECT_MISMATCH
;
3540 DFS("02.01.1970 00:00:00"); EXPECT_MISMATCH
;
3541 lcid
= MAKELCID(MAKELANGID(LANG_GERMAN
,SUBLANG_GERMAN
),SORT_DEFAULT
);
3542 DFS("02.01.1970"); EXPECT_DBL(25570.0);
3543 DFS("02.13.1970"); EXPECT_DBL(25612.0);
3544 DFS("02-13-1970"); EXPECT_DBL(25612.0);
3545 DFS("2020-01-11"); EXPECT_DBL(43841.0);
3546 DFS("2173-10-14"); EXPECT_DBL(100000.0);
3548 DFS("02.01.1970 00:00:00"); EXPECT_DBL(25570.0);
3549 lcid
= MAKELCID(MAKELANGID(LANG_SPANISH
,SUBLANG_SPANISH
),SORT_DEFAULT
);
3550 DFS("02.01.1970"); EXPECT_MISMATCH
;
3551 DFS("02.01.1970 00:00:00"); EXPECT_MISMATCH
;
3554 static void test_VarDateCopy(void)
3556 COPYTEST(77665544.0, VT_DATE
, V_DATE(&vSrc
), V_DATE(&vDst
), V_DATEREF(&vSrc
),
3557 V_DATEREF(&vDst
), "%16.16g");
3560 static const char* wtoascii(LPWSTR lpszIn
)
3562 static char buff
[256];
3563 WideCharToMultiByte(CP_ACP
, 0, lpszIn
, -1, buff
, sizeof(buff
), NULL
, NULL
);
3567 static void test_VarDateChangeTypeEx(void)
3569 static const WCHAR sz25570
[] = {
3570 '1','/','2','/','1','9','7','0','\0' };
3571 static const WCHAR sz25570_2
[] = {
3572 '1','/','2','/','7','0','\0' };
3573 static const WCHAR sz25570Nls
[] = {
3574 '1','/','2','/','1','9','7','0',' ','1','2',':','0','0',':','0','0',' ','A','M','\0' };
3577 VARIANTARG vSrc
, vDst
;
3582 #ifdef HAS_UINT64_TO_FLOAT
3583 INITIAL_TYPETEST(VT_DATE
, V_DATE
, "%g");
3587 V_VT(&vDst
) = VT_EMPTY
;
3588 V_VT(&vSrc
) = VT_DATE
;
3589 V_DATE(&vSrc
) = 25570.0;
3590 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
3592 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, VARIANT_NOUSEROVERRIDE
, VT_BSTR
);
3593 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_BSTR
&& V_BSTR(&vDst
) &&
3594 (!lstrcmpW(V_BSTR(&vDst
), sz25570
) || !lstrcmpW(V_BSTR(&vDst
), sz25570_2
)),
3595 "hres=0x%X, type=%d (should be VT_BSTR), *bstr=%s\n",
3596 hres
, V_VT(&vDst
), V_BSTR(&vDst
) ? wtoascii(V_BSTR(&vDst
)) : "?");
3597 VariantClear(&vDst
);
3599 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
3602 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, VARIANT_NOUSEROVERRIDE
|VARIANT_USE_NLS
, VT_BSTR
);
3603 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_BSTR
&& V_BSTR(&vDst
) && !lstrcmpW(V_BSTR(&vDst
), sz25570Nls
),
3604 "hres=0x%X, type=%d (should be VT_BSTR), *bstr=%s\n",
3605 hres
, V_VT(&vDst
), V_BSTR(&vDst
) ? wtoascii(V_BSTR(&vDst
)) : "?");
3606 VariantClear(&vDst
);
3615 #define CONV_TYPE CY
3617 #define EXPECTCY(x) \
3618 ok((hres == S_OK && out.int64 == (LONGLONG)(x*CY_MULTIPLIER)), \
3619 "expected " #x "*CY_MULTIPLIER, got (%8x %8x); hres=0x%08x\n", S(out).Hi, S(out).Lo, hres)
3621 #define EXPECTCY64(x,y) \
3622 ok(hres == S_OK && S(out).Hi == (LONG)x && S(out).Lo == y, \
3623 "expected " #x " " #y " (%u,%u), got (%u,%u); hres=0x%08x\n", \
3624 (ULONG)(x), (ULONG)(y), S(out).Hi, S(out).Lo, hres)
3626 static void test_VarCyFromI1(void)
3628 CONVVARS(signed char);
3631 CHECKPTR(VarCyFromI1
);
3632 for (i
= -128; i
< 128; i
++)
3634 CONVERT(VarCyFromI1
,i
); EXPECTCY(i
);
3638 static void test_VarCyFromUI1(void)
3643 CHECKPTR(VarCyFromUI1
);
3644 for (i
= 0; i
< 256; i
++)
3646 CONVERT(VarCyFromUI1
,i
); EXPECTCY(i
);
3650 static void test_VarCyFromI2(void)
3655 CHECKPTR(VarCyFromI2
);
3656 for (i
= -16384; i
< 16384; i
++)
3658 CONVERT(VarCyFromI2
,i
); EXPECTCY(i
);
3662 static void test_VarCyFromUI2(void)
3667 CHECKPTR(VarCyFromUI2
);
3668 for (i
= 0; i
< 32768; i
++)
3670 CONVERT(VarCyFromUI2
,i
); EXPECTCY(i
);
3674 static void test_VarCyFromI4(void)
3678 CHECKPTR(VarCyFromI4
);
3679 CONVERT(VarCyFromI4
, -1); EXPECTCY(-1);
3680 CONVERT(VarCyFromI4
, 0); EXPECTCY(0);
3681 CONVERT(VarCyFromI4
, 1); EXPECTCY(1);
3682 CONVERT(VarCyFromI4
, 0x7fffffff); EXPECTCY64(0x1387, 0xffffd8f0);
3683 CONVERT(VarCyFromI4
, 0x80000000); EXPECTCY64(0xffffec78, 0);
3686 static void test_VarCyFromUI4(void)
3688 CONVVARS(unsigned int);
3690 CHECKPTR(VarCyFromUI4
);
3691 CONVERT(VarCyFromUI4
, 0); EXPECTCY(0);
3692 CONVERT(VarCyFromUI4
, 1); EXPECTCY(1);
3693 CONVERT(VarCyFromUI4
, 0x80000000); EXPECTCY64(5000, 0);
3696 static void test_VarCyFromR4(void)
3700 CHECKPTR(VarCyFromR4
);
3701 CONVERT(VarCyFromR4
, -1.0f
); EXPECTCY(-1);
3702 CONVERT(VarCyFromR4
, 0.0f
); EXPECTCY(0);
3703 CONVERT(VarCyFromR4
, 1.0f
); EXPECTCY(1);
3704 CONVERT(VarCyFromR4
, 1.5f
); EXPECTCY(1.5);
3706 CONVERT(VarCyFromR4
, -1.5f
); EXPECTCY(-1.5);
3707 CONVERT(VarCyFromR4
, -0.6f
); EXPECTCY(-0.6);
3708 CONVERT(VarCyFromR4
, -0.5f
); EXPECTCY(-0.5);
3709 CONVERT(VarCyFromR4
, -0.4f
); EXPECTCY(-0.4);
3710 CONVERT(VarCyFromR4
, 0.4f
); EXPECTCY(0.4);
3711 CONVERT(VarCyFromR4
, 0.5f
); EXPECTCY(0.5);
3712 CONVERT(VarCyFromR4
, 0.6f
); EXPECTCY(0.6);
3713 CONVERT(VarCyFromR4
, 1.5f
); EXPECTCY(1.5);
3714 CONVERT(VarCyFromR4
, 1.00009f
); EXPECTCY(1.0001);
3715 CONVERT(VarCyFromR4
, -1.00001f
); EXPECTCY(-1);
3716 CONVERT(VarCyFromR4
, -1.00005f
); EXPECTCY(-1);
3717 CONVERT(VarCyFromR4
, -0.00009f
); EXPECTCY(-0.0001);
3718 CONVERT(VarCyFromR4
, -0.00005f
); EXPECTCY(0);
3719 CONVERT(VarCyFromR4
, -0.00001f
); EXPECTCY(0);
3720 CONVERT(VarCyFromR4
, 0.00001f
); EXPECTCY(0);
3721 CONVERT(VarCyFromR4
, 0.00005f
); EXPECTCY(0);
3722 CONVERT(VarCyFromR4
, 0.00009f
); EXPECTCY(0.0001);
3723 CONVERT(VarCyFromR4
, -1.00001f
); EXPECTCY(-1);
3724 CONVERT(VarCyFromR4
, -1.00005f
); EXPECTCY(-1);
3725 CONVERT(VarCyFromR4
, -1.00009f
); EXPECTCY(-1.0001);
3728 static void test_VarCyFromR8(void)
3732 CHECKPTR(VarCyFromR8
);
3734 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3735 /* Test our rounding is exactly the same. This fails if the special x86
3736 * code is taken out of VarCyFromR8.
3738 CONVERT(VarCyFromR8
, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
3741 CONVERT(VarCyFromR8
, -4611686018427388416.1); EXPECT_OVERFLOW
;
3742 CONVERT(VarCyFromR8
, -1.0); EXPECTCY(-1);
3743 CONVERT(VarCyFromR8
, -0.0); EXPECTCY(0);
3744 CONVERT(VarCyFromR8
, 1.0); EXPECTCY(1);
3745 CONVERT(VarCyFromR8
, 4611686018427387648.0); EXPECT_OVERFLOW
;
3748 CONVERT(VarCyFromR8
, -1.5f
); EXPECTCY(-1.5);
3749 CONVERT(VarCyFromR8
, -0.6f
); EXPECTCY(-0.6);
3750 CONVERT(VarCyFromR8
, -0.5f
); EXPECTCY(-0.5);
3751 CONVERT(VarCyFromR8
, -0.4f
); EXPECTCY(-0.4);
3752 CONVERT(VarCyFromR8
, 0.4f
); EXPECTCY(0.4);
3753 CONVERT(VarCyFromR8
, 0.5f
); EXPECTCY(0.5);
3754 CONVERT(VarCyFromR8
, 0.6f
); EXPECTCY(0.6);
3755 CONVERT(VarCyFromR8
, 1.5f
); EXPECTCY(1.5);
3756 CONVERT(VarCyFromR8
, 1.00009f
); EXPECTCY(1.0001);
3757 CONVERT(VarCyFromR8
, -1.00001f
); EXPECTCY(-1);
3758 CONVERT(VarCyFromR8
, -1.00005f
); EXPECTCY(-1);
3759 CONVERT(VarCyFromR8
, -0.00009f
); EXPECTCY(-0.0001);
3760 CONVERT(VarCyFromR8
, -0.00005f
); EXPECTCY(0);
3761 CONVERT(VarCyFromR8
, -0.00001f
); EXPECTCY(0);
3762 CONVERT(VarCyFromR8
, 0.00001f
); EXPECTCY(0);
3763 CONVERT(VarCyFromR8
, 0.00005f
); EXPECTCY(0);
3764 CONVERT(VarCyFromR8
, 0.00009f
); EXPECTCY(0.0001);
3765 CONVERT(VarCyFromR8
, -1.00001f
); EXPECTCY(-1);
3766 CONVERT(VarCyFromR8
, -1.00005f
); EXPECTCY(-1);
3767 CONVERT(VarCyFromR8
, -1.00009f
); EXPECTCY(-1.0001);
3770 static void test_VarCyFromBool(void)
3772 CONVVARS(VARIANT_BOOL
);
3775 CHECKPTR(VarCyFromBool
);
3776 for (i
= -32768; i
< 32768; i
++)
3778 CONVERT(VarCyFromBool
, i
); EXPECTCY(i
);
3782 static void test_VarCyFromI8(void)
3786 CHECKPTR(VarCyFromI8
);
3787 CONVERT_I8(VarCyFromI8
, -214749, 2728163227ul); EXPECT_OVERFLOW
;
3788 CONVERT_I8(VarCyFromI8
, -214749, 2728163228ul); EXPECTCY64(2147483648ul,15808);
3789 CONVERT(VarCyFromI8
, -1); EXPECTCY(-1);
3790 CONVERT(VarCyFromI8
, 0); EXPECTCY(0);
3791 CONVERT(VarCyFromI8
, 1); EXPECTCY(1);
3792 CONVERT_I8(VarCyFromI8
, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3793 CONVERT_I8(VarCyFromI8
, 214748, 1566804069); EXPECT_OVERFLOW
;
3796 static void test_VarCyFromUI8(void)
3800 CHECKPTR(VarCyFromUI8
);
3801 CONVERT(VarCyFromUI8
, 0); EXPECTCY(0);
3802 CONVERT(VarCyFromUI8
, 1); EXPECTCY(1);
3803 CONVERT_I8(VarCyFromUI8
, 214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3804 CONVERT_I8(VarCyFromUI8
, 214748, 1566804069); EXPECTCY64(2147483647ul, 4294961488ul);
3805 CONVERT_I8(VarCyFromUI8
, 214748, 1566804070); EXPECT_OVERFLOW
;
3806 CONVERT_I8(VarCyFromUI8
, 214749, 1566804068); EXPECT_OVERFLOW
;
3809 static void test_VarCyFromDec(void)
3813 CHECKPTR(VarCyFromDec
);
3815 CONVERT_BADDEC(VarCyFromDec
);
3817 CONVERT_DEC(VarCyFromDec
,0,0x80,0,1); EXPECTCY(-1);
3818 CONVERT_DEC(VarCyFromDec
,0,0,0,0); EXPECTCY(0);
3819 CONVERT_DEC(VarCyFromDec
,0,0,0,1); EXPECTCY(1);
3821 CONVERT_DEC64(VarCyFromDec
,0,0,0,214748, 1566804068); EXPECTCY64(2147483647ul, 4294951488ul);
3822 CONVERT_DEC64(VarCyFromDec
,0,0,0,214748, 1566804069); EXPECTCY64(2147483647ul, 4294961488ul);
3823 CONVERT_DEC64(VarCyFromDec
,0,0,0,214748, 1566804070); EXPECT_OVERFLOW
;
3824 CONVERT_DEC64(VarCyFromDec
,0,0,0,214749, 1566804068); EXPECT_OVERFLOW
;
3826 CONVERT_DEC(VarCyFromDec
,2,0,0,100); EXPECTCY(1);
3827 CONVERT_DEC(VarCyFromDec
,2,0x80,0,100); EXPECTCY(-1);
3828 CONVERT_DEC(VarCyFromDec
,2,0x80,0,1); EXPECTCY(-0.01);
3829 CONVERT_DEC(VarCyFromDec
,2,0,0,1); EXPECTCY(0.01);
3830 CONVERT_DEC(VarCyFromDec
,2,0x80,0,1); EXPECTCY(-0.01);
3831 CONVERT_DEC(VarCyFromDec
,2,0,0,999); EXPECTCY(9.99);
3832 CONVERT_DEC(VarCyFromDec
,2,0x80,0,999); EXPECTCY(-9.99);
3833 CONVERT_DEC(VarCyFromDec
,2,0,0,1500); EXPECTCY(15);
3834 CONVERT_DEC(VarCyFromDec
,2,0x80,0,1500); EXPECTCY(-15);
3837 static void test_VarCyFromDate(void)
3841 CHECKPTR(VarCyFromDate
);
3843 #if defined(__i386__) && (defined(_MSC_VER) || defined(__GNUC__))
3844 CONVERT(VarCyFromR8
, -461168601842738.7904); EXPECTCY64(0xbfffffff, 0xffffff23);
3847 CONVERT(VarCyFromDate
, -1.0); EXPECTCY(-1);
3848 CONVERT(VarCyFromDate
, -0.0); EXPECTCY(0);
3849 CONVERT(VarCyFromDate
, 1.0); EXPECTCY(1);
3850 CONVERT(VarCyFromDate
, -4611686018427388416.1); EXPECT_OVERFLOW
;
3851 CONVERT(VarCyFromDate
, 4611686018427387648.0); EXPECT_OVERFLOW
;
3854 CONVERT(VarCyFromDate
, -1.5f
); EXPECTCY(-1.5);
3855 CONVERT(VarCyFromDate
, -0.6f
); EXPECTCY(-0.6);
3856 CONVERT(VarCyFromDate
, -0.5f
); EXPECTCY(-0.5);
3857 CONVERT(VarCyFromDate
, -0.4f
); EXPECTCY(-0.4);
3858 CONVERT(VarCyFromDate
, 0.4f
); EXPECTCY(0.4);
3859 CONVERT(VarCyFromDate
, 0.5f
); EXPECTCY(0.5);
3860 CONVERT(VarCyFromDate
, 0.6f
); EXPECTCY(0.6);
3861 CONVERT(VarCyFromDate
, 1.5f
); EXPECTCY(1.5);
3862 CONVERT(VarCyFromDate
, 1.00009f
); EXPECTCY(1.0001);
3863 CONVERT(VarCyFromDate
, -1.00001f
); EXPECTCY(-1);
3864 CONVERT(VarCyFromDate
, -1.00005f
); EXPECTCY(-1);
3865 CONVERT(VarCyFromDate
, -0.00009f
); EXPECTCY(-0.0001);
3866 CONVERT(VarCyFromDate
, -0.00005f
); EXPECTCY(0);
3867 CONVERT(VarCyFromDate
, -0.00001f
); EXPECTCY(0);
3868 CONVERT(VarCyFromDate
, 0.00001f
); EXPECTCY(0);
3869 CONVERT(VarCyFromDate
, 0.00005f
); EXPECTCY(0);
3870 CONVERT(VarCyFromDate
, 0.00009f
); EXPECTCY(0.0001);
3871 CONVERT(VarCyFromDate
, -1.00001f
); EXPECTCY(-1);
3872 CONVERT(VarCyFromDate
, -1.00005f
); EXPECTCY(-1);
3873 CONVERT(VarCyFromDate
, -1.00009f
); EXPECTCY(-1.0001);
3876 #define MATHVARS1 HRESULT hres; double left = 0.0; CY cyLeft, out
3877 #define MATHVARS2 MATHVARS1; double right = 0.0; CY cyRight
3878 #define MATH1(func, l) left = (double)l; pVarCyFromR8(left, &cyLeft); hres = p##func(cyLeft, &out)
3879 #define MATH2(func, l, r) left = (double)l; right = (double)r; \
3880 pVarCyFromR8(left, &cyLeft); pVarCyFromR8(right, &cyRight); \
3881 hres = p##func(cyLeft, cyRight, &out)
3883 static void test_VarCyAdd(void)
3888 MATH2(VarCyAdd
, 0.5, 0.5); EXPECTCY(1);
3889 MATH2(VarCyAdd
, 0.5, -0.4); EXPECTCY(0.1);
3890 MATH2(VarCyAdd
, 0.5, -0.6); EXPECTCY(-0.1);
3891 MATH2(VarCyAdd
, -0.5, -0.5); EXPECTCY(-1);
3892 MATH2(VarCyAdd
, -922337203685476.0, -922337203685476.0); EXPECT_OVERFLOW
;
3893 MATH2(VarCyAdd
, -922337203685476.0, 922337203685476.0); EXPECTCY(0);
3894 MATH2(VarCyAdd
, 922337203685476.0, -922337203685476.0); EXPECTCY(0);
3895 MATH2(VarCyAdd
, 922337203685476.0, 922337203685476.0); EXPECT_OVERFLOW
;
3898 static void test_VarCyMul(void)
3903 MATH2(VarCyMul
, 534443.0, 0.0); EXPECTCY(0);
3904 MATH2(VarCyMul
, 0.5, 0.5); EXPECTCY(0.25);
3905 MATH2(VarCyMul
, 0.5, -0.4); EXPECTCY(-0.2);
3906 MATH2(VarCyMul
, 0.5, -0.6); EXPECTCY(-0.3);
3907 MATH2(VarCyMul
, -0.5, -0.5); EXPECTCY(0.25);
3908 MATH2(VarCyMul
, 922337203685476.0, 20000); EXPECT_OVERFLOW
;
3911 static void test_VarCySub(void)
3916 MATH2(VarCySub
, 0.5, 0.5); EXPECTCY(0);
3917 MATH2(VarCySub
, 0.5, -0.4); EXPECTCY(0.9);
3918 MATH2(VarCySub
, 0.5, -0.6); EXPECTCY(1.1);
3919 MATH2(VarCySub
, -0.5, -0.5); EXPECTCY(0);
3920 MATH2(VarCySub
, -922337203685476.0, -922337203685476.0); EXPECTCY(0);
3921 MATH2(VarCySub
, -922337203685476.0, 922337203685476.0); EXPECT_OVERFLOW
;
3922 MATH2(VarCySub
, 922337203685476.0, -922337203685476.0); EXPECT_OVERFLOW
;
3923 MATH2(VarCySub
, 922337203685476.0, 922337203685476.0); EXPECTCY(0);
3926 static void test_VarCyAbs(void)
3931 MATH1(VarCyAbs
, 0.5); EXPECTCY(0.5);
3932 MATH1(VarCyAbs
, -0.5); EXPECTCY(0.5);
3933 MATH1(VarCyAbs
, 922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3934 MATH1(VarCyAbs
, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3937 static void test_VarCyNeg(void)
3942 MATH1(VarCyNeg
, 0.5); EXPECTCY(-0.5);
3943 MATH1(VarCyNeg
, -0.5); EXPECTCY(0.5);
3944 MATH1(VarCyNeg
, 922337203685476.0); EXPECTCY64(2147483648ul,15808);
3945 MATH1(VarCyNeg
, -922337203685476.0); EXPECTCY64(2147483647ul,4294951488ul);
3948 #define MATHMULI4(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
3949 hres = pVarCyMulI4(cyLeft, right, &out)
3951 static void test_VarCyMulI4(void)
3956 CHECKPTR(VarCyMulI4
);
3957 MATHMULI4(534443.0, 0); EXPECTCY(0);
3958 MATHMULI4(0.5, 1); EXPECTCY(0.5);
3959 MATHMULI4(0.5, 2); EXPECTCY(1);
3960 MATHMULI4(922337203685476.0, 1); EXPECTCY64(2147483647ul,4294951488ul);
3961 MATHMULI4(922337203685476.0, 2); EXPECT_OVERFLOW
;
3964 #define MATHMULI8(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
3965 hres = pVarCyMulI8(cyLeft, right, &out)
3967 static void test_VarCyMulI8(void)
3972 CHECKPTR(VarCyMulI8
);
3973 MATHMULI8(534443.0, 0); EXPECTCY(0);
3974 MATHMULI8(0.5, 1); EXPECTCY(0.5);
3975 MATHMULI8(0.5, 2); EXPECTCY(1);
3976 MATHMULI8(922337203685476.0, 1); EXPECTCY64(2147483647ul,4294951488ul);
3977 MATHMULI8(922337203685476.0, 2); EXPECT_OVERFLOW
;
3980 #define MATHCMP(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); pVarCyFromR8(right, &cyRight); \
3981 hres = pVarCyCmp(cyLeft, cyRight)
3983 static void test_VarCyCmp(void)
3986 double left
= 0.0, right
= 0.0;
3990 MATHCMP(-1.0, -1.0); EXPECT_EQ
;
3991 MATHCMP(-1.0, 0.0); EXPECT_LT
;
3992 MATHCMP(-1.0, 1.0); EXPECT_LT
;
3993 MATHCMP(-1.0, 2.0); EXPECT_LT
;
3994 MATHCMP(0.0, 1.0); EXPECT_LT
;
3995 MATHCMP(0.0, 0.0); EXPECT_EQ
;
3996 MATHCMP(0.0, -1.0); EXPECT_GT
;
3997 MATHCMP(1.0, -1.0); EXPECT_GT
;
3998 MATHCMP(1.0, 0.0); EXPECT_GT
;
3999 MATHCMP(1.0, 1.0); EXPECT_EQ
;
4000 MATHCMP(1.0, 2.0); EXPECT_LT
;
4003 #define MATHCMPR8(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
4004 hres = pVarCyCmpR8(cyLeft, right);
4006 static void test_VarCyCmpR8(void)
4013 CHECKPTR(VarCyCmpR8
);
4014 MATHCMPR8(-1.0, -1.0); EXPECT_EQ
;
4015 MATHCMPR8(-1.0, 0.0); EXPECT_LT
;
4016 MATHCMPR8(-1.0, 1.0); EXPECT_LT
;
4017 MATHCMPR8(-1.0, 2.0); EXPECT_LT
;
4018 MATHCMPR8(0.0, 1.0); EXPECT_LT
;
4019 MATHCMPR8(0.0, 0.0); EXPECT_EQ
;
4020 MATHCMPR8(0.0, -1.0); EXPECT_GT
;
4021 MATHCMPR8(1.0, -1.0); EXPECT_GT
;
4022 MATHCMPR8(1.0, 0.0); EXPECT_GT
;
4023 MATHCMPR8(1.0, 1.0); EXPECT_EQ
;
4024 MATHCMPR8(1.0, 2.0); EXPECT_LT
;
4028 #define MATHRND(l, r) left = l; right = r; pVarCyFromR8(left, &cyLeft); \
4029 hres = pVarCyRound(cyLeft, right, &out)
4031 static void test_VarCyRound(void)
4036 CHECKPTR(VarCyRound
);
4037 MATHRND(0.5432, 5); EXPECTCY(0.5432);
4038 MATHRND(0.5432, 4); EXPECTCY(0.5432);
4039 MATHRND(0.5432, 3); EXPECTCY(0.543);
4040 MATHRND(0.5432, 2); EXPECTCY(0.54);
4041 MATHRND(0.5432, 1); EXPECTCY(0.5);
4042 MATHRND(0.5532, 0); EXPECTCY(1);
4043 MATHRND(0.5532, -1); EXPECT_INVALID
;
4045 MATHRND(0.5568, 5); EXPECTCY(0.5568);
4046 MATHRND(0.5568, 4); EXPECTCY(0.5568);
4047 MATHRND(0.5568, 3); EXPECTCY(0.557);
4048 MATHRND(0.5568, 2); EXPECTCY(0.56);
4049 MATHRND(0.5568, 1); EXPECTCY(0.6);
4050 MATHRND(0.5568, 0); EXPECTCY(1);
4051 MATHRND(0.5568, -1); EXPECT_INVALID
;
4053 MATHRND(0.4999, 0); EXPECTCY(0);
4054 MATHRND(0.5000, 0); EXPECTCY(0);
4055 MATHRND(0.5001, 0); EXPECTCY(1);
4056 MATHRND(1.4999, 0); EXPECTCY(1);
4057 MATHRND(1.5000, 0); EXPECTCY(2);
4058 MATHRND(1.5001, 0); EXPECTCY(2);
4061 #define MATHFIX(l) left = l; pVarCyFromR8(left, &cyLeft); \
4062 hres = pVarCyFix(cyLeft, &out)
4064 static void test_VarCyFix(void)
4069 MATHFIX(-1.0001); EXPECTCY(-1);
4070 MATHFIX(-1.4999); EXPECTCY(-1);
4071 MATHFIX(-1.5001); EXPECTCY(-1);
4072 MATHFIX(-1.9999); EXPECTCY(-1);
4073 MATHFIX(-0.0001); EXPECTCY(0);
4074 MATHFIX(-0.4999); EXPECTCY(0);
4075 MATHFIX(-0.5001); EXPECTCY(0);
4076 MATHFIX(-0.9999); EXPECTCY(0);
4077 MATHFIX(0.0001); EXPECTCY(0);
4078 MATHFIX(0.4999); EXPECTCY(0);
4079 MATHFIX(0.5001); EXPECTCY(0);
4080 MATHFIX(0.9999); EXPECTCY(0);
4081 MATHFIX(1.0001); EXPECTCY(1);
4082 MATHFIX(1.4999); EXPECTCY(1);
4083 MATHFIX(1.5001); EXPECTCY(1);
4084 MATHFIX(1.9999); EXPECTCY(1);
4087 #define MATHINT(l) left = l; pVarCyFromR8(left, &cyLeft); \
4088 hres = pVarCyInt(cyLeft, &out)
4090 static void test_VarCyInt(void)
4095 MATHINT(-1.0001); EXPECTCY(-2);
4096 MATHINT(-1.4999); EXPECTCY(-2);
4097 MATHINT(-1.5001); EXPECTCY(-2);
4098 MATHINT(-1.9999); EXPECTCY(-2);
4099 MATHINT(-0.0001); EXPECTCY(-1);
4100 MATHINT(-0.4999); EXPECTCY(-1);
4101 MATHINT(-0.5001); EXPECTCY(-1);
4102 MATHINT(-0.9999); EXPECTCY(-1);
4103 MATHINT(0.0001); EXPECTCY(0);
4104 MATHINT(0.4999); EXPECTCY(0);
4105 MATHINT(0.5001); EXPECTCY(0);
4106 MATHINT(0.9999); EXPECTCY(0);
4107 MATHINT(1.0001); EXPECTCY(1);
4108 MATHINT(1.4999); EXPECTCY(1);
4109 MATHINT(1.5001); EXPECTCY(1);
4110 MATHINT(1.9999); EXPECTCY(1);
4118 #define CONV_TYPE DECIMAL
4120 #define EXPECTDEC(scl, sgn, hi, lo) ok(hres == S_OK && \
4121 S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
4122 out.Hi32 == (ULONG)(hi) && U1(out).Lo64 == (ULONG64)(lo), \
4123 "expected (%d,%d,%d,(%x %x)), got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
4124 scl, sgn, hi, (LONG)((LONG64)(lo) >> 32), (LONG)((lo) & 0xffffffff), S(U(out)).scale, \
4125 S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
4127 #define EXPECTDEC64(scl, sgn, hi, mid, lo) ok(hres == S_OK && \
4128 S(U(out)).scale == (BYTE)(scl) && S(U(out)).sign == (BYTE)(sgn) && \
4129 out.Hi32 == (ULONG)(hi) && S1(U1(out)).Mid32 == (ULONG)(mid) && \
4130 S1(U1(out)).Lo32 == (ULONG)(lo), \
4131 "expected (%d,%d,%d,(%x %x)), got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
4132 scl, sgn, hi, (LONG)(mid), (LONG)(lo), S(U(out)).scale, \
4133 S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
4135 /* expect either a positive or negative zero */
4136 #define EXPECTDECZERO() ok(hres == S_OK && S(U(out)).scale == 0 && \
4137 (S(U(out)).sign == 0 || S(U(out)).sign == 0x80) && out.Hi32 == 0 && U1(out).Lo64 == 0, \
4138 "expected zero, got (%d,%d,%d,(%x %x)) hres 0x%08x\n", \
4139 S(U(out)).scale, S(U(out)).sign, out.Hi32, S1(U1(out)).Mid32, S1(U1(out)).Lo32, hres)
4141 #define EXPECTDECI if (i < 0) EXPECTDEC(0, 0x80, 0, -i); else EXPECTDEC(0, 0, 0, i)
4143 static void test_VarDecFromI1(void)
4145 CONVVARS(signed char);
4148 CHECKPTR(VarDecFromI1
);
4149 for (i
= -128; i
< 128; i
++)
4151 CONVERT(VarDecFromI1
,i
); EXPECTDECI
;
4155 static void test_VarDecFromI2(void)
4160 CHECKPTR(VarDecFromI2
);
4161 for (i
= -32768; i
< 32768; i
++)
4163 CONVERT(VarDecFromI2
,i
); EXPECTDECI
;
4167 static void test_VarDecFromI4(void)
4172 CHECKPTR(VarDecFromI4
);
4173 for (i
= -32768; i
< 32768; i
++)
4175 CONVERT(VarDecFromI4
,i
); EXPECTDECI
;
4179 static void test_VarDecFromI8(void)
4184 CHECKPTR(VarDecFromI8
);
4185 for (i
= -32768; i
< 32768; i
++)
4187 CONVERT(VarDecFromI8
,i
); EXPECTDECI
;
4191 static void test_VarDecFromUI1(void)
4196 CHECKPTR(VarDecFromUI1
);
4197 for (i
= 0; i
< 256; i
++)
4199 CONVERT(VarDecFromUI1
,i
); EXPECTDECI
;
4203 static void test_VarDecFromUI2(void)
4208 CHECKPTR(VarDecFromUI2
);
4209 for (i
= 0; i
< 65536; i
++)
4211 CONVERT(VarDecFromUI2
,i
); EXPECTDECI
;
4215 static void test_VarDecFromUI4(void)
4220 CHECKPTR(VarDecFromUI4
);
4221 for (i
= 0; i
< 65536; i
++)
4223 CONVERT(VarDecFromUI4
,i
); EXPECTDECI
;
4227 static void test_VarDecFromUI8(void)
4232 CHECKPTR(VarDecFromUI8
);
4233 for (i
= 0; i
< 65536; i
++)
4235 CONVERT(VarDecFromUI8
,i
); EXPECTDECI
;
4239 static void test_VarDecFromBool(void)
4244 CHECKPTR(VarDecFromBool
);
4245 /* Test all possible type values. Note that the result is reduced to 0 or -1 */
4246 for (i
= -32768; i
< 0; i
++)
4248 CONVERT(VarDecFromBool
,i
);
4250 EXPECTDEC(0,0x80,0,1);
4256 static void test_VarDecFromR4(void)
4260 CHECKPTR(VarDecFromR4
);
4262 CONVERT(VarDecFromR4
,-0.6f
); EXPECTDEC(1,0x80,0,6);
4263 CONVERT(VarDecFromR4
,-0.5f
); EXPECTDEC(1,0x80,0,5);
4264 CONVERT(VarDecFromR4
,-0.4f
); EXPECTDEC(1,0x80,0,4);
4265 CONVERT(VarDecFromR4
,0.0f
); EXPECTDEC(0,0,0,0);
4266 CONVERT(VarDecFromR4
,0.4f
); EXPECTDEC(1,0,0,4);
4267 CONVERT(VarDecFromR4
,0.5f
); EXPECTDEC(1,0,0,5);
4268 CONVERT(VarDecFromR4
,0.6f
); EXPECTDEC(1,0,0,6);
4271 static void test_VarDecFromR8(void)
4275 CHECKPTR(VarDecFromR8
);
4277 CONVERT(VarDecFromR8
,-0.6); EXPECTDEC(1,0x80,0,6);
4278 CONVERT(VarDecFromR8
,-0.5); EXPECTDEC(1,0x80,0,5);
4279 CONVERT(VarDecFromR8
,-0.4); EXPECTDEC(1,0x80,0,4);
4280 CONVERT(VarDecFromR8
,0.0); EXPECTDEC(0,0,0,0);
4281 CONVERT(VarDecFromR8
,0.4); EXPECTDEC(1,0,0,4);
4282 CONVERT(VarDecFromR8
,0.5); EXPECTDEC(1,0,0,5);
4283 CONVERT(VarDecFromR8
,0.6); EXPECTDEC(1,0,0,6);
4286 static void test_VarDecFromDate(void)
4290 CHECKPTR(VarDecFromDate
);
4292 CONVERT(VarDecFromDate
,-0.6); EXPECTDEC(1,0x80,0,6);
4293 CONVERT(VarDecFromDate
,-0.5); EXPECTDEC(1,0x80,0,5);
4294 CONVERT(VarDecFromDate
,-0.4); EXPECTDEC(1,0x80,0,4);
4295 CONVERT(VarDecFromDate
,0.0); EXPECTDEC(0,0,0,0);
4296 CONVERT(VarDecFromDate
,0.4); EXPECTDEC(1,0,0,4);
4297 CONVERT(VarDecFromDate
,0.5); EXPECTDEC(1,0,0,5);
4298 CONVERT(VarDecFromDate
,0.6); EXPECTDEC(1,0,0,6);
4301 static void test_VarDecFromStr(void)
4306 CHECKPTR(VarDecFromStr
);
4308 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
4310 CONVERT_STR(VarDecFromStr
,NULL
,0); EXPECT_MISMATCH
;
4311 CONVERT_STR(VarDecFromStr
,"-1", LOCALE_NOUSEROVERRIDE
); EXPECTDEC(0,0x80,0,1);
4312 CONVERT_STR(VarDecFromStr
,"0", LOCALE_NOUSEROVERRIDE
); EXPECTDEC(0,0,0,0);
4313 CONVERT_STR(VarDecFromStr
,"1", LOCALE_NOUSEROVERRIDE
); EXPECTDEC(0,0,0,1);
4314 CONVERT_STR(VarDecFromStr
,"0.5", LOCALE_NOUSEROVERRIDE
); EXPECTDEC(1,0,0,5);
4315 CONVERT_STR(VarDecFromStr
,"4294967296", LOCALE_NOUSEROVERRIDE
); EXPECTDEC64(0,0,0,1,0);
4316 CONVERT_STR(VarDecFromStr
,"18446744073709551616", LOCALE_NOUSEROVERRIDE
); EXPECTDEC(0,0,1,0);
4317 CONVERT_STR(VarDecFromStr
,"4294967296.0", LOCALE_NOUSEROVERRIDE
); EXPECTDEC64(0,0,0,1,0);
4318 CONVERT_STR(VarDecFromStr
,"18446744073709551616.0", LOCALE_NOUSEROVERRIDE
); EXPECTDEC(0,0,1,0);
4321 static void test_VarDecFromCy(void)
4325 CHECKPTR(VarDecFromCy
);
4327 CONVERT_CY(VarDecFromCy
, -1); EXPECTDEC(4,0x80,0,10000);
4328 CONVERT_CY(VarDecFromCy
, 0); EXPECTDEC(4,0,0,0);
4329 CONVERT_CY(VarDecFromCy
, 1); EXPECTDEC(4,0,0,10000);
4330 CONVERT_CY(VarDecFromCy
, 0.5); EXPECTDEC(4,0,0,5000);
4334 #define MATHVARS1 HRESULT hres; DECIMAL l, out
4336 #define MATHVARS2 MATHVARS1; DECIMAL r
4338 #define MATH1(func) hres = p##func(&l, &out)
4340 #define MATH2(func) hres = p##func(&l, &r, &out)
4342 #define MATH3(func) hres = p##func(&l, r)
4344 static void test_VarDecAbs(void)
4348 CHECKPTR(VarDecAbs
);
4349 SETDEC(l
,0,0x80,0,1); MATH1(VarDecAbs
); EXPECTDEC(0,0,0,1);
4350 SETDEC(l
,0,0,0,0); MATH1(VarDecAbs
); EXPECTDEC(0,0,0,0);
4351 SETDEC(l
,0,0x80,0,0); MATH1(VarDecAbs
); EXPECTDEC(0,0,0,0);
4352 SETDEC(l
,0,0,0,1); MATH1(VarDecAbs
); EXPECTDEC(0,0,0,1);
4354 /* Doesn't check for invalid input */
4355 SETDEC(l
,0,0x7f,0,1); MATH1(VarDecAbs
); EXPECTDEC(0,0x7f,0,1);
4356 SETDEC(l
,0,0x80,29,1); MATH1(VarDecAbs
); EXPECTDEC(0,0,29,1);
4359 static void test_VarDecNeg(void)
4363 CHECKPTR(VarDecNeg
);
4364 SETDEC(l
,0,0x80,0,1); MATH1(VarDecNeg
); EXPECTDEC(0,0,0,1);
4365 SETDEC(l
,0,0,0,0); MATH1(VarDecNeg
); EXPECTDEC(0,0x80,0,0); /* '-0'! */
4366 SETDEC(l
,0,0x80,0,0); MATH1(VarDecNeg
); EXPECTDEC(0,0,0,0);
4367 SETDEC(l
,0,0,0,1); MATH1(VarDecNeg
); EXPECTDEC(0,0x80,0,1);
4369 /* Doesn't check for invalid input */
4370 SETDEC(l
,0,0x7f,0,1); MATH1(VarDecNeg
); EXPECTDEC(0,0xff,0,1);
4371 SETDEC(l
,0,0x80,29,1); MATH1(VarDecNeg
); EXPECTDEC(0,0,29,1);
4372 SETDEC(l
,0,0,29,1); MATH1(VarDecNeg
); EXPECTDEC(0,0x80,29,1);
4375 static void test_VarDecAdd(void)
4379 CHECKPTR(VarDecAdd
);
4380 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,0); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,0);
4381 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0x80,0,1);
4382 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,1);
4384 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,0); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,1);
4385 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,2);
4386 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
); EXPECTDECZERO();
4387 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0x80,0,2); MATH2(VarDecAdd
); EXPECTDEC(0,0x80,0,1);
4389 SETDEC(l
,0,0x80,0,0); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,1);
4390 SETDEC(l
,0,0x80,0,1); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDECZERO();
4391 SETDEC(l
,0,0x80,0,1); SETDEC(r
,0,0,0,2); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,1);
4392 SETDEC(l
,0,0x80,0,1); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0x80,0,2);
4393 SETDEC(l
,0,0x80,0,2); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0x80,0,1);
4395 SETDEC(l
,0,0,0,0xffffffff); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,0xfffffffe);
4396 SETDEC(l
,0,0,0,0xffffffff); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,(ULONG64
)1 << 32);
4397 SETDEC(l
,0,0,0,0xffffffff); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0,(ULONG64
)1 << 32);
4399 SETDEC64(l
,0,0,0,0xffffffff,0); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC64(0,0,0,0xffffffff,1);
4400 SETDEC64(l
,0,0,0,0xffffffff,0); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
);
4401 EXPECTDEC64(0,0,0,0xfffffffe,0xffffffff);
4403 SETDEC64(l
,0,0,0,0xffffffff,0xffffffff); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,1,0);
4404 SETDEC64(l
,0,0,0,0xffffffff,0xffffffff); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
);
4405 EXPECTDEC64(0,0,0,0xffffffff,0xfffffffe);
4407 SETDEC(l
,0,0,0xffffffff,0); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(0,0,0xffffffff,1);
4408 SETDEC(l
,0,0,0xffffffff,0); SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
);
4409 EXPECTDEC64(0,0,0xfffffffe,0xffffffff,0xffffffff);
4411 SETDEC64(l
,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r
,0,0x80,0,1); MATH2(VarDecAdd
);
4412 EXPECTDEC64(0,0,0xffffffff,0xffffffff,0xfffffffe);
4413 SETDEC64(l
,0,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
);
4414 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4415 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4417 SETDEC64(l
,1,0,0xffffffff,0xffffffff,0xffffffff);SETDEC(r
,1,0,0,1); MATH2(VarDecAdd
);
4418 todo_wine
EXPECTDEC64(0,0,0x19999999,0x99999999,0x9999999A);
4420 SETDEC64(l
,0,0,0xe22ea493,0xb30310a7,0x70000000);SETDEC64(r
,0,0,0xe22ea493,0xb30310a7,0x70000000); MATH2(VarDecAdd
);
4421 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4422 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4424 SETDEC64(l
,1,0,0xe22ea493,0xb30310a7,0x70000000);SETDEC64(r
,1,0,0xe22ea493,0xb30310a7,0x70000000); MATH2(VarDecAdd
);
4425 todo_wine
EXPECTDEC64(0,0,0x2d3c8750,0xbd670354,0xb0000000);
4427 SETDEC(l
,3,128,0,123456); SETDEC64(r
,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
4428 MATH2(VarDecAdd
); EXPECTDEC64(0,0,-1,0xFFFFFFFF,0xFFFFFF84);
4430 SETDEC(l
,3,0,0,123456); SETDEC64(r
,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecAdd
);
4431 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4432 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4434 SETDEC(l
,4,0,0,123456); SETDEC64(r
,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecAdd
);
4435 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4436 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4438 SETDEC(l
,5,0,0,123456); SETDEC64(r
,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecAdd
);
4439 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4440 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4442 SETDEC(l
,6,0,0,123456); SETDEC64(r
,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
4443 MATH2(VarDecAdd
); EXPECTDEC64(0,0,-1,0xFFFFFFFF,0xFFFFFFFF);
4445 SETDEC(l
,3,128,0,123456); SETDEC64(r
,0,0,0x19999999,0x99999999,0x99999999);
4446 MATH2(VarDecAdd
); EXPECTDEC64(1,0,-1,0xFFFFFFFF,0xFFFFFB27);
4448 SETDEC(l
,3,128,0,123567); SETDEC64(r
,0,0,0x19999999,0x99999999,0x99999999);
4449 MATH2(VarDecAdd
); EXPECTDEC64(1,0,-1,0xFFFFFFFF,0xFFFFFB26);
4451 /* Promotes to the highest scale, so here the results are in the scale of 2 */
4452 SETDEC(l
,2,0,0,0); SETDEC(r
,0,0,0,0); MATH2(VarDecAdd
); EXPECTDEC(2,0,0,0);
4453 SETDEC(l
,2,0,0,100); SETDEC(r
,0,0,0,1); MATH2(VarDecAdd
); EXPECTDEC(2,0,0,200);
4456 static void test_VarDecSub(void)
4460 CHECKPTR(VarDecSub
);
4461 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,0); MATH2(VarDecSub
); EXPECTDECZERO();
4462 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,1); MATH2(VarDecSub
); EXPECTDEC(0,0x80,0,1);
4463 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,1); MATH2(VarDecSub
); EXPECTDECZERO();
4464 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0x80,0,1); MATH2(VarDecSub
); EXPECTDEC(0,0,0,2);
4467 static void test_VarDecMul(void)
4471 CHECKPTR(VarDecMul
);
4472 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,0); MATH2(VarDecMul
); EXPECTDEC(0,0,0,0);
4473 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,0); MATH2(VarDecMul
); EXPECTDEC(0,0,0,0);
4474 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,1); MATH2(VarDecMul
); EXPECTDEC(0,0,0,0);
4475 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,1); MATH2(VarDecMul
); EXPECTDEC(0,0,0,1);
4476 SETDEC(l
,0,0,0,45000);SETDEC(r
,0,0,0,2); MATH2(VarDecMul
); EXPECTDEC(0,0,0,90000);
4477 SETDEC(l
,0,0,0,2); SETDEC(r
,0,0,0,45000); MATH2(VarDecMul
); EXPECTDEC(0,0,0,90000);
4479 SETDEC(l
,0,0x80,0,2); SETDEC(r
,0,0,0,2); MATH2(VarDecMul
); EXPECTDEC(0,0x80,0,4);
4480 SETDEC(l
,0,0,0,2); SETDEC(r
,0,0x80,0,2); MATH2(VarDecMul
); EXPECTDEC(0,0x80,0,4);
4481 SETDEC(l
,0,0x80,0,2); SETDEC(r
,0,0x80,0,2); MATH2(VarDecMul
); EXPECTDEC(0,0,0,4);
4483 SETDEC(l
,4,0,0,2); SETDEC(r
,0,0,0,2); MATH2(VarDecMul
); EXPECTDEC(4,0,0,4);
4484 SETDEC(l
,0,0,0,2); SETDEC(r
,3,0,0,2); MATH2(VarDecMul
); EXPECTDEC(3,0,0,4);
4485 SETDEC(l
,4,0,0,2); SETDEC(r
,3,0,0,2); MATH2(VarDecMul
); EXPECTDEC(7,0,0,4);
4486 /* this last one shows that native oleaut32 does *not* gratuitously seize opportunities
4487 to reduce the scale if possible - the canonical result for the expected value is (6,0,0,1)
4489 SETDEC(l
,4,0,0,5); SETDEC(r
,3,0,0,2); MATH2(VarDecMul
); EXPECTDEC(7,0,0,10);
4491 SETDEC64(l
,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC(r
,0,0,0,2); MATH2(VarDecMul
); EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4492 SETDEC(l
,0,0,0,2); SETDEC64(r
,0,0,0,0xFFFFFFFF,0xFFFFFFFF); MATH2(VarDecMul
); EXPECTDEC64(0,0,1,0xFFFFFFFF,0xFFFFFFFE);
4493 SETDEC(l
,0,0,1,1); SETDEC(r
,0,0,0,0x80000000); MATH2(VarDecMul
); EXPECTDEC(0,0,0x80000000,0x80000000);
4494 SETDEC(l
,0,0,0,0x80000000); SETDEC(r
,0,0,1,1); MATH2(VarDecMul
); EXPECTDEC(0,0,0x80000000,0x80000000);
4496 /* near-overflow, used as a reference */
4497 SETDEC64(l
,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC(r
,0,0,0,2000000000); MATH2(VarDecMul
);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4498 /* actual overflow - right operand is 10 times the previous value */
4499 SETDEC64(l
,0,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r
,0,0,0,4,0xA817C800); MATH2(VarDecMul
);
4500 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4501 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4502 /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result */
4503 SETDEC64(l
,1,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r
,0,0,0,4,0xA817C800); MATH2(VarDecMul
);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4505 /* near-overflow, used as a reference */
4506 SETDEC64(l
,0,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC(r
,0,0,0,1000000000); MATH2(VarDecMul
);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4507 /* actual overflow - right operand is 10 times the previous value */
4508 SETDEC64(l
,0,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC64(r
,0,0,0,2,0x540BE400); MATH2(VarDecMul
);
4509 ok(hres
== DISP_E_OVERFLOW
,"Expected overflow, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4510 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4511 /* here, native oleaut32 has an opportunity to avert the overflow, by reducing the scale of the result */
4512 SETDEC64(l
,1,0,1,0xFFFFFFFF,0xFFFFFFFE); SETDEC64(r
,0,0,0,2,0x540BE400); MATH2(VarDecMul
);EXPECTDEC64(0,0,1999999999,0xFFFFFFFF,0x88CA6C00);
4514 /* this one shows that native oleaut32 is willing to lose significant digits in order to avert an overflow */
4515 SETDEC64(l
,2,0,0,0xFFFFFFFF,0xFFFFFFFF); SETDEC64(r
,0,0,0,9,0x502F9001); MATH2(VarDecMul
);EXPECTDEC64(1,0,0xee6b2800,0x19999998,0xab2e719a);
4518 static void test_VarDecDiv(void)
4522 CHECKPTR(VarDecDiv
);
4523 /* identity divisions */
4524 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,1); MATH2(VarDecDiv
); EXPECTDEC(0,0,0,0);
4525 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,1); MATH2(VarDecDiv
); EXPECTDEC(0,0,0,1);
4526 SETDEC(l
,1,0,0,1); SETDEC(r
,0,0,0,1); MATH2(VarDecDiv
); EXPECTDEC(1,0,0,1);
4528 /* exact divisions */
4529 SETDEC(l
,0,0,0,45); SETDEC(r
,0,0,0,9); MATH2(VarDecDiv
); EXPECTDEC(0,0,0,5);
4530 SETDEC(l
,1,0,0,45); SETDEC(r
,0,0,0,9); MATH2(VarDecDiv
); EXPECTDEC(1,0,0,5);
4531 SETDEC(l
,0,0,0,45); SETDEC(r
,1,0,0,9); MATH2(VarDecDiv
); EXPECTDEC(0,0,0,50);
4532 SETDEC(l
,1,0,0,45); SETDEC(r
,2,0,0,9); MATH2(VarDecDiv
); EXPECTDEC(0,0,0,50);
4533 /* these last three results suggest that native oleaut32 scales both operands down to zero
4534 before the division, but does not always try to scale the result, even if it is possible -
4535 analogous to multiplication behavior.
4537 SETDEC(l
,1,0,0,45); SETDEC(r
,1,0,0,9); MATH2(VarDecDiv
); EXPECTDEC(0,0,0,5);
4538 SETDEC(l
,2,0,0,450); SETDEC(r
,1,0,0,9); MATH2(VarDecDiv
);
4539 if (S(U(out
)).scale
== 1) EXPECTDEC(1,0,0,50);
4540 else EXPECTDEC(0,0,0,5);
4542 /* inexact divisions */
4543 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4544 SETDEC(l
,1,0,0,1); SETDEC(r
,0,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,18070036,0x35458014,0x4d555555);
4545 SETDEC(l
,0,0,0,1); SETDEC(r
,1,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4546 SETDEC(l
,1,0,0,1); SETDEC(r
,2,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,1807003620,0xcf2607ee,0x35555555);
4547 SETDEC(l
,1,0,0,1); SETDEC(r
,1,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4548 SETDEC(l
,2,0,0,10); SETDEC(r
,1,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,180700362,0x14b700cb,0x05555555);
4550 /* this one shows that native oleaut32 rounds up the result */
4551 SETDEC(l
,0,0,0,2); SETDEC(r
,0,0,0,3); MATH2(VarDecDiv
); EXPECTDEC64(28,0,361400724,0x296e0196,0x0aaaaaab);
4554 SETDEC(l
,0,0x80,0,45); SETDEC(r
,0,0,0,9); MATH2(VarDecDiv
); EXPECTDEC(0,0x80,0,5);
4555 SETDEC(l
,0,0,0,45); SETDEC(r
,0,0x80,0,9); MATH2(VarDecDiv
);EXPECTDEC(0,0x80,0,5);
4556 SETDEC(l
,0,0x80,0,45); SETDEC(r
,0,0x80,0,9); MATH2(VarDecDiv
);EXPECTDEC(0,0,0,5);
4559 SETDEC(l
,0,0,0,0); SETDEC(r
,0,0,0,0); MATH2(VarDecDiv
);/* indeterminate */
4560 ok(hres
== DISP_E_DIVBYZERO
,"Expected division-by-zero, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4561 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4562 SETDEC(l
,0,0,0,1); SETDEC(r
,0,0,0,0); MATH2(VarDecDiv
);/* division by zero */
4563 ok(hres
== DISP_E_DIVBYZERO
,"Expected division-by-zero, got (%d,%d,%d,(%8x,%8x)x) hres 0x%08x\n",
4564 S(U(out
)).scale
, S(U(out
)).sign
, out
.Hi32
, S1(U1(out
)).Mid32
, S1(U1(out
)).Lo32
, hres
);
4568 static void test_VarDecCmp(void)
4572 CHECKPTR(VarDecCmp
);
4574 SETDEC(l
,0,0,0,1); SETDEC(out
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_EQ
;
4575 SETDEC(l
,0,0,0,1); SETDEC(out
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4576 SETDEC(l
,0,0,0,1); SETDEC(out
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4578 SETDEC(l
,0,0,0,1); SETDEC(out
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4579 SETDEC(l
,0,0,0,1); SETDEC(out
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4580 SETDEC(l
,0,0,0,1); SETDEC(out
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4582 SETDEC(l
,0,DECIMAL_NEG
,0,1); SETDEC(out
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4583 SETDEC(l
,0,DECIMAL_NEG
,0,1); SETDEC(out
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4584 SETDEC(l
,0,DECIMAL_NEG
,0,1); SETDEC(out
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4586 SETDEC(l
,0,DECIMAL_NEG
,0,1); SETDEC(out
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_EQ
;
4587 SETDEC(l
,0,DECIMAL_NEG
,0,1); SETDEC(out
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4588 SETDEC(l
,0,DECIMAL_NEG
,0,1); SETDEC(out
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4590 SETDEC(l
,0,0,0,0); SETDEC(out
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4591 SETDEC(l
,0,0,0,0); SETDEC(out
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4592 SETDEC(l
,0,0,0,0); SETDEC(out
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4594 SETDEC(l
,0,0,0,0); SETDEC(out
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4595 SETDEC(l
,0,0,0,0); SETDEC(out
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4596 SETDEC(l
,0,0,0,0); SETDEC(out
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4598 SETDEC(l
,0,DECIMAL_NEG
,0,0); SETDEC(out
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4599 SETDEC(l
,0,DECIMAL_NEG
,0,0); SETDEC(out
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4600 SETDEC(l
,0,DECIMAL_NEG
,0,0); SETDEC(out
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4602 SETDEC(l
,0,DECIMAL_NEG
,0,0); SETDEC(out
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4603 SETDEC(l
,0,DECIMAL_NEG
,0,0); SETDEC(out
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4604 SETDEC(l
,0,DECIMAL_NEG
,0,0); SETDEC(out
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4606 SETDEC(l
,0,0,-1,-1); SETDEC(out
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4607 SETDEC(l
,0,0,-1,-1); SETDEC(out
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4608 SETDEC(l
,0,0,-1,-1); SETDEC(out
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_EQ
;
4610 SETDEC(l
,0,0,-1,-1); SETDEC(out
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4611 SETDEC(l
,0,0,-1,-1); SETDEC(out
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4612 SETDEC(l
,0,0,-1,-1); SETDEC(out
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4614 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); SETDEC(out
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4615 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); SETDEC(out
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4616 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); SETDEC(out
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4618 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); SETDEC(out
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4619 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); SETDEC(out
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4620 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); SETDEC(out
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_EQ
;
4623 SETDEC(out
,0,0,0,1); SETDEC(l
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_EQ
;
4624 SETDEC(out
,0,0,0,1); SETDEC(l
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4625 SETDEC(out
,0,0,0,1); SETDEC(l
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4627 SETDEC(out
,0,0,0,1); SETDEC(l
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4628 SETDEC(out
,0,0,0,1); SETDEC(l
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4629 SETDEC(out
,0,0,0,1); SETDEC(l
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4631 SETDEC(out
,0,DECIMAL_NEG
,0,1); SETDEC(l
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4632 SETDEC(out
,0,DECIMAL_NEG
,0,1); SETDEC(l
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4633 SETDEC(out
,0,DECIMAL_NEG
,0,1); SETDEC(l
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4635 SETDEC(out
,0,DECIMAL_NEG
,0,1); SETDEC(l
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_EQ
;
4636 SETDEC(out
,0,DECIMAL_NEG
,0,1); SETDEC(l
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4637 SETDEC(out
,0,DECIMAL_NEG
,0,1); SETDEC(l
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4639 SETDEC(out
,0,0,0,0); SETDEC(l
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4640 SETDEC(out
,0,0,0,0); SETDEC(l
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4641 SETDEC(out
,0,0,0,0); SETDEC(l
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4643 SETDEC(out
,0,0,0,0); SETDEC(l
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4644 SETDEC(out
,0,0,0,0); SETDEC(l
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4645 SETDEC(out
,0,0,0,0); SETDEC(l
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4647 SETDEC(out
,0,DECIMAL_NEG
,0,0); SETDEC(l
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4648 SETDEC(out
,0,DECIMAL_NEG
,0,0); SETDEC(l
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4649 SETDEC(out
,0,DECIMAL_NEG
,0,0); SETDEC(l
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4651 SETDEC(out
,0,DECIMAL_NEG
,0,0); SETDEC(l
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4652 SETDEC(out
,0,DECIMAL_NEG
,0,0); SETDEC(l
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_EQ
;
4653 SETDEC(out
,0,DECIMAL_NEG
,0,0); SETDEC(l
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4655 SETDEC(out
,0,0,-1,-1); SETDEC(l
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4656 SETDEC(out
,0,0,-1,-1); SETDEC(l
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4657 SETDEC(out
,0,0,-1,-1); SETDEC(l
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_EQ
;
4659 SETDEC(out
,0,0,-1,-1); SETDEC(l
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_LT
;
4660 SETDEC(out
,0,0,-1,-1); SETDEC(l
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_LT
;
4661 SETDEC(out
,0,0,-1,-1); SETDEC(l
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_LT
;
4663 SETDEC(out
,0,DECIMAL_NEG
,-1,-1); SETDEC(l
,0,0,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4664 SETDEC(out
,0,DECIMAL_NEG
,-1,-1); SETDEC(l
,0,0,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4665 SETDEC(out
,0,DECIMAL_NEG
,-1,-1); SETDEC(l
,0,0,-1,-1); MATH1(VarDecCmp
); EXPECT_GT
;
4667 SETDEC(out
,0,DECIMAL_NEG
,-1,-1); SETDEC(l
,0,DECIMAL_NEG
,0,1); MATH1(VarDecCmp
); EXPECT_GT
;
4668 SETDEC(out
,0,DECIMAL_NEG
,-1,-1); SETDEC(l
,0,DECIMAL_NEG
,0,0); MATH1(VarDecCmp
); EXPECT_GT
;
4669 SETDEC(out
,0,DECIMAL_NEG
,-1,-1); SETDEC(l
,0,DECIMAL_NEG
,-1,-1); MATH1(VarDecCmp
); EXPECT_EQ
;
4671 SETDEC(l
,3,0,0,123456); SETDEC64(out
,0,0,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF);
4672 MATH1(VarDecCmp
); EXPECT_LT
;
4675 static void test_VarDecCmpR8(void)
4681 CHECKPTR(VarDecCmpR8
);
4683 SETDEC(l
,0,0,0,1); r
= 0.0; MATH3(VarDecCmpR8
); EXPECT_GT
;
4684 SETDEC(l
,0,0,0,1); r
= 0.1; MATH3(VarDecCmpR8
); EXPECT_GT
;
4685 SETDEC(l
,0,0,0,1); r
= -0.1; MATH3(VarDecCmpR8
); EXPECT_GT
;
4687 SETDEC(l
,0,DECIMAL_NEG
,0,1); r
= 0.0; MATH3(VarDecCmpR8
); EXPECT_LT
;
4688 SETDEC(l
,0,DECIMAL_NEG
,0,1); r
= 0.1; MATH3(VarDecCmpR8
); EXPECT_LT
;
4689 SETDEC(l
,0,DECIMAL_NEG
,0,1); r
= -0.1; MATH3(VarDecCmpR8
); EXPECT_LT
;
4691 SETDEC(l
,0,0,0,0); r
= 0.0; MATH3(VarDecCmpR8
); EXPECT_EQ
;
4692 SETDEC(l
,0,0,0,0); r
= 0.1; MATH3(VarDecCmpR8
); EXPECT_LT
;
4693 SETDEC(l
,0,0,0,0); r
= -0.1; MATH3(VarDecCmpR8
); EXPECT_GT
;
4695 SETDEC(l
,0,DECIMAL_NEG
,0,0); r
= 0.0; MATH3(VarDecCmpR8
); EXPECT_EQ
;
4696 SETDEC(l
,0,DECIMAL_NEG
,0,0); r
= 0.1; MATH3(VarDecCmpR8
); EXPECT_LT
;
4697 SETDEC(l
,0,DECIMAL_NEG
,0,0); r
= -0.1; MATH3(VarDecCmpR8
); EXPECT_GT
;
4699 SETDEC(l
,0,0,0,1); r
= DECIMAL_NEG
; MATH3(VarDecCmpR8
); EXPECT_LT
;
4700 SETDEC(l
,0,DECIMAL_NEG
,0,0); r
= DECIMAL_NEG
; MATH3(VarDecCmpR8
); EXPECT_LT
;
4701 SETDEC(l
,0,0,-1,-1); r
= DECIMAL_NEG
; MATH3(VarDecCmpR8
); EXPECT_GT
;
4702 SETDEC(l
,0,DECIMAL_NEG
,-1,-1); r
= DECIMAL_NEG
; MATH3(VarDecCmpR8
); EXPECT_LT
;
4705 #define CLEAR(x) memset(&(x), 0xBB, sizeof(x))
4707 static void test_VarDecRound(void)
4712 CHECKPTR(VarDecRound
);
4714 CLEAR(out
); SETDEC(l
, 0, 0, 0, 1); hres
= pVarDecRound(&l
, 3, &out
); EXPECTDEC(0, 0, 0, 1);
4716 CLEAR(out
); SETDEC(l
, 0, 0, 0, 1); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC(0, 0, 0, 1);
4717 CLEAR(out
); SETDEC(l
, 1, 0, 0, 1); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC(0, 0, 0, 0);
4718 CLEAR(out
); SETDEC(l
, 1, 0, 0, 1); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, 0, 0, 1);
4719 CLEAR(out
); SETDEC(l
, 2, 0, 0, 11); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, 0, 0, 1);
4720 CLEAR(out
); SETDEC(l
, 2, 0, 0, 15); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, 0, 0, 2);
4721 CLEAR(out
); SETDEC(l
, 6, 0, 0, 550001); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, 0, 0, 6);
4723 CLEAR(out
); SETDEC(l
, 0, DECIMAL_NEG
, 0, 1); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC(0, DECIMAL_NEG
, 0, 1);
4724 CLEAR(out
); SETDEC(l
, 1, DECIMAL_NEG
, 0, 1); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC(0, DECIMAL_NEG
, 0, 0);
4725 CLEAR(out
); SETDEC(l
, 1, DECIMAL_NEG
, 0, 1); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, DECIMAL_NEG
, 0, 1);
4726 CLEAR(out
); SETDEC(l
, 2, DECIMAL_NEG
, 0, 11); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, DECIMAL_NEG
, 0, 1);
4727 CLEAR(out
); SETDEC(l
, 2, DECIMAL_NEG
, 0, 15); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, DECIMAL_NEG
, 0, 2);
4728 CLEAR(out
); SETDEC(l
, 6, DECIMAL_NEG
, 0, 550001); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, DECIMAL_NEG
, 0, 6);
4730 CLEAR(out
); SETDEC64(l
, 0, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC64(0, 0, 0xffffffff, 0xffffffff, 0xffffffff);
4731 CLEAR(out
); SETDEC64(l
, 28, 0, 0xffffffff, 0xffffffff, 0xffffffff); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC64(0, 0, 0, 0, 8);
4732 CLEAR(out
); SETDEC64(l
, 0, DECIMAL_NEG
, 0xffffffff, 0xffffffff, 0xffffffff); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC64(0, DECIMAL_NEG
, 0xffffffff, 0xffffffff, 0xffffffff);
4733 CLEAR(out
); SETDEC64(l
, 28, DECIMAL_NEG
, 0xffffffff, 0xffffffff, 0xffffffff); hres
= pVarDecRound(&l
, 0, &out
); EXPECTDEC64(0, DECIMAL_NEG
, 0, 0, 8);
4735 CLEAR(out
); SETDEC(l
, 2, 0, 0, 0); hres
= pVarDecRound(&l
, 1, &out
); EXPECTDEC(1, 0, 0, 0);
4743 #define CONV_TYPE VARIANT_BOOL
4745 #define EXPECTRES(res, x) _EXPECTRES(res, x, "%d")
4747 #define CONVERTRANGE(func,start,end) for (i = start; i < end; i++) { \
4748 CONVERT(func, i); if (i) { EXPECT(VARIANT_TRUE); } else { EXPECT(VARIANT_FALSE); } }
4750 static void test_VarBoolFromI1(void)
4752 CONVVARS(signed char);
4755 CHECKPTR(VarBoolFromI1
);
4756 CONVERTRANGE(VarBoolFromI1
, -128, 128);
4759 static void test_VarBoolFromUI1(void)
4764 CHECKPTR(VarBoolFromUI1
);
4765 CONVERTRANGE(VarBoolFromUI1
, 0, 256);
4768 static void test_VarBoolFromI2(void)
4773 CHECKPTR(VarBoolFromI2
);
4774 CONVERTRANGE(VarBoolFromI2
, -32768, 32768);
4777 static void test_VarBoolFromUI2(void)
4782 CHECKPTR(VarBoolFromUI2
);
4783 CONVERTRANGE(VarBoolFromUI2
, 0, 65536);
4786 static void test_VarBoolFromI4(void)
4790 CHECKPTR(VarBoolFromI4
);
4791 CONVERT(VarBoolFromI4
, 0x80000000); EXPECT(VARIANT_TRUE
);
4792 CONVERT(VarBoolFromI4
, -1); EXPECT(VARIANT_TRUE
);
4793 CONVERT(VarBoolFromI4
, 0); EXPECT(VARIANT_FALSE
);
4794 CONVERT(VarBoolFromI4
, 1); EXPECT(VARIANT_TRUE
);
4795 CONVERT(VarBoolFromI4
, 0x7fffffff); EXPECT(VARIANT_TRUE
);
4798 static void test_VarBoolFromUI4(void)
4802 CHECKPTR(VarBoolFromUI4
);
4803 CONVERT(VarBoolFromI4
, 0); EXPECT(VARIANT_FALSE
);
4804 CONVERT(VarBoolFromI4
, 1); EXPECT(VARIANT_TRUE
);
4805 CONVERT(VarBoolFromI4
, 0x80000000); EXPECT(VARIANT_TRUE
);
4808 static void test_VarBoolFromR4(void)
4812 CHECKPTR(VarBoolFromR4
);
4813 CONVERT(VarBoolFromR4
, -1.0f
); EXPECT(VARIANT_TRUE
);
4814 CONVERT(VarBoolFromR4
, 0.0f
); EXPECT(VARIANT_FALSE
);
4815 CONVERT(VarBoolFromR4
, 1.0f
); EXPECT(VARIANT_TRUE
);
4816 CONVERT(VarBoolFromR4
, 1.5f
); EXPECT(VARIANT_TRUE
);
4819 CONVERT(VarBoolFromR4
, -1.5f
); EXPECT(VARIANT_TRUE
);
4820 CONVERT(VarBoolFromR4
, -0.6f
); EXPECT(VARIANT_TRUE
);
4821 CONVERT(VarBoolFromR4
, -0.5f
); EXPECT(VARIANT_TRUE
);
4822 CONVERT(VarBoolFromR4
, -0.4f
); EXPECT(VARIANT_TRUE
);
4823 CONVERT(VarBoolFromR4
, 0.4f
); EXPECT(VARIANT_TRUE
);
4824 CONVERT(VarBoolFromR4
, 0.5f
); EXPECT(VARIANT_TRUE
);
4825 CONVERT(VarBoolFromR4
, 0.6f
); EXPECT(VARIANT_TRUE
);
4826 CONVERT(VarBoolFromR4
, 1.5f
); EXPECT(VARIANT_TRUE
);
4829 static void test_VarBoolFromR8(void)
4833 /* Hopefully we made the point with R4 above that rounding is
4834 * irrelevant, so we'll skip that for R8 and Date
4836 CHECKPTR(VarBoolFromR8
);
4837 CONVERT(VarBoolFromR8
, -1.0); EXPECT(VARIANT_TRUE
);
4838 CONVERT(VarBoolFromR8
, -0.0); EXPECT(VARIANT_FALSE
);
4839 CONVERT(VarBoolFromR8
, 1.0); EXPECT(VARIANT_TRUE
);
4842 static void test_VarBoolFromCy(void)
4846 CHECKPTR(VarBoolFromCy
);
4847 CONVERT_CY(VarBoolFromCy
, -32769); EXPECT(VARIANT_TRUE
);
4848 CONVERT_CY(VarBoolFromCy
, -32768); EXPECT(VARIANT_TRUE
);
4849 CONVERT_CY(VarBoolFromCy
, -1); EXPECT(VARIANT_TRUE
);
4850 CONVERT_CY(VarBoolFromCy
, 0); EXPECT(VARIANT_FALSE
);
4851 CONVERT_CY(VarBoolFromCy
, 1); EXPECT(VARIANT_TRUE
);
4852 CONVERT_CY(VarBoolFromCy
, 32767); EXPECT(VARIANT_TRUE
);
4853 CONVERT_CY(VarBoolFromCy
, 32768); EXPECT(VARIANT_TRUE
);
4856 static void test_VarBoolFromI8(void)
4860 CHECKPTR(VarBoolFromI8
);
4861 CONVERT(VarBoolFromI8
, -1); EXPECT(VARIANT_TRUE
);
4862 CONVERT(VarBoolFromI8
, 0); EXPECT(VARIANT_FALSE
);
4863 CONVERT(VarBoolFromI8
, 1); EXPECT(VARIANT_TRUE
);
4866 static void test_VarBoolFromUI8(void)
4870 CHECKPTR(VarBoolFromUI8
);
4871 CONVERT(VarBoolFromUI8
, 0); EXPECT(VARIANT_FALSE
);
4872 CONVERT(VarBoolFromUI8
, 1); EXPECT(VARIANT_TRUE
);
4875 static void test_VarBoolFromDec(void)
4879 CHECKPTR(VarBoolFromDec
);
4880 CONVERT_BADDEC(VarBoolFromDec
);
4882 CONVERT_DEC(VarBoolFromDec
,29,0,0,0); EXPECT_INVALID
;
4883 CONVERT_DEC(VarBoolFromDec
,0,0x1,0,0); EXPECT_INVALID
;
4884 CONVERT_DEC(VarBoolFromDec
,0,0x40,0,0); EXPECT_INVALID
;
4885 CONVERT_DEC(VarBoolFromDec
,0,0x7f,0,0); EXPECT_INVALID
;
4887 CONVERT_DEC(VarBoolFromDec
,0,0x80,0,1); EXPECT(VARIANT_TRUE
);
4888 CONVERT_DEC(VarBoolFromDec
,0,0,0,0); EXPECT(VARIANT_FALSE
);
4889 CONVERT_DEC(VarBoolFromDec
,0,0,0,1); EXPECT(VARIANT_TRUE
);
4890 CONVERT_DEC(VarBoolFromDec
,0,0,1,0); EXPECT(VARIANT_TRUE
);
4892 CONVERT_DEC(VarBoolFromDec
,2,0,0,CY_MULTIPLIER
); EXPECT(VARIANT_TRUE
);
4893 CONVERT_DEC(VarBoolFromDec
,2,0x80,0,CY_MULTIPLIER
); EXPECT(VARIANT_TRUE
);
4896 static void test_VarBoolFromDate(void)
4900 CHECKPTR(VarBoolFromDate
);
4901 CONVERT(VarBoolFromDate
, -1.0); EXPECT(VARIANT_TRUE
);
4902 CONVERT(VarBoolFromDate
, -0.0); EXPECT(VARIANT_FALSE
);
4903 CONVERT(VarBoolFromDate
, 1.0); EXPECT(VARIANT_TRUE
);
4906 static void test_VarBoolFromStr(void)
4911 CHECKPTR(VarBoolFromStr
);
4913 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
4915 CONVERT_STR(VarBoolFromStr
,NULL
,0);
4916 if (hres
!= E_INVALIDARG
)
4919 /* #FALSE# and #TRUE# Are always accepted */
4920 CONVERT_STR(VarBoolFromStr
,"#FALSE#",0); EXPECT(VARIANT_FALSE
);
4921 CONVERT_STR(VarBoolFromStr
,"#TRUE#",0); EXPECT(VARIANT_TRUE
);
4923 /* Match of #FALSE# and #TRUE# is case sensitive */
4924 CONVERT_STR(VarBoolFromStr
,"#False#",0); EXPECT_MISMATCH
;
4925 /* But match against English is not */
4926 CONVERT_STR(VarBoolFromStr
,"false",0); EXPECT(VARIANT_FALSE
);
4927 CONVERT_STR(VarBoolFromStr
,"False",0); EXPECT(VARIANT_FALSE
);
4928 /* On/Off and yes/no are not acceptable inputs, with any flags set */
4929 CONVERT_STR(VarBoolFromStr
,"On",0xffffffff); EXPECT_MISMATCH
;
4930 CONVERT_STR(VarBoolFromStr
,"Yes",0xffffffff); EXPECT_MISMATCH
;
4932 /* Change the LCID. This doesn't make any difference for text,unless we ask
4933 * to check local boolean text with the VARIANT_LOCALBOOL flag. */
4934 in
= MAKELCID(MAKELANGID(LANG_FRENCH
, SUBLANG_DEFAULT
), SORT_DEFAULT
);
4936 /* #FALSE# and #TRUE# are accepted in all locales */
4937 CONVERT_STR(VarBoolFromStr
,"#FALSE#",0); EXPECT(VARIANT_FALSE
);
4938 CONVERT_STR(VarBoolFromStr
,"#TRUE#",0); EXPECT(VARIANT_TRUE
);
4939 CONVERT_STR(VarBoolFromStr
,"#FALSE#",VARIANT_LOCALBOOL
); EXPECT(VARIANT_FALSE
);
4940 CONVERT_STR(VarBoolFromStr
,"#TRUE#",VARIANT_LOCALBOOL
); EXPECT(VARIANT_TRUE
);
4942 /* English is accepted regardless of the locale */
4943 CONVERT_STR(VarBoolFromStr
,"false",0); EXPECT(VARIANT_FALSE
);
4944 /* And is still not case sensitive */
4945 CONVERT_STR(VarBoolFromStr
,"False",0); EXPECT(VARIANT_FALSE
);
4949 /* French is rejected without VARIANT_LOCALBOOL */
4950 CONVERT_STR(VarBoolFromStr
,"faux",0); EXPECT_MISMATCH
;
4951 /* But accepted if this flag is given */
4952 CONVERT_STR(VarBoolFromStr
,"faux",VARIANT_LOCALBOOL
); EXPECT(VARIANT_FALSE
);
4953 /* Regardless of case - from this we assume locale text comparisons ignore case */
4954 CONVERT_STR(VarBoolFromStr
,"Faux",VARIANT_LOCALBOOL
); EXPECT(VARIANT_FALSE
);
4956 /* Changing the locale prevents the localised text from being compared -
4957 * this demonstrates that only the indicated LCID and English are searched */
4958 in
= MAKELCID(MAKELANGID(LANG_POLISH
, SUBLANG_DEFAULT
), SORT_DEFAULT
);
4959 CONVERT_STR(VarBoolFromStr
,"faux",VARIANT_LOCALBOOL
); EXPECT_MISMATCH
;
4962 /* Numeric strings are read as 0 or non-0 */
4963 CONVERT_STR(VarBoolFromStr
,"0",0); EXPECT(VARIANT_FALSE
);
4964 CONVERT_STR(VarBoolFromStr
,"-1",0); EXPECT(VARIANT_TRUE
);
4965 CONVERT_STR(VarBoolFromStr
,"+1",0); EXPECT(VARIANT_TRUE
);
4969 /* Numeric strings are read as floating point numbers. The line below fails
4970 * because '.' is not a valid decimal separator for Polish numbers */
4971 CONVERT_STR(VarBoolFromStr
,"0.1",LOCALE_NOUSEROVERRIDE
); EXPECT_MISMATCH
;
4974 /* Changing the lcid back to US English reads the r8 correctly */
4975 in
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
4976 CONVERT_STR(VarBoolFromStr
,"0.1",LOCALE_NOUSEROVERRIDE
); EXPECT(VARIANT_TRUE
);
4979 static void test_VarBoolCopy(void)
4981 COPYTEST(1, VT_BOOL
, V_BOOL(&vSrc
), V_BOOL(&vDst
), V_BOOLREF(&vSrc
), V_BOOLREF(&vDst
), "%d");
4984 #define BOOL_STR(flags, str) hres = VariantChangeTypeEx(&vDst, &vSrc, lcid, flags, VT_BSTR); \
4985 ok(hres == S_OK && V_VT(&vDst) == VT_BSTR && \
4986 V_BSTR(&vDst) && !memcmp(V_BSTR(&vDst), str, sizeof(str)), \
4987 "hres=0x%X, type=%d (should be VT_BSTR), *bstr='%c'\n", \
4988 hres, V_VT(&vDst), V_BSTR(&vDst) ? *V_BSTR(&vDst) : '?'); \
4991 static void test_VarBoolChangeTypeEx(void)
4993 static const WCHAR szTrue
[] = { 'T','r','u','e','\0' };
4994 static const WCHAR szFalse
[] = { 'F','a','l','s','e','\0' };
4995 static const WCHAR szFaux
[] = { 'F','a','u','x','\0' };
4998 VARIANTARG vSrc
, vDst
;
5003 INITIAL_TYPETEST(VT_BOOL
, V_BOOL
, "%d");
5006 /* The common tests convert to a number. Try the different flags */
5007 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
5009 V_VT(&vSrc
) = VT_BOOL
;
5012 BOOL_STR(VARIANT_ALPHABOOL
, szTrue
);
5014 BOOL_STR(VARIANT_ALPHABOOL
, szFalse
);
5018 lcid
= MAKELCID(MAKELANGID(LANG_FRENCH
, SUBLANG_DEFAULT
), SORT_DEFAULT
);
5020 /* VARIANT_ALPHABOOL is always English */
5021 BOOL_STR(VARIANT_ALPHABOOL
, szFalse
);
5022 /* VARIANT_LOCALBOOL uses the localised text */
5023 BOOL_STR(VARIANT_LOCALBOOL
, szFaux
);
5024 /* Both flags together acts as VARIANT_LOCALBOOL */
5025 BOOL_STR(VARIANT_ALPHABOOL
|VARIANT_LOCALBOOL
, szFaux
);
5033 static void test_VarBstrFromR4(void)
5035 static const WCHAR szNative
[] = { '6','5','4','3','2','2','.','3','\0' };
5036 static const WCHAR szZero
[] = {'0', '\0'};
5037 static const WCHAR szOneHalf_English
[] = { '0','.','5','\0' }; /* uses period */
5038 static const WCHAR szOneHalf_Spanish
[] = { '0',',','5','\0' }; /* uses comma */
5046 CHECKPTR(VarBstrFromR4
);
5048 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
5049 lcid_spanish
= MAKELCID(MAKELANGID(LANG_SPANISH
, SUBLANG_SPANISH
), SORT_DEFAULT
);
5051 hres
= pVarBstrFromR4(f
, lcid
, 0, &bstr
);
5052 ok(hres
== S_OK
, "got hres 0x%08x\n", hres
);
5056 /* MSDN states that rounding of R4/R8 is dependent on the underlying
5057 * bit pattern of the number and so is architecture dependent. In this
5058 * case Wine returns .2 (which is more correct) and Native returns .3
5060 ok(memcmp(bstr
, szNative
, sizeof(szNative
)) == 0, "string different\n");
5062 SysFreeString(bstr
);
5066 hres
= pVarBstrFromR4(f
, lcid
, 0, &bstr
);
5067 ok(hres
== S_OK
, "got hres 0x%08x\n", hres
);
5071 ok(memcmp(bstr
+ 1, szZero
, sizeof(szZero
)) == 0, "negative zero (got %s)\n", wtoascii(bstr
));
5073 ok(memcmp(bstr
, szZero
, sizeof(szZero
)) == 0, "negative zero (got %s)\n", wtoascii(bstr
));
5074 SysFreeString(bstr
);
5077 /* The following tests that lcid is used for decimal separator even without LOCALE_USE_NLS */
5079 hres
= pVarBstrFromR4(f
, lcid
, LOCALE_NOUSEROVERRIDE
, &bstr
);
5080 ok(hres
== S_OK
, "got hres 0x%08x\n", hres
);
5083 ok(memcmp(bstr
, szOneHalf_English
, sizeof(szOneHalf_English
)) == 0, "English locale failed (got %s)\n", wtoascii(bstr
));
5084 SysFreeString(bstr
);
5087 hres
= pVarBstrFromR4(f
, lcid_spanish
, LOCALE_NOUSEROVERRIDE
, &bstr
);
5088 ok(hres
== S_OK
, "got hres 0x%08x\n", hres
);
5091 ok(memcmp(bstr
, szOneHalf_Spanish
, sizeof(szOneHalf_Spanish
)) == 0, "Spanish locale failed (got %s)\n", wtoascii(bstr
));
5092 SysFreeString(bstr
);
5096 static void _BSTR_DATE(DATE dt
, const char *str
, int line
)
5098 LCID lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
5103 hres
= pVarBstrFromDate(dt
, lcid
, LOCALE_NOUSEROVERRIDE
, &bstr
);
5106 WideCharToMultiByte(CP_ACP
, 0, bstr
, -1, buff
, sizeof(buff
), 0, 0);
5107 SysFreeString(bstr
);
5111 ok_(__FILE__
, line
)(hres
== S_OK
&& !strcmp(str
, buff
),
5112 "Expected '%s', got '%s', hres = 0x%08x\n", str
, buff
, hres
);
5115 static void test_VarBstrFromDate(void)
5117 #define BSTR_DATE(dt,str) _BSTR_DATE(dt,str,__LINE__)
5119 CHECKPTR(VarBstrFromDate
);
5121 BSTR_DATE(0.0, "12:00:00 AM");
5122 BSTR_DATE(3.34, "1/2/1900 8:09:36 AM");
5123 BSTR_DATE(3339.34, "2/20/1909 8:09:36 AM");
5124 BSTR_DATE(365.00, "12/30/1900");
5125 BSTR_DATE(365.25, "12/30/1900 6:00:00 AM");
5126 BSTR_DATE(1461.0, "12/31/1903");
5127 BSTR_DATE(1461.5, "12/31/1903 12:00:00 PM");
5128 BSTR_DATE(-49192.24, "4/24/1765 5:45:36 AM");
5129 BSTR_DATE(-657434.0, "1/1/100");
5130 BSTR_DATE(2958465.0, "12/31/9999");
5135 static void _BSTR_CY(LONG a
, LONG b
, const char *str
, LCID lcid
, int line
)
5144 hr
= pVarBstrFromCy(l
, lcid
, LOCALE_NOUSEROVERRIDE
, &bstr
);
5145 ok(hr
== S_OK
, "got hr 0x%08x\n", hr
);
5149 WideCharToMultiByte(CP_ACP
, 0, bstr
, -1, buff
, sizeof(buff
), 0, 0);
5150 SysFreeString(bstr
);
5157 ok_(__FILE__
, line
)(!strcmp(str
, buff
), "Expected '%s', got '%s'\n", str
, buff
);
5161 static void test_VarBstrFromCy(void)
5163 #define BSTR_CY(a, b, str, lcid) _BSTR_CY(a, b, str, lcid, __LINE__)
5167 CHECKPTR(VarBstrFromCy
);
5169 en_us
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
5170 sp
= MAKELCID(MAKELANGID(LANG_SPANISH
, SUBLANG_DEFAULT
), SORT_DEFAULT
);
5172 BSTR_CY(0, 0, "0", en_us
);
5173 BSTR_CY(0, 10000, "1", en_us
);
5174 BSTR_CY(0, 15000, "1.5", en_us
);
5175 BSTR_CY(0xffffffff, ((15000)^0xffffffff)+1, "-1.5", en_us
);
5176 /* (1 << 32) - 1 / 1000 */
5177 BSTR_CY(0, 0xffffffff, "429496.7295", en_us
);
5178 /* (1 << 32) / 1000 */
5179 BSTR_CY(1, 0, "429496.7296", en_us
);
5180 /* ((1 << 63) - 1)/10000 */
5181 BSTR_CY(0x7fffffff, 0xffffffff, "922337203685477.5807", en_us
);
5182 BSTR_CY(0, 9, "0.0009", en_us
);
5183 BSTR_CY(0, 9, "0,0009", sp
);
5188 static void _BSTR_DEC(BYTE scale
, BYTE sign
, ULONG hi
, ULONG mid
, ULONGLONG lo
, const char *str
,
5189 LCID lcid
, int line
)
5196 SETDEC64(dec
, scale
, sign
, hi
, mid
, lo
);
5197 hr
= pVarBstrFromDec(&dec
, lcid
, LOCALE_NOUSEROVERRIDE
, &bstr
);
5198 ok_(__FILE__
, line
)(hr
== S_OK
, "got hr 0x%08x\n", hr
);
5202 WideCharToMultiByte(CP_ACP
, 0, bstr
, -1, buff
, sizeof(buff
), 0, 0);
5203 SysFreeString(bstr
);
5210 ok_(__FILE__
, line
)(!strcmp(str
, buff
), "Expected '%s', got '%s'\n", str
, buff
);
5214 static void test_VarBstrFromDec(void)
5216 #define BSTR_DEC(scale, sign, hi, lo, str, lcid) _BSTR_DEC(scale, sign, hi, 0, lo, str, lcid, __LINE__)
5217 #define BSTR_DEC64(scale, sign, hi, mid, lo, str, lcid) _BSTR_DEC(scale, sign, hi, mid, lo, str, lcid, __LINE__)
5221 CHECKPTR(VarBstrFromDec
);
5223 en_us
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
5224 sp
= MAKELCID(MAKELANGID(LANG_SPANISH
, SUBLANG_DEFAULT
), SORT_DEFAULT
);
5226 BSTR_DEC(0,0,0,0, "0", en_us
);
5228 BSTR_DEC(0,0,0,1, "1", en_us
);
5229 BSTR_DEC(1,0,0,10, "1", en_us
);
5230 BSTR_DEC(2,0,0,100, "1", en_us
);
5231 BSTR_DEC(3,0,0,1000,"1", en_us
);
5233 BSTR_DEC(1,0,0,15, "1.5", en_us
);
5234 BSTR_DEC(2,0,0,150, "1.5", en_us
);
5235 BSTR_DEC(3,0,0,1500,"1.5", en_us
);
5237 BSTR_DEC(1,0x80,0,15, "-1.5", en_us
);
5240 BSTR_DEC(0,0,0,0xffffffff, "4294967295", en_us
);
5242 BSTR_DEC64(0,0,0,1,0, "4294967296", en_us
);
5244 BSTR_DEC64(0,0,0,0xffffffff,0xffffffff, "18446744073709551615", en_us
);
5246 BSTR_DEC(0,0,1,0, "18446744073709551616", en_us
);
5248 BSTR_DEC64(0,0,0xffffffff,0xffffffff,0xffffffff, "79228162514264337593543950335", en_us
);
5250 BSTR_DEC(10,0,0,1, "0.0000000001", en_us
);
5251 /* ((1 << 96) - 1) * 10^-10 */
5252 BSTR_DEC64(10,0,0xffffffffUL
,0xffffffff,0xffffffff, "7922816251426433759.3543950335", en_us
);
5253 /* ((1 << 96) - 1) * 10^-28 */
5254 BSTR_DEC64(28,0,0xffffffffUL
,0xffffffff,0xffffffff, "7.9228162514264337593543950335", en_us
);
5256 /* check leading zeros and decimal sep. for English locale */
5257 BSTR_DEC(4,0,0,9, "0.0009", en_us
);
5258 BSTR_DEC(5,0,0,90, "0.0009", en_us
);
5259 BSTR_DEC(6,0,0,900, "0.0009", en_us
);
5260 BSTR_DEC(7,0,0,9000, "0.0009", en_us
);
5262 /* check leading zeros and decimal sep. for Spanish locale */
5263 BSTR_DEC(4,0,0,9, "0,0009", sp
);
5264 BSTR_DEC(5,0,0,90, "0,0009", sp
);
5265 BSTR_DEC(6,0,0,900, "0,0009", sp
);
5266 BSTR_DEC(7,0,0,9000, "0,0009", sp
);
5272 #define _VARBSTRCMP(left,right,lcid,flags,result) \
5273 hres = pVarBstrCmp(left,right,lcid,flags); \
5274 ok(hres == result, "VarBstrCmp: expected " #result ", got hres=0x%x\n", hres)
5275 #define VARBSTRCMP(left,right,flags,result) \
5276 _VARBSTRCMP(left,right,lcid,flags,result)
5278 static void test_VarBstrCmp(void)
5282 static const WCHAR sz
[] = {'W','u','r','s','c','h','t','\0'};
5283 static const WCHAR szempty
[] = {'\0'};
5284 static const WCHAR sz1
[] = { 'a',0 };
5285 static const WCHAR sz2
[] = { 'A',0 };
5286 static const WCHAR s1
[] = { 'a',0 };
5287 static const WCHAR s2
[] = { 'a',0,'b' };
5288 static const char sb1
[] = {1,0,1};
5289 static const char sb2
[] = {1,0,2};
5290 static const char sbchr0
[] = {0,0};
5291 static const char sbchr00
[] = {0,0,0};
5292 BSTR bstr
, bstrempty
, bstr2
;
5294 CHECKPTR(VarBstrCmp
);
5296 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
),SORT_DEFAULT
);
5297 bstr
= SysAllocString(sz
);
5298 bstrempty
= SysAllocString(szempty
);
5300 /* NULL handling. Yepp, MSDN is totally wrong here */
5301 VARBSTRCMP(NULL
,NULL
,0,VARCMP_EQ
);
5302 VARBSTRCMP(bstr
,NULL
,0,VARCMP_GT
);
5303 VARBSTRCMP(NULL
,bstr
,0,VARCMP_LT
);
5305 /* NULL and empty string comparisons */
5306 VARBSTRCMP(bstrempty
,NULL
,0,VARCMP_EQ
);
5307 VARBSTRCMP(NULL
,bstrempty
,0,VARCMP_EQ
);
5309 SysFreeString(bstr
);
5310 bstr
= SysAllocString(sz1
);
5312 bstr2
= SysAllocString(sz2
);
5313 VARBSTRCMP(bstr
,bstr2
,0,VARCMP_LT
);
5314 VARBSTRCMP(bstr
,bstr2
,NORM_IGNORECASE
,VARCMP_EQ
);
5315 SysFreeString(bstr2
);
5316 /* These two strings are considered equal even though one is
5317 * NULL-terminated and the other not.
5319 bstr2
= SysAllocStringLen(s1
, sizeof(s1
) / sizeof(WCHAR
));
5320 VARBSTRCMP(bstr
,bstr2
,0,VARCMP_EQ
);
5321 SysFreeString(bstr2
);
5323 /* These two strings are not equal */
5324 bstr2
= SysAllocStringLen(s2
, sizeof(s2
) / sizeof(WCHAR
));
5325 VARBSTRCMP(bstr
,bstr2
,0,VARCMP_LT
);
5326 SysFreeString(bstr2
);
5328 SysFreeString(bstr
);
5330 bstr
= SysAllocStringByteLen(sbchr0
, sizeof(sbchr0
));
5331 bstr2
= SysAllocStringByteLen(sbchr00
, sizeof(sbchr00
));
5332 VARBSTRCMP(bstr
,bstrempty
,0,VARCMP_GT
);
5333 VARBSTRCMP(bstrempty
,bstr
,0,VARCMP_LT
);
5334 VARBSTRCMP(bstr2
,bstrempty
,0,VARCMP_GT
);
5335 VARBSTRCMP(bstr2
,bstr
,0,VARCMP_EQ
);
5336 SysFreeString(bstr2
);
5337 SysFreeString(bstr
);
5339 /* When (LCID == 0) it should be a binary comparison
5340 * so these two strings could not match.
5342 bstr
= SysAllocStringByteLen(sb1
, sizeof(sb1
));
5343 bstr2
= SysAllocStringByteLen(sb2
, sizeof(sb2
));
5345 VARBSTRCMP(bstr
,bstr2
,0,VARCMP_LT
);
5346 SysFreeString(bstr2
);
5347 SysFreeString(bstr
);
5349 bstr
= SysAllocStringByteLen(sbchr0
, sizeof(sbchr0
));
5350 bstr2
= SysAllocStringByteLen(sbchr00
, sizeof(sbchr00
));
5351 VARBSTRCMP(bstr
,bstrempty
,0,VARCMP_GT
);
5352 VARBSTRCMP(bstrempty
,bstr
,0,VARCMP_LT
);
5353 VARBSTRCMP(bstr2
,bstrempty
,0,VARCMP_GT
);
5354 VARBSTRCMP(bstr2
,bstr
,0,VARCMP_GT
);
5355 SysFreeString(bstr2
);
5356 SysFreeString(bstr
);
5357 SysFreeString(bstrempty
);
5360 /* Get the internal representation of a BSTR */
5361 static inline LPINTERNAL_BSTR
Get(const BSTR lpszString
)
5363 return lpszString
? (LPINTERNAL_BSTR
)((char*)lpszString
- sizeof(DWORD
)) : NULL
;
5366 static inline BSTR
GetBSTR(const LPINTERNAL_BSTR bstr
)
5368 return (BSTR
)bstr
->szString
;
5371 static void test_SysStringLen(void)
5374 BSTR str
= GetBSTR(&bstr
);
5377 ok (SysStringLen(str
) == 0, "Expected dwLen 0, got %d\n", SysStringLen(str
));
5379 ok (SysStringLen(str
) == 1, "Expected dwLen 1, got %d\n", SysStringLen(str
));
5382 static void test_SysStringByteLen(void)
5385 BSTR str
= GetBSTR(&bstr
);
5388 ok (SysStringByteLen(str
) == 0, "Expected dwLen 0, got %d\n", SysStringByteLen(str
));
5390 ok (SysStringByteLen(str
) == 2, "Expected dwLen 2, got %d\n", SysStringByteLen(str
));
5393 static void test_SysAllocString(void)
5395 const OLECHAR szTest
[5] = { 'T','e','s','t','\0' };
5398 str
= SysAllocString(NULL
);
5399 ok (str
== NULL
, "Expected NULL, got %p\n", str
);
5401 str
= SysAllocString(szTest
);
5402 ok (str
!= NULL
, "Expected non-NULL\n");
5405 LPINTERNAL_BSTR bstr
= Get(str
);
5407 ok (bstr
->dwLen
== 8, "Expected 8, got %d\n", bstr
->dwLen
);
5408 ok (!lstrcmpW(bstr
->szString
, szTest
), "String different\n");
5413 static void test_SysAllocStringLen(void)
5415 const OLECHAR szTest
[5] = { 'T','e','s','t','\0' };
5418 /* Very early native dlls do not limit the size of strings, so skip this test */
5421 str
= SysAllocStringLen(szTest
, 0x80000000);
5422 ok (str
== NULL
, "Expected NULL, got %p\n", str
);
5425 str
= SysAllocStringLen(NULL
, 0);
5426 ok (str
!= NULL
, "Expected non-NULL\n");
5429 LPINTERNAL_BSTR bstr
= Get(str
);
5431 ok (bstr
->dwLen
== 0, "Expected 0, got %d\n", bstr
->dwLen
);
5432 ok (!bstr
->szString
[0], "String not empty\n");
5436 str
= SysAllocStringLen(szTest
, 4);
5437 ok (str
!= NULL
, "Expected non-NULL\n");
5440 LPINTERNAL_BSTR bstr
= Get(str
);
5442 ok (bstr
->dwLen
== 8, "Expected 8, got %d\n", bstr
->dwLen
);
5443 ok (!lstrcmpW(bstr
->szString
, szTest
), "String different\n");
5448 static void test_SysAllocStringByteLen(void)
5450 const OLECHAR szTest
[10] = { 'T','e','s','t','\0' };
5451 const CHAR szTestA
[6] = { 'T','e','s','t','\0','?' };
5454 if (sizeof(void *) == 4) /* not limited to 0x80000000 on Win64 */
5456 str
= SysAllocStringByteLen(szTestA
, 0x80000000);
5457 ok (str
== NULL
, "Expected NULL, got %p\n", str
);
5460 str
= SysAllocStringByteLen(szTestA
, 0xffffffff);
5461 ok (str
== NULL
, "Expected NULL, got %p\n", str
);
5463 str
= SysAllocStringByteLen(NULL
, 0);
5464 ok (str
!= NULL
, "Expected non-NULL\n");
5467 LPINTERNAL_BSTR bstr
= Get(str
);
5469 ok (bstr
->dwLen
== 0, "Expected 0, got %d\n", bstr
->dwLen
);
5470 ok (!bstr
->szString
[0], "String not empty\n");
5474 str
= SysAllocStringByteLen(szTestA
, 4);
5475 ok (str
!= NULL
, "Expected non-NULL\n");
5478 LPINTERNAL_BSTR bstr
= Get(str
);
5480 ok (bstr
->dwLen
== 4, "Expected 4, got %d\n", bstr
->dwLen
);
5481 ok (!lstrcmpA((LPCSTR
)bstr
->szString
, szTestA
), "String different\n");
5485 /* Odd lengths are allocated rounded up, but truncated at the right position */
5486 str
= SysAllocStringByteLen(szTestA
, 3);
5487 ok (str
!= NULL
, "Expected non-NULL\n");
5490 const CHAR szTestTruncA
[4] = { 'T','e','s','\0' };
5491 LPINTERNAL_BSTR bstr
= Get(str
);
5493 ok (bstr
->dwLen
== 3, "Expected 3, got %d\n", bstr
->dwLen
);
5494 ok (!lstrcmpA((LPCSTR
)bstr
->szString
, szTestTruncA
), "String different\n");
5498 str
= SysAllocStringByteLen((LPCSTR
)szTest
, 8);
5499 ok (str
!= NULL
, "Expected non-NULL\n");
5502 LPINTERNAL_BSTR bstr
= Get(str
);
5504 ok (bstr
->dwLen
== 8, "Expected 8, got %d\n", bstr
->dwLen
);
5505 ok (!lstrcmpW(bstr
->szString
, szTest
), "String different\n");
5510 static void test_SysReAllocString(void)
5512 const OLECHAR szTest
[5] = { 'T','e','s','t','\0' };
5513 const OLECHAR szSmaller
[2] = { 'x','\0' };
5514 const OLECHAR szLarger
[7] = { 'L','a','r','g','e','r','\0' };
5517 str
= SysAllocStringLen(szTest
, 4);
5518 ok (str
!= NULL
, "Expected non-NULL\n");
5521 LPINTERNAL_BSTR bstr
;
5525 ok (bstr
->dwLen
== 8, "Expected 8, got %d\n", bstr
->dwLen
);
5526 ok (!lstrcmpW(bstr
->szString
, szTest
), "String different\n");
5528 changed
= SysReAllocString(&str
, szSmaller
);
5529 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5530 /* Vista creates a new string, but older versions reuse the existing string. */
5531 /*ok (str == oldstr, "Created new string\n");*/
5533 ok (bstr
->dwLen
== 2, "Expected 2, got %d\n", bstr
->dwLen
);
5534 ok (!lstrcmpW(bstr
->szString
, szSmaller
), "String different\n");
5536 changed
= SysReAllocString(&str
, szLarger
);
5537 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5538 /* Early versions always make new strings rather than resizing */
5539 /* ok (str == oldstr, "Created new string\n"); */
5541 ok (bstr
->dwLen
== 12, "Expected 12, got %d\n", bstr
->dwLen
);
5542 ok (!lstrcmpW(bstr
->szString
, szLarger
), "String different\n");
5548 static void test_SysReAllocStringLen(void)
5550 const OLECHAR szTest
[5] = { 'T','e','s','t','\0' };
5551 const OLECHAR szSmaller
[2] = { 'x','\0' };
5552 const OLECHAR szLarger
[7] = { 'L','a','r','g','e','r','\0' };
5555 str
= SysAllocStringLen(szTest
, 4);
5556 ok (str
!= NULL
, "Expected non-NULL\n");
5559 LPINTERNAL_BSTR bstr
;
5563 ok (bstr
->dwLen
== 8, "Expected 8, got %d\n", bstr
->dwLen
);
5564 ok (!lstrcmpW(bstr
->szString
, szTest
), "String different\n");
5566 changed
= SysReAllocStringLen(&str
, szSmaller
, 1);
5567 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5568 /* Vista creates a new string, but older versions reuse the existing string. */
5569 /*ok (str == oldstr, "Created new string\n");*/
5571 ok (bstr
->dwLen
== 2, "Expected 2, got %d\n", bstr
->dwLen
);
5572 ok (!lstrcmpW(bstr
->szString
, szSmaller
), "String different\n");
5574 changed
= SysReAllocStringLen(&str
, szLarger
, 6);
5575 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5576 /* Early versions always make new strings rather than resizing */
5577 /* ok (str == oldstr, "Created new string\n"); */
5579 ok (bstr
->dwLen
== 12, "Expected 12, got %d\n", bstr
->dwLen
);
5580 ok (!lstrcmpW(bstr
->szString
, szLarger
), "String different\n");
5582 changed
= SysReAllocStringLen(&str
, str
, 6);
5583 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5588 /* Windows always returns null terminated strings */
5589 str
= SysAllocStringLen(szTest
, 4);
5590 ok (str
!= NULL
, "Expected non-NULL\n");
5593 const int CHUNK_SIZE
= 64;
5594 const int STRING_SIZE
= 24;
5596 changed
= SysReAllocStringLen(&str
, NULL
, CHUNK_SIZE
);
5597 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5598 ok (str
!= NULL
, "Expected non-NULL\n");
5603 /* Filling string */
5604 memset (str
, 0xAB, CHUNK_SIZE
* sizeof (OLECHAR
));
5605 /* Checking null terminator */
5606 changed
= SysReAllocStringLen(&str
, NULL
, STRING_SIZE
);
5607 ok (changed
== 1, "Expected 1, got %d\n", changed
);
5608 ok (str
!= NULL
, "Expected non-NULL\n");
5611 ok (str
== oldstr
, "Expected reuse of the old string memory\n");
5612 ok (str
[STRING_SIZE
] == 0,
5613 "Expected null terminator, got 0x%04X\n", str
[STRING_SIZE
]);
5619 /* Some Windows applications use the same pointer for pbstr and psz */
5620 str
= SysAllocStringLen(szTest
, 4);
5621 ok(str
!= NULL
, "Expected non-NULL\n");
5624 SysReAllocStringLen(&str
, str
, 1000000);
5625 ok(SysStringLen(str
)==1000000, "Incorrect string length\n");
5626 ok(!memcmp(szTest
, str
, 4*sizeof(WCHAR
)), "Incorrect string returned\n");
5632 static void test_BstrCopy(void)
5634 const CHAR szTestA
[6] = { 'T','e','s','t','\0','?' };
5635 const CHAR szTestTruncA
[4] = { 'T','e','s','\0' };
5636 LPINTERNAL_BSTR bstr
;
5641 str
= SysAllocStringByteLen(szTestA
, 3);
5642 ok (str
!= NULL
, "Expected non-NULL\n");
5645 V_VT(&vt1
) = VT_BSTR
;
5647 V_VT(&vt2
) = VT_EMPTY
;
5648 hres
= VariantCopy(&vt2
, &vt1
);
5649 ok (hres
== S_OK
,"Failed to copy binary bstring with hres 0x%08x\n", hres
);
5650 bstr
= Get(V_BSTR(&vt2
));
5651 ok (bstr
->dwLen
== 3, "Expected 3, got %d\n", bstr
->dwLen
);
5652 ok (!lstrcmpA((LPCSTR
)bstr
->szString
, szTestTruncA
), "String different\n");
5658 static void test_VarBstrCat(void)
5660 static const WCHAR sz1
[] = { 'a',0 };
5661 static const WCHAR sz2
[] = { 'b',0 };
5662 static const WCHAR sz1sz2
[] = { 'a','b',0 };
5663 static const WCHAR s1
[] = { 'a',0 };
5664 static const WCHAR s2
[] = { 'b',0 };
5665 static const WCHAR s1s2
[] = { 'a',0,'b',0 };
5666 static const char str1A
[] = "Have ";
5667 static const char str2A
[] = "A Cigar";
5669 BSTR str1
, str2
, res
;
5672 CHECKPTR(VarBstrCat
);
5677 pVarBstrCat(NULL
, NULL
, NULL
);
5680 /* Concatenation of two NULL strings works */
5681 ret
= pVarBstrCat(NULL
, NULL
, &res
);
5682 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5683 ok(res
!= NULL
, "Expected a string\n");
5684 ok(SysStringLen(res
) == 0, "Expected a 0-length string\n");
5687 str1
= SysAllocString(sz1
);
5689 /* Concatenation with one NULL arg */
5690 ret
= pVarBstrCat(NULL
, str1
, &res
);
5691 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5692 ok(res
!= NULL
, "Expected a string\n");
5693 ok(SysStringLen(res
) == SysStringLen(str1
), "Unexpected length\n");
5694 ok(!memcmp(res
, sz1
, SysStringLen(str1
)), "Unexpected value\n");
5696 ret
= pVarBstrCat(str1
, NULL
, &res
);
5697 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5698 ok(res
!= NULL
, "Expected a string\n");
5699 ok(SysStringLen(res
) == SysStringLen(str1
), "Unexpected length\n");
5700 ok(!memcmp(res
, sz1
, SysStringLen(str1
)), "Unexpected value\n");
5703 /* Concatenation of two zero-terminated strings */
5704 str2
= SysAllocString(sz2
);
5705 ret
= pVarBstrCat(str1
, str2
, &res
);
5706 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5707 ok(res
!= NULL
, "Expected a string\n");
5708 ok(SysStringLen(res
) == sizeof(sz1sz2
) / sizeof(WCHAR
) - 1,
5709 "Unexpected length\n");
5710 ok(!memcmp(res
, sz1sz2
, sizeof(sz1sz2
)), "Unexpected value\n");
5713 SysFreeString(str2
);
5714 SysFreeString(str1
);
5716 /* Concatenation of two strings with embedded NULLs */
5717 str1
= SysAllocStringLen(s1
, sizeof(s1
) / sizeof(WCHAR
));
5718 str2
= SysAllocStringLen(s2
, sizeof(s2
) / sizeof(WCHAR
));
5720 ret
= pVarBstrCat(str1
, str2
, &res
);
5721 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5722 ok(res
!= NULL
, "Expected a string\n");
5723 ok(SysStringLen(res
) == sizeof(s1s2
) / sizeof(WCHAR
),
5724 "Unexpected length\n");
5725 ok(!memcmp(res
, s1s2
, sizeof(s1s2
)), "Unexpected value\n");
5728 SysFreeString(str2
);
5729 SysFreeString(str1
);
5731 /* Concatenation of ansi BSTRs, both odd byte count not including termination */
5732 str1
= SysAllocStringByteLen(str1A
, sizeof(str1A
)-1);
5733 str2
= SysAllocStringByteLen(str2A
, sizeof(str2A
)-1);
5734 len
= SysStringLen(str1
);
5735 ok(len
== (sizeof(str1A
)-1)/sizeof(WCHAR
), "got length %u\n", len
);
5736 len
= SysStringLen(str2
);
5737 ok(len
== (sizeof(str2A
)-1)/sizeof(WCHAR
), "got length %u\n", len
);
5739 ret
= pVarBstrCat(str1
, str2
, &res
);
5740 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5741 ok(res
!= NULL
, "Expected a string\n");
5742 len
= (sizeof(str1A
) + sizeof(str2A
) - 2)/sizeof(WCHAR
);
5743 ok(SysStringLen(res
) == len
, "got %d, expected %u\n", SysStringLen(res
), len
);
5744 ok(!memcmp(res
, "Have A Cigar", sizeof(str1A
) + sizeof(str2A
) - 1), "got (%s)\n", (char*)res
);
5747 SysFreeString(str2
);
5748 SysFreeString(str1
);
5750 /* Concatenation of ansi BSTRs, both 1 byte length not including termination */
5751 str1
= SysAllocStringByteLen(str1A
, 1);
5752 str2
= SysAllocStringByteLen(str2A
, 1);
5753 len
= SysStringLen(str1
);
5754 ok(len
== 0, "got length %u\n", len
);
5755 len
= SysStringLen(str2
);
5756 ok(len
== 0, "got length %u\n", len
);
5758 ret
= pVarBstrCat(str1
, str2
, &res
);
5759 ok(ret
== S_OK
, "VarBstrCat failed: %08x\n", ret
);
5760 ok(res
!= NULL
, "Expected a string\n");
5761 ok(SysStringLen(res
) == 1, "got %d, expected 1\n", SysStringLen(res
));
5762 ok(!memcmp(res
, "HA", 2), "got (%s)\n", (char*)res
);
5765 SysFreeString(str2
);
5766 SysFreeString(str1
);
5771 static void test_IUnknownClear(void)
5778 init_test_dispatch(1, VT_UI1
, &u
);
5779 pu
= (IUnknown
*)&u
.IDispatch_iface
;
5781 /* Test that IUnknown_Release is called on by-value */
5782 V_VT(&v
) = VT_UNKNOWN
;
5783 V_UNKNOWN(&v
) = (IUnknown
*)&u
.IDispatch_iface
;
5784 hres
= VariantClear(&v
);
5785 ok(hres
== S_OK
&& u
.ref
== 0 && V_VT(&v
) == VT_EMPTY
,
5786 "clear unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5787 S_OK
, 0, VT_EMPTY
, hres
, u
.ref
, V_VT(&v
));
5789 /* But not when clearing a by-reference*/
5791 V_VT(&v
) = VT_UNKNOWN
|VT_BYREF
;
5792 V_UNKNOWNREF(&v
) = &pu
;
5793 hres
= VariantClear(&v
);
5794 ok(hres
== S_OK
&& u
.ref
== 1 && V_VT(&v
) == VT_EMPTY
,
5795 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5796 S_OK
, 1, VT_EMPTY
, hres
, u
.ref
, V_VT(&v
));
5799 static void test_IUnknownCopy(void)
5802 VARIANTARG vSrc
, vDst
;
5806 init_test_dispatch(1, VT_UI1
, &u
);
5807 pu
= (IUnknown
*)&u
.IDispatch_iface
;
5809 /* AddRef is called on by-value copy */
5811 V_VT(&vSrc
) = VT_UNKNOWN
;
5812 V_UNKNOWN(&vSrc
) = pu
;
5813 hres
= VariantCopy(&vDst
, &vSrc
);
5814 ok(hres
== S_OK
&& u
.ref
== 2 && V_VT(&vDst
) == VT_UNKNOWN
,
5815 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5816 S_OK
, 2, VT_EMPTY
, hres
, u
.ref
, V_VT(&vDst
));
5818 /* AddRef is skipped on copy of by-reference IDispatch */
5821 V_VT(&vSrc
) = VT_UNKNOWN
|VT_BYREF
;
5822 V_UNKNOWNREF(&vSrc
) = &pu
;
5823 hres
= VariantCopy(&vDst
, &vSrc
);
5824 ok(hres
== S_OK
&& u
.ref
== 1 && V_VT(&vDst
) == (VT_UNKNOWN
|VT_BYREF
),
5825 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5826 S_OK
, 1, VT_DISPATCH
, hres
, u
.ref
, V_VT(&vDst
));
5828 /* AddRef is called copying by-reference IDispatch with indirection */
5831 V_VT(&vSrc
) = VT_UNKNOWN
|VT_BYREF
;
5832 V_UNKNOWNREF(&vSrc
) = &pu
;
5833 hres
= VariantCopyInd(&vDst
, &vSrc
);
5834 ok(hres
== S_OK
&& u
.ref
== 2 && V_VT(&vDst
) == VT_UNKNOWN
,
5835 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5836 S_OK
, 2, VT_DISPATCH
, hres
, u
.ref
, V_VT(&vDst
));
5838 /* Indirection in place also calls AddRef */
5840 V_VT(&vSrc
) = VT_UNKNOWN
|VT_BYREF
;
5841 V_UNKNOWNREF(&vSrc
) = &pu
;
5842 hres
= VariantCopyInd(&vSrc
, &vSrc
);
5843 ok(hres
== S_OK
&& u
.ref
== 2 && V_VT(&vSrc
) == VT_UNKNOWN
,
5844 "copy unknown: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5845 S_OK
, 2, VT_DISPATCH
, hres
, u
.ref
, V_VT(&vSrc
));
5848 static void test_IUnknownChangeTypeEx(void)
5851 VARIANTARG vSrc
, vDst
;
5857 init_test_dispatch(1, VT_UI1
, &u
);
5858 pu
= (IUnknown
*)&u
.IDispatch_iface
;
5860 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
5862 V_VT(&vSrc
) = VT_UNKNOWN
;
5863 V_UNKNOWN(&vSrc
) = pu
;
5865 /* =>IDispatch in place */
5866 hres
= VariantChangeTypeEx(&vSrc
, &vSrc
, lcid
, 0, VT_DISPATCH
);
5867 ok(hres
== S_OK
&& u
.ref
== 1 &&
5868 V_VT(&vSrc
) == VT_DISPATCH
&& V_DISPATCH(&vSrc
) == (IDispatch
*)pu
,
5869 "change unk(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5870 S_OK
, 1, VT_DISPATCH
, pu
, hres
, u
.ref
, V_VT(&vSrc
), V_DISPATCH(&vSrc
));
5874 V_VT(&vSrc
) = VT_UNKNOWN
;
5875 V_UNKNOWN(&vSrc
) = pu
;
5877 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, VT_UNKNOWN
);
5878 /* Note vSrc is not cleared, as final refcount is 2 */
5879 ok(hres
== S_OK
&& u
.ref
== 2 &&
5880 V_VT(&vDst
) == VT_UNKNOWN
&& V_UNKNOWN(&vDst
) == pu
,
5881 "change unk(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
5882 S_OK
, 2, VT_UNKNOWN
, pu
, hres
, u
.ref
, V_VT(&vDst
), V_UNKNOWN(&vDst
));
5884 /* Can't change unknown to anything else */
5885 for (vt
= 0; vt
<= VT_BSTR_BLOB
; vt
++)
5887 HRESULT hExpected
= DISP_E_BADVARTYPE
;
5889 V_VT(&vSrc
) = VT_UNKNOWN
;
5890 V_UNKNOWN(&vSrc
) = pu
;
5893 if (vt
== VT_UNKNOWN
|| vt
== VT_DISPATCH
|| vt
== VT_EMPTY
|| vt
== VT_NULL
)
5897 if (vt
== VT_I8
|| vt
== VT_UI8
)
5900 hExpected
= DISP_E_TYPEMISMATCH
;
5902 else if (vt
== VT_RECORD
)
5904 hExpected
= DISP_E_TYPEMISMATCH
;
5906 else if (vt
>= VT_I2
&& vt
<= VT_UINT
&& vt
!= (VARTYPE
)15)
5907 hExpected
= DISP_E_TYPEMISMATCH
;
5910 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, vt
);
5911 ok(hres
== hExpected
,
5912 "change unk(badvar): vt %d expected 0x%08x, got 0x%08x\n",
5913 vt
, hExpected
, hres
);
5918 static void test_IDispatchClear(void)
5925 init_test_dispatch(1, VT_UI1
, &d
);
5926 pd
= &d
.IDispatch_iface
;
5928 /* As per IUnknown */
5930 V_VT(&v
) = VT_DISPATCH
;
5931 V_DISPATCH(&v
) = pd
;
5932 hres
= VariantClear(&v
);
5933 ok(hres
== S_OK
&& d
.ref
== 0 && V_VT(&v
) == VT_EMPTY
,
5934 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5935 S_OK
, 0, VT_EMPTY
, hres
, d
.ref
, V_VT(&v
));
5938 V_VT(&v
) = VT_DISPATCH
|VT_BYREF
;
5939 V_DISPATCHREF(&v
) = &pd
;
5940 hres
= VariantClear(&v
);
5941 ok(hres
== S_OK
&& d
.ref
== 1 && V_VT(&v
) == VT_EMPTY
,
5942 "clear dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5943 S_OK
, 1, VT_EMPTY
, hres
, d
.ref
, V_VT(&v
));
5946 static void test_IDispatchCopy(void)
5949 VARIANTARG vSrc
, vDst
;
5953 init_test_dispatch(1, VT_UI1
, &d
);
5954 pd
= &d
.IDispatch_iface
;
5956 /* As per IUnknown */
5959 V_VT(&vSrc
) = VT_DISPATCH
;
5960 V_DISPATCH(&vSrc
) = pd
;
5961 hres
= VariantCopy(&vDst
, &vSrc
);
5962 ok(hres
== S_OK
&& d
.ref
== 2 && V_VT(&vDst
) == VT_DISPATCH
,
5963 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5964 S_OK
, 2, VT_EMPTY
, hres
, d
.ref
, V_VT(&vDst
));
5968 V_VT(&vSrc
) = VT_DISPATCH
|VT_BYREF
;
5969 V_DISPATCHREF(&vSrc
) = &pd
;
5970 hres
= VariantCopy(&vDst
, &vSrc
);
5971 ok(hres
== S_OK
&& d
.ref
== 1 && V_VT(&vDst
) == (VT_DISPATCH
|VT_BYREF
),
5972 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5973 S_OK
, 1, VT_DISPATCH
, hres
, d
.ref
, V_VT(&vDst
));
5977 V_VT(&vSrc
) = VT_DISPATCH
|VT_BYREF
;
5978 V_DISPATCHREF(&vSrc
) = &pd
;
5979 hres
= VariantCopyInd(&vDst
, &vSrc
);
5980 ok(hres
== S_OK
&& d
.ref
== 2 && V_VT(&vDst
) == VT_DISPATCH
,
5981 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5982 S_OK
, 2, VT_DISPATCH
, hres
, d
.ref
, V_VT(&vDst
));
5985 V_VT(&vSrc
) = VT_DISPATCH
|VT_BYREF
;
5986 V_DISPATCHREF(&vSrc
) = &pd
;
5987 hres
= VariantCopyInd(&vSrc
, &vSrc
);
5988 ok(hres
== S_OK
&& d
.ref
== 2 && V_VT(&vSrc
) == VT_DISPATCH
,
5989 "copy dispatch: expected 0x%08x, %d, %d, got 0x%08x, %d, %d\n",
5990 S_OK
, 2, VT_DISPATCH
, hres
, d
.ref
, V_VT(&vSrc
));
5993 static void test_IDispatchChangeTypeEx(void)
5996 VARIANTARG vSrc
, vDst
;
6001 init_test_dispatch(1, VT_UI1
, &d
);
6002 pd
= &d
.IDispatch_iface
;
6004 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
6006 V_VT(&vSrc
) = VT_DISPATCH
;
6007 V_DISPATCH(&vSrc
) = pd
;
6009 /* =>IUnknown in place */
6010 hres
= VariantChangeTypeEx(&vSrc
, &vSrc
, lcid
, 0, VT_UNKNOWN
);
6011 ok(hres
== S_OK
&& d
.ref
== 1 &&
6012 V_VT(&vSrc
) == VT_UNKNOWN
&& V_UNKNOWN(&vSrc
) == (IUnknown
*)pd
,
6013 "change disp(src=src): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
6014 S_OK
, 1, VT_UNKNOWN
, pd
, hres
, d
.ref
, V_VT(&vSrc
), V_UNKNOWN(&vSrc
));
6018 V_VT(&vSrc
) = VT_DISPATCH
;
6019 V_DISPATCH(&vSrc
) = pd
;
6021 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, VT_UNKNOWN
);
6022 /* Note vSrc is not cleared, as final refcount is 2 */
6023 ok(hres
== S_OK
&& d
.ref
== 2 &&
6024 V_VT(&vDst
) == VT_UNKNOWN
&& V_UNKNOWN(&vDst
) == (IUnknown
*)pd
,
6025 "change disp(src,dst): expected 0x%08x,%d,%d,%p, got 0x%08x,%d,%d,%p\n",
6026 S_OK
, 2, VT_UNKNOWN
, pd
, hres
, d
.ref
, V_VT(&vDst
), V_UNKNOWN(&vDst
));
6028 /* FIXME: Verify that VARIANT_NOVALUEPROP prevents conversion to integral
6029 * types. this requires that the xxxFromDisp tests work first.
6034 static void test_ErrorChangeTypeEx(void)
6037 VARIANTARG vSrc
, vDst
;
6041 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
6043 for (vt
= 0; vt
<= VT_BSTR_BLOB
; vt
++)
6045 HRESULT hExpected
= DISP_E_BADVARTYPE
;
6047 V_VT(&vSrc
) = VT_ERROR
;
6050 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, vt
);
6056 if (vt
== VT_I8
|| vt
== VT_UI8
)
6059 hExpected
= DISP_E_TYPEMISMATCH
;
6061 else if (vt
== VT_RECORD
)
6063 hExpected
= DISP_E_TYPEMISMATCH
;
6065 else if (vt
<= VT_UINT
&& vt
!= (VARTYPE
)15)
6066 hExpected
= DISP_E_TYPEMISMATCH
;
6069 ok(hres
== hExpected
,
6070 "change err: vt %d expected 0x%08x, got 0x%08x\n", vt
, hExpected
, hres
);
6075 static void test_EmptyChangeTypeEx(void)
6080 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
6082 for (vt
= VT_EMPTY
; vt
<= VT_BSTR_BLOB
; vt
++)
6084 HRESULT hExpected
, hres
;
6085 VARIANTARG vSrc
, vDst
;
6087 /* skip for undefined types */
6088 if ((vt
== 15) || (vt
> VT_VERSIONED_STREAM
&& vt
< VT_BSTR_BLOB
))
6098 hExpected
= DISP_E_BADVARTYPE
;
6105 hExpected
= DISP_E_TYPEMISMATCH
;
6127 hExpected
= DISP_E_BADVARTYPE
;
6131 V_VT(&vSrc
) = VT_EMPTY
;
6132 memset(&vDst
, 0, sizeof(vDst
));
6133 V_VT(&vDst
) = VT_NULL
;
6135 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, vt
);
6136 ok(hres
== hExpected
, "change empty: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
6137 vt
, hExpected
, hres
, V_VT(&vDst
));
6140 ok(V_VT(&vDst
) == vt
, "change empty: vt %d, got %d\n", vt
, V_VT(&vDst
));
6141 VariantClear(&vDst
);
6147 static void test_NullChangeTypeEx(void)
6152 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
6154 for (vt
= VT_EMPTY
; vt
<= VT_BSTR_BLOB
; vt
++)
6156 VARIANTARG vSrc
, vDst
;
6157 HRESULT hExpected
, hres
;
6159 /* skip for undefined types */
6160 if ((vt
== 15) || (vt
> VT_VERSIONED_STREAM
&& vt
< VT_BSTR_BLOB
))
6168 hExpected
= DISP_E_TYPEMISMATCH
;
6170 hExpected
= DISP_E_BADVARTYPE
;
6196 hExpected
= DISP_E_TYPEMISMATCH
;
6199 hExpected
= DISP_E_BADVARTYPE
;
6203 V_VT(&vSrc
) = VT_NULL
;
6204 memset(&vDst
, 0, sizeof(vDst
));
6205 V_VT(&vDst
) = VT_EMPTY
;
6207 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, vt
);
6208 ok(hres
== hExpected
, "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
6209 vt
, hExpected
, hres
, V_VT(&vDst
));
6211 /* should work only for VT_NULL -> VT_NULL case */
6213 ok(V_VT(&vDst
) == VT_NULL
, "change null: VT_NULL expected 0x%08x, got 0x%08x, vt %d\n",
6214 hExpected
, hres
, V_VT(&vDst
));
6216 ok(V_VT(&vDst
) == VT_EMPTY
, "change null: vt %d expected 0x%08x, got 0x%08x, vt %d\n",
6217 vt
, hExpected
, hres
, V_VT(&vDst
));
6223 static void test_UintChangeTypeEx(void)
6226 VARIANTARG vSrc
, vDst
;
6229 lcid
= MAKELCID(MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
), SORT_DEFAULT
);
6231 /* Converting a VT_UINT to a VT_INT does not check for overflow */
6232 V_VT(&vDst
) = VT_EMPTY
;
6233 V_VT(&vSrc
) = VT_UINT
;
6235 hres
= VariantChangeTypeEx(&vDst
, &vSrc
, lcid
, 0, VT_I4
);
6236 ok(hres
== S_OK
&& V_VT(&vDst
) == VT_I4
&& V_I4(&vDst
) == -1,
6237 "change uint: Expected %d,0x%08x,%d got %d,0x%08x,%d\n",
6238 VT_I4
, S_OK
, -1, V_VT(&vDst
), hres
, V_I4(&vDst
));
6241 #define NUM_CUST_ITEMS 16
6243 static void test_ClearCustData(void)
6248 CHECKPTR(ClearCustData
);
6250 ci
.cCustData
= NUM_CUST_ITEMS
;
6251 ci
.prgCustData
= CoTaskMemAlloc( sizeof(CUSTDATAITEM
) * NUM_CUST_ITEMS
);
6252 for (i
= 0; i
< NUM_CUST_ITEMS
; i
++)
6253 VariantInit(&ci
.prgCustData
[i
].varValue
);
6254 pClearCustData(&ci
);
6255 ok(!ci
.cCustData
&& !ci
.prgCustData
, "ClearCustData didn't clear fields!\n");
6258 static void test_NullByRef(void)
6265 V_VT(&v1
) = VT_BYREF
|VT_VARIANT
;
6268 hRes
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, VT_I4
);
6269 ok(hRes
== DISP_E_TYPEMISMATCH
, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
6272 V_VT(&v1
) = VT_BYREF
|VT_VARIANT
;
6277 hRes
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, VT_VARIANT
);
6278 ok(hRes
== DISP_E_TYPEMISMATCH
, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
6279 ok(V_VT(&v2
) == VT_I4
&& V_I4(&v2
) == 123, "VariantChangeTypeEx shouldn't change pvargDest\n");
6281 hRes
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, VT_BYREF
|VT_I4
);
6282 ok(hRes
== DISP_E_TYPEMISMATCH
, "VariantChangeTypeEx should return DISP_E_TYPEMISMATCH\n");
6284 hRes
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, 0x3847);
6285 ok(hRes
== DISP_E_BADVARTYPE
, "VariantChangeTypeEx should return DISP_E_BADVARTYPE\n");
6288 /* Dst Variant should remain unchanged if VariantChangeType cannot convert */
6289 static void test_ChangeType_keep_dst(void)
6293 static const WCHAR testW
[] = {'t','e','s','t',0};
6296 bstr
= SysAllocString(testW
);
6299 V_VT(&v1
) = VT_BSTR
;
6301 hres
= VariantChangeTypeEx(&v1
, &v1
, 0, 0, VT_INT
);
6302 ok(hres
== DISP_E_TYPEMISMATCH
, "VariantChangeTypeEx returns %08x\n", hres
);
6303 ok(V_VT(&v1
) == VT_BSTR
&& V_BSTR(&v1
) == bstr
, "VariantChangeTypeEx changed dst variant\n");
6306 hres
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, VT_INT
);
6307 ok(hres
== DISP_E_TYPEMISMATCH
, "VariantChangeTypeEx returns %08x\n", hres
);
6308 ok(V_VT(&v2
) == VT_INT
&& V_INT(&v2
) == 4, "VariantChangeTypeEx changed dst variant\n");
6309 V_VT(&v2
) = 0xff; /* incorrect variant type */
6310 hres
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, VT_INT
);
6311 ok(hres
== DISP_E_TYPEMISMATCH
, "VariantChangeTypeEx returns %08x\n", hres
);
6312 ok(V_VT(&v2
) == 0xff, "VariantChangeTypeEx changed dst variant\n");
6313 hres
= VariantChangeTypeEx(&v2
, &v1
, 0, 0, VT_BSTR
);
6314 ok(hres
== DISP_E_BADVARTYPE
, "VariantChangeTypeEx returns %08x\n", hres
);
6315 ok(V_VT(&v2
) == 0xff, "VariantChangeTypeEx changed dst variant\n");
6316 SysFreeString(bstr
);
6319 /* This tests assumes an empty cache, so it needs to be ran early in the test. */
6320 static void test_bstr_cache(void)
6322 BSTR str
, str2
, strs
[20];
6325 static const WCHAR testW
[] = {'t','e','s','t',0};
6327 if (GetEnvironmentVariableA("OANOCACHE", NULL
, 0)) {
6328 skip("BSTR cache is disabled, some tests will be skipped.\n");
6332 str
= SysAllocString(testW
);
6333 /* This should put the string into cache */
6335 /* The string is in cache, this won't touch it */
6338 ok(SysStringLen(str
) == 4, "unexpected len\n");
6339 ok(!lstrcmpW(str
, testW
), "string changed\n");
6341 str2
= SysAllocString(testW
);
6342 ok(str
== str2
, "str != str2\n");
6343 SysFreeString(str2
);
6345 /* Fill the bucket with cached entries. */
6346 for(i
=0; i
< sizeof(strs
)/sizeof(*strs
); i
++)
6347 strs
[i
] = SysAllocStringLen(NULL
, 24);
6348 for(i
=0; i
< sizeof(strs
)/sizeof(*strs
); i
++)
6349 SysFreeString(strs
[i
]);
6351 /* Following allocation will be made from cache */
6352 str
= SysAllocStringLen(NULL
, 24);
6353 ok(str
== strs
[0], "str != strs[0]\n");
6355 /* Smaller buffers may also use larget cached buffers */
6356 str2
= SysAllocStringLen(NULL
, 16);
6357 ok(str2
== strs
[1], "str2 != strs[1]\n");
6360 SysFreeString(str2
);
6362 SysFreeString(str2
);
6365 static void write_typelib(int res_no
, const char *filename
)
6372 file
= CreateFileA( filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, 0, 0 );
6373 ok( file
!= INVALID_HANDLE_VALUE
, "file creation failed\n" );
6374 if (file
== INVALID_HANDLE_VALUE
) return;
6375 res
= FindResourceA( GetModuleHandleA(NULL
), (LPCSTR
)MAKEINTRESOURCE(res_no
), "TYPELIB" );
6376 ok( res
!= 0, "couldn't find resource\n" );
6377 ptr
= LockResource( LoadResource( GetModuleHandleA(NULL
), res
));
6378 WriteFile( file
, ptr
, SizeofResource( GetModuleHandleA(NULL
), res
), &written
, NULL
);
6379 ok( written
== SizeofResource( GetModuleHandleA(NULL
), res
), "couldn't write resource\n" );
6380 CloseHandle( file
);
6383 static const char *create_test_typelib(int res_no
)
6385 static char filename
[MAX_PATH
];
6387 GetTempFileNameA( ".", "tlb", 0, filename
);
6388 write_typelib(res_no
, filename
);
6392 static void test_recinfo(void)
6394 static const WCHAR testW
[] = {'t','e','s','t',0};
6395 static WCHAR teststructW
[] = {'t','e','s','t','_','s','t','r','u','c','t',0};
6396 static WCHAR teststruct2W
[] = {'t','e','s','t','_','s','t','r','u','c','t','2',0};
6397 static WCHAR teststruct3W
[] = {'t','e','s','t','_','s','t','r','u','c','t','3',0};
6398 WCHAR filenameW
[MAX_PATH
], filename2W
[MAX_PATH
];
6399 ITypeInfo
*typeinfo
, *typeinfo2
, *typeinfo3
;
6400 IRecordInfo
*recinfo
, *recinfo2
, *recinfo3
;
6401 struct test_struct teststruct
, testcopy
;
6402 ITypeLib
*typelib
, *typelib2
;
6403 const char *filename
;
6404 DummyDispatch dispatch
;
6412 filename
= create_test_typelib(2);
6413 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filenameW
, MAX_PATH
);
6414 hr
= LoadTypeLibEx(filenameW
, REGKIND_NONE
, &typelib
);
6415 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6417 filename
= create_test_typelib(3);
6418 MultiByteToWideChar(CP_ACP
, 0, filename
, -1, filename2W
, MAX_PATH
);
6419 hr
= LoadTypeLibEx(filename2W
, REGKIND_NONE
, &typelib2
);
6420 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6424 hr
= ITypeLib_FindName(typelib
, teststructW
, 0, &typeinfo
, &memid
, &found
);
6425 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6426 ok(typeinfo
!= NULL
, "got %p\n", typeinfo
);
6427 hr
= ITypeInfo_GetTypeAttr(typeinfo
, &attr
);
6428 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6429 ok(IsEqualGUID(&attr
->guid
, &UUID_test_struct
), "got %s\n", wine_dbgstr_guid(&attr
->guid
));
6430 ok(attr
->typekind
== TKIND_RECORD
, "got %d\n", attr
->typekind
);
6434 hr
= ITypeLib_FindName(typelib
, teststruct2W
, 0, &typeinfo2
, &memid
, &found
);
6435 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6436 ok(typeinfo2
!= NULL
, "got %p\n", typeinfo2
);
6440 hr
= ITypeLib_FindName(typelib2
, teststruct3W
, 0, &typeinfo3
, &memid
, &found
);
6441 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6442 ok(typeinfo3
!= NULL
, "got %p\n", typeinfo3
);
6444 hr
= GetRecordInfoFromTypeInfo(typeinfo
, &recinfo
);
6445 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6447 hr
= GetRecordInfoFromTypeInfo(typeinfo2
, &recinfo2
);
6448 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6450 hr
= GetRecordInfoFromTypeInfo(typeinfo3
, &recinfo3
);
6451 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6453 /* IsMatchingType, these two records only differ in GUIDs */
6454 ret
= IRecordInfo_IsMatchingType(recinfo
, recinfo2
);
6455 ok(!ret
, "got %d\n", ret
);
6457 /* these two have same GUIDs, but different set of fields */
6458 ret
= IRecordInfo_IsMatchingType(recinfo2
, recinfo3
);
6459 ok(ret
, "got %d\n", ret
);
6461 IRecordInfo_Release(recinfo3
);
6462 ITypeInfo_Release(typeinfo3
);
6463 IRecordInfo_Release(recinfo2
);
6464 ITypeInfo_Release(typeinfo2
);
6467 hr
= IRecordInfo_GetSize(recinfo
, &size
);
6468 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6469 ok(size
== sizeof(struct test_struct
), "got size %d\n", size
);
6470 ok(attr
->cbSizeInstance
== sizeof(struct test_struct
), "got instance size %d\n", attr
->cbSizeInstance
);
6471 ITypeInfo_ReleaseTypeAttr(typeinfo
, attr
);
6474 teststruct
.hr
= E_FAIL
;
6476 teststruct
.disp
= (void*)0xdeadbeef;
6477 teststruct
.bstr
= (void*)0xdeadbeef;
6479 hr
= IRecordInfo_RecordInit(recinfo
, &teststruct
);
6480 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6481 ok(teststruct
.hr
== 0, "got 0x%08x\n", teststruct
.hr
);
6482 ok(teststruct
.b
== 0, "got 0x%08x\n", teststruct
.b
);
6483 ok(teststruct
.disp
== NULL
, "got %p\n", teststruct
.disp
);
6484 ok(teststruct
.bstr
== NULL
, "got %p\n", teststruct
.bstr
);
6486 init_test_dispatch(10, VT_UI1
, &dispatch
);
6488 /* RecordCopy(), interface field reference increased */
6489 teststruct
.hr
= S_FALSE
;
6490 teststruct
.b
= VARIANT_TRUE
;
6491 teststruct
.disp
= &dispatch
.IDispatch_iface
;
6492 teststruct
.bstr
= SysAllocString(testW
);
6493 memset(&testcopy
, 0, sizeof(testcopy
));
6494 hr
= IRecordInfo_RecordCopy(recinfo
, &teststruct
, &testcopy
);
6495 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6496 ok(testcopy
.hr
== S_FALSE
, "got 0x%08x\n", testcopy
.hr
);
6497 ok(testcopy
.b
== VARIANT_TRUE
, "got %d\n", testcopy
.b
);
6498 ok(testcopy
.disp
== teststruct
.disp
, "got %p\n", testcopy
.disp
);
6499 ok(dispatch
.ref
== 11, "got %d\n", dispatch
.ref
);
6500 ok(testcopy
.bstr
!= teststruct
.bstr
, "got %p\n", testcopy
.bstr
);
6501 ok(!lstrcmpW(testcopy
.bstr
, teststruct
.bstr
), "got %s, %s\n", wine_dbgstr_w(testcopy
.bstr
), wine_dbgstr_w(teststruct
.bstr
));
6504 hr
= IRecordInfo_RecordClear(recinfo
, &teststruct
);
6505 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6506 ok(teststruct
.bstr
== NULL
, "got %p\n", teststruct
.bstr
);
6507 hr
= IRecordInfo_RecordClear(recinfo
, &testcopy
);
6508 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6509 ok(testcopy
.bstr
== NULL
, "got %p\n", testcopy
.bstr
);
6511 /* now the destination contains the interface pointer */
6512 memset(&testcopy
, 0, sizeof(testcopy
));
6513 testcopy
.disp
= &dispatch
.IDispatch_iface
;
6516 hr
= IRecordInfo_RecordCopy(recinfo
, &teststruct
, &testcopy
);
6517 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
6518 ok(dispatch
.ref
== 9, "got %d\n", dispatch
.ref
);
6520 IRecordInfo_Release(recinfo
);
6522 ITypeInfo_Release(typeinfo
);
6523 ITypeLib_Release(typelib
);
6524 DeleteFileW(filenameW
);
6525 DeleteFileW(filename2W
);
6530 hOleaut32
= GetModuleHandleA("oleaut32.dll");
6532 has_i8
= GetProcAddress(hOleaut32
, "VarI8FromI1") != NULL
;
6533 has_locales
= has_i8
&& GetProcAddress(hOleaut32
, "GetVarConversionLocaleSetting") != NULL
;
6535 trace("LCIDs: System=0x%08x, User=0x%08x\n", GetSystemDefaultLCID(),
6536 GetUserDefaultLCID());
6543 test_VarI1FromUI1();
6544 test_VarI1FromUI2();
6545 test_VarI1FromUI4();
6546 test_VarI1FromUI8();
6547 test_VarI1FromBool();
6550 test_VarI1FromDate();
6552 test_VarI1FromDec();
6553 test_VarI1FromStr();
6554 test_VarUI1FromDisp();
6556 test_VarI1ChangeTypeEx();
6558 test_VarUI1FromI1();
6559 test_VarUI1FromI2();
6560 test_VarUI1FromI4();
6561 test_VarUI1FromI8();
6562 test_VarUI1FromUI2();
6563 test_VarUI1FromUI4();
6564 test_VarUI1FromUI8();
6565 test_VarUI1FromBool();
6566 test_VarUI1FromR4();
6567 test_VarUI1FromR8();
6568 test_VarUI1FromDate();
6569 test_VarUI1FromCy();
6570 test_VarUI1FromDec();
6571 test_VarUI1FromStr();
6573 test_VarUI1ChangeTypeEx();
6578 test_VarI2FromUI1();
6579 test_VarI2FromUI2();
6580 test_VarI2FromUI4();
6581 test_VarI2FromUI8();
6582 test_VarI2FromBool();
6585 test_VarI2FromDate();
6587 test_VarI2FromDec();
6588 test_VarI2FromStr();
6590 test_VarI2ChangeTypeEx();
6592 test_VarUI2FromI1();
6593 test_VarUI2FromI2();
6594 test_VarUI2FromI4();
6595 test_VarUI2FromI8();
6596 test_VarUI2FromUI1();
6597 test_VarUI2FromUI4();
6598 test_VarUI2FromUI8();
6599 test_VarUI2FromBool();
6600 test_VarUI2FromR4();
6601 test_VarUI2FromR8();
6602 test_VarUI2FromDate();
6603 test_VarUI2FromCy();
6604 test_VarUI2FromDec();
6605 test_VarUI2FromStr();
6607 test_VarUI2ChangeTypeEx();
6612 test_VarI4FromUI1();
6613 test_VarI4FromUI2();
6614 test_VarI4FromUI4();
6615 test_VarI4FromUI8();
6616 test_VarI4FromBool();
6619 test_VarI4FromDate();
6621 test_VarI4FromDec();
6622 test_VarI4FromStr();
6624 test_VarI4ChangeTypeEx();
6626 test_VarUI4FromI1();
6627 test_VarUI4FromI2();
6628 test_VarUI4FromUI2();
6629 test_VarUI4FromI8();
6630 test_VarUI4FromUI1();
6631 test_VarUI4FromI4();
6632 test_VarUI4FromUI8();
6633 test_VarUI4FromBool();
6634 test_VarUI4FromR4();
6635 test_VarUI4FromR8();
6636 test_VarUI4FromDate();
6637 test_VarUI4FromCy();
6638 test_VarUI4FromDec();
6639 test_VarUI4FromStr();
6641 test_VarUI4ChangeTypeEx();
6644 test_VarI8FromUI1();
6646 test_VarI8FromUI2();
6647 test_VarI8FromUI4();
6650 test_VarI8FromBool();
6651 test_VarI8FromUI8();
6653 test_VarI8FromDec();
6654 test_VarI8FromDate();
6655 test_VarI8FromStr();
6657 test_VarI8ChangeTypeEx();
6659 test_VarUI8FromI1();
6660 test_VarUI8FromUI1();
6661 test_VarUI8FromI2();
6662 test_VarUI8FromUI2();
6663 test_VarUI8FromUI4();
6664 test_VarUI8FromR4();
6665 test_VarUI8FromR8();
6666 test_VarUI8FromBool();
6667 test_VarUI8FromI8();
6668 test_VarUI8FromCy();
6669 test_VarUI8FromDec();
6670 test_VarUI8FromDate();
6671 test_VarUI8FromStr();
6673 test_VarUI8ChangeTypeEx();
6676 test_VarR4FromUI1();
6678 test_VarR4FromUI2();
6680 test_VarR4FromUI4();
6682 test_VarR4FromBool();
6685 test_VarR4FromUI8();
6686 test_VarR4FromDec();
6687 test_VarR4FromDate();
6688 test_VarR4FromStr();
6690 test_VarR4ChangeTypeEx();
6693 test_VarR8FromUI1();
6695 test_VarR8FromUI2();
6697 test_VarR8FromUI4();
6699 test_VarR8FromBool();
6702 test_VarR8FromUI8();
6703 test_VarR8FromDec();
6704 test_VarR8FromDate();
6705 test_VarR8FromStr();
6707 test_VarR8ChangeTypeEx();
6710 test_VarDateFromI1();
6711 test_VarDateFromUI1();
6712 test_VarDateFromI2();
6713 test_VarDateFromUI2();
6714 test_VarDateFromI4();
6715 test_VarDateFromUI4();
6716 test_VarDateFromR4();
6717 test_VarDateFromR8();
6718 test_VarDateFromBool();
6719 test_VarDateFromCy();
6720 test_VarDateFromI8();
6721 test_VarDateFromUI8();
6722 test_VarDateFromDec();
6723 test_VarDateFromStr();
6725 test_VarDateChangeTypeEx();
6728 test_VarCyFromUI1();
6730 test_VarCyFromUI2();
6732 test_VarCyFromUI4();
6735 test_VarCyFromBool();
6737 test_VarCyFromUI8();
6738 test_VarCyFromDec();
6739 test_VarCyFromDate();
6754 test_VarDecFromI1();
6755 test_VarDecFromI2();
6756 test_VarDecFromI4();
6757 test_VarDecFromI8();
6758 test_VarDecFromUI1();
6759 test_VarDecFromUI2();
6760 test_VarDecFromUI4();
6761 test_VarDecFromUI8();
6762 test_VarDecFromR4();
6763 test_VarDecFromR8();
6764 test_VarDecFromDate();
6765 test_VarDecFromStr();
6766 test_VarDecFromCy();
6767 test_VarDecFromDate();
6768 test_VarDecFromBool();
6780 test_VarBoolFromI1();
6781 test_VarBoolFromUI1();
6782 test_VarBoolFromI2();
6783 test_VarBoolFromUI2();
6784 test_VarBoolFromI4();
6785 test_VarBoolFromUI4();
6786 test_VarBoolFromR4();
6787 test_VarBoolFromR8();
6788 test_VarBoolFromCy();
6789 test_VarBoolFromI8();
6790 test_VarBoolFromUI8();
6791 test_VarBoolFromDec();
6792 test_VarBoolFromDate();
6793 test_VarBoolFromStr();
6795 test_VarBoolChangeTypeEx();
6797 test_VarBstrFromR4();
6798 test_VarBstrFromDate();
6799 test_VarBstrFromCy();
6800 test_VarBstrFromDec();
6802 test_SysStringLen();
6803 test_SysStringByteLen();
6804 test_SysAllocString();
6805 test_SysAllocStringLen();
6806 test_SysAllocStringByteLen();
6807 test_SysReAllocString();
6808 test_SysReAllocStringLen();
6812 test_IUnknownClear();
6813 test_IUnknownCopy();
6814 test_IUnknownChangeTypeEx();
6816 test_IDispatchClear();
6817 test_IDispatchCopy();
6818 test_IDispatchChangeTypeEx();
6820 test_ErrorChangeTypeEx();
6821 test_EmptyChangeTypeEx();
6822 test_NullChangeTypeEx();
6823 test_UintChangeTypeEx();
6825 test_ClearCustData();
6828 test_ChangeType_keep_dst();