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