1 /* OLE DB Conversion library tests
3 * Copyright 2009 Huw Davies
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #define NONAMELESSUNION
24 #define NONAMELESSSTRUCT
36 #include "wine/test.h"
38 static IDataConvert
*convert
;
40 static void test_dcinfo(void)
47 hr
= CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IDCInfo
, (void**)&info
);
50 win_skip("Unable to load oledb conversion library\n");
54 types
[0] = DCINFOTYPE_VERSION
;
55 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
56 ok(hr
== S_OK
, "got %08x\n", hr
);
58 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
59 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
60 ok(V_UI4(&inf
->vData
) == 0x110, "got %08x\n", V_UI4(&inf
->vData
));
62 V_UI4(&inf
->vData
) = 0x200;
63 hr
= IDCInfo_SetInfo(info
, 1, inf
);
64 ok(hr
== S_OK
, "got %08x\n", hr
);
67 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
68 ok(hr
== S_OK
, "got %08x\n", hr
);
69 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
70 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
71 ok(V_UI4(&inf
->vData
) == 0x200, "got %08x\n", V_UI4(&inf
->vData
));
73 V_UI4(&inf
->vData
) = 0x100;
74 hr
= IDCInfo_SetInfo(info
, 1, inf
);
75 ok(hr
== S_OK
, "got %08x\n", hr
);
78 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
79 ok(hr
== S_OK
, "got %08x\n", hr
);
80 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
81 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
82 ok(V_UI4(&inf
->vData
) == 0x100, "got %08x\n", V_UI4(&inf
->vData
));
84 V_UI4(&inf
->vData
) = 0x500;
85 hr
= IDCInfo_SetInfo(info
, 1, inf
);
86 ok(hr
== S_OK
, "got %08x\n", hr
);
89 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
90 ok(hr
== S_OK
, "got %08x\n", hr
);
91 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
92 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
93 ok(V_UI4(&inf
->vData
) == 0x500, "got %08x\n", V_UI4(&inf
->vData
));
95 V_UI4(&inf
->vData
) = 0xffff;
96 hr
= IDCInfo_SetInfo(info
, 1, inf
);
97 ok(hr
== S_OK
, "got %08x\n", hr
);
100 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
101 ok(hr
== S_OK
, "got %08x\n", hr
);
102 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
103 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
104 ok(V_UI4(&inf
->vData
) == 0xffff, "got %08x\n", V_UI4(&inf
->vData
));
106 V_UI4(&inf
->vData
) = 0x12345678;
107 hr
= IDCInfo_SetInfo(info
, 1, inf
);
108 ok(hr
== S_OK
, "got %08x\n", hr
);
111 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
112 ok(hr
== S_OK
, "got %08x\n", hr
);
113 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
114 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
115 ok(V_UI4(&inf
->vData
) == 0x12345678, "got %08x\n", V_UI4(&inf
->vData
));
117 /* Try setting a version variant of something other than VT_UI4 */
118 V_VT(&inf
->vData
) = VT_I4
;
119 V_I4(&inf
->vData
) = 0x200;
120 hr
= IDCInfo_SetInfo(info
, 1, inf
);
121 ok(hr
== DB_S_ERRORSOCCURRED
, "got %08x\n", hr
);
124 hr
= IDCInfo_GetInfo(info
, 1, types
, &inf
);
125 ok(hr
== S_OK
, "got %08x\n", hr
);
126 ok(inf
->eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
->eInfoType
);
127 ok(V_VT(&inf
->vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
->vData
));
128 ok(V_UI4(&inf
->vData
) == 0x12345678, "got %08x\n", V_UI4(&inf
->vData
));
131 /* More than one type */
133 hr
= IDCInfo_GetInfo(info
, 2, types
, &inf
);
134 ok(hr
== S_OK
, "got %08x\n", hr
);
135 ok(inf
[0].eInfoType
== DCINFOTYPE_VERSION
, "got %08x\n", inf
[0].eInfoType
);
136 ok(V_VT(&inf
[0].vData
) == VT_UI4
, "got %08x\n", V_VT(&inf
[0].vData
));
137 ok(V_UI4(&inf
[0].vData
) == 0x12345678, "got %08x\n", V_UI4(&inf
[0].vData
));
138 ok(inf
[1].eInfoType
== 2, "got %08x\n", inf
[1].eInfoType
);
139 ok(V_VT(&inf
[1].vData
) == VT_EMPTY
, "got %08x\n", V_VT(&inf
[1].vData
));
141 hr
= IDCInfo_SetInfo(info
, 2, inf
);
142 ok(hr
== S_OK
, "got %08x\n", hr
);
146 IDCInfo_Release(info
);
149 static const struct can_convert
152 DWORD can_convert_to
;
155 {DBTYPE_EMPTY
, 0x63bfd9ff},
156 {DBTYPE_NULL
, 0x40001002},
157 {DBTYPE_I2
, 0x3b9fd9ff},
158 {DBTYPE_I4
, 0x3bdfd9ff},
160 {DBTYPE_R4
, 0x3b9fd9ff},
161 {DBTYPE_R8
, 0x3b9fd9ff},
162 {DBTYPE_CY
, 0x039fd97f},
163 {DBTYPE_DATE
, 0x799f99bf},
165 {DBTYPE_BSTR
, 0x7bffd9ff},
166 {DBTYPE_IDISPATCH
, 0x7bffffff},
167 {DBTYPE_ERROR
, 0x01001500},
168 {DBTYPE_BOOL
, 0x039fd9ff},
170 {DBTYPE_VARIANT
, 0x7bffffff},
171 {DBTYPE_IUNKNOWN
, 0x00003203},
172 {DBTYPE_DECIMAL
, 0x3b9fd97f},
173 {DBTYPE_I1
, 0x3b9fd9ff},
175 {DBTYPE_UI1
, 0x3b9fd9ff},
176 {DBTYPE_UI2
, 0x3b9fd9ff},
177 {DBTYPE_UI4
, 0x3bdfd9ff},
178 {DBTYPE_I8
, 0x43dfd97f},
180 {DBTYPE_UI8
, 0x43dfd97f},
181 {DBTYPE_GUID
, 0x01e01103},
182 {DBTYPE_BYTES
, 0x01fc110b},
183 {DBTYPE_STR
, 0x7bffd9ff},
185 {DBTYPE_WSTR
, 0x7bffd9ff},
186 {DBTYPE_NUMERIC
, 0x039fd97f},
187 {DBTYPE_UDT
, 0x00000000},
188 {DBTYPE_DBDATE
, 0x79801183},
190 {DBTYPE_DBTIME
, 0x79801183},
191 {DBTYPE_DBTIMESTAMP
, 0x79801183},
192 {DBTYPE_FILETIME
, 0x79981183}
196 static inline BOOL
array_type(DBTYPE type
)
198 return (type
>= DBTYPE_I2
&& type
<= DBTYPE_UI4
);
201 static void test_canconvert(void)
204 int src_idx
, dst_idx
;
206 /* Some older versions of the library don't support several conversions, we'll skip
207 if we have such a library */
208 hr
= IDataConvert_CanConvert(convert
, DBTYPE_EMPTY
, DBTYPE_DBTIMESTAMP
);
211 win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
215 /* Some older versions of the library don't support several conversions, we'll skip
216 if we have such a library */
217 hr
= IDataConvert_CanConvert(convert
, DBTYPE_EMPTY
, DBTYPE_DBTIMESTAMP
);
220 win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
224 for(src_idx
= 0; src_idx
< sizeof(simple_convert
) / sizeof(simple_convert
[0]); src_idx
++)
225 for(dst_idx
= 0; dst_idx
< sizeof(simple_convert
) / sizeof(simple_convert
[0]); dst_idx
++)
227 BOOL expect
, simple_expect
;
228 simple_expect
= (simple_convert
[src_idx
].can_convert_to
>> dst_idx
) & 1;
230 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
, simple_convert
[dst_idx
].type
);
231 expect
= simple_expect
;
232 ok((hr
== S_OK
&& expect
== TRUE
) ||
233 (hr
== S_FALSE
&& expect
== FALSE
),
234 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
,
235 simple_convert
[dst_idx
].type
, hr
, expect
? "" : "not ");
237 /* src DBTYPE_BYREF */
238 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
| DBTYPE_BYREF
, simple_convert
[dst_idx
].type
);
239 expect
= simple_expect
;
240 ok((hr
== S_OK
&& expect
== TRUE
) ||
241 (hr
== S_FALSE
&& expect
== FALSE
),
242 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
| DBTYPE_BYREF
,
243 simple_convert
[dst_idx
].type
, hr
, expect
? "" : "not ");
245 /* dst DBTYPE_BYREF */
246 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
, simple_convert
[dst_idx
].type
| DBTYPE_BYREF
);
249 (simple_convert
[dst_idx
].type
== DBTYPE_BYTES
||
250 simple_convert
[dst_idx
].type
== DBTYPE_STR
||
251 simple_convert
[dst_idx
].type
== DBTYPE_WSTR
))
253 ok((hr
== S_OK
&& expect
== TRUE
) ||
254 (hr
== S_FALSE
&& expect
== FALSE
),
255 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
,
256 simple_convert
[dst_idx
].type
| DBTYPE_BYREF
, hr
, expect
? "" : "not ");
258 /* src & dst DBTYPE_BYREF */
259 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
| DBTYPE_BYREF
, simple_convert
[dst_idx
].type
| DBTYPE_BYREF
);
262 (simple_convert
[dst_idx
].type
== DBTYPE_BYTES
||
263 simple_convert
[dst_idx
].type
== DBTYPE_STR
||
264 simple_convert
[dst_idx
].type
== DBTYPE_WSTR
))
266 ok((hr
== S_OK
&& expect
== TRUE
) ||
267 (hr
== S_FALSE
&& expect
== FALSE
),
268 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
| DBTYPE_BYREF
,
269 simple_convert
[dst_idx
].type
| DBTYPE_BYREF
, hr
, expect
? "" : "not ");
271 /* src DBTYPE_ARRAY */
272 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
| DBTYPE_ARRAY
, simple_convert
[dst_idx
].type
);
274 if(array_type(simple_convert
[src_idx
].type
) && simple_convert
[dst_idx
].type
== DBTYPE_VARIANT
)
276 ok((hr
== S_OK
&& expect
== TRUE
) ||
277 (hr
== S_FALSE
&& expect
== FALSE
),
278 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
| DBTYPE_ARRAY
,
279 simple_convert
[dst_idx
].type
, hr
, expect
? "" : "not ");
281 /* dst DBTYPE_ARRAY */
282 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
, simple_convert
[dst_idx
].type
| DBTYPE_ARRAY
);
284 if(array_type(simple_convert
[dst_idx
].type
) &&
285 (simple_convert
[src_idx
].type
== DBTYPE_IDISPATCH
||
286 simple_convert
[src_idx
].type
== DBTYPE_VARIANT
))
288 ok((hr
== S_OK
&& expect
== TRUE
) ||
289 (hr
== S_FALSE
&& expect
== FALSE
),
290 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
,
291 simple_convert
[dst_idx
].type
| DBTYPE_ARRAY
, hr
, expect
? "" : "not ");
293 /* src & dst DBTYPE_ARRAY */
294 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
| DBTYPE_ARRAY
, simple_convert
[dst_idx
].type
| DBTYPE_ARRAY
);
296 if(array_type(simple_convert
[src_idx
].type
) &&
297 simple_convert
[src_idx
].type
== simple_convert
[dst_idx
].type
)
299 ok((hr
== S_OK
&& expect
== TRUE
) ||
300 (hr
== S_FALSE
&& expect
== FALSE
),
301 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
| DBTYPE_ARRAY
,
302 simple_convert
[dst_idx
].type
| DBTYPE_ARRAY
, hr
, expect
? "" : "not ");
304 /* src DBTYPE_VECTOR */
305 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
| DBTYPE_VECTOR
, simple_convert
[dst_idx
].type
);
307 ok((hr
== S_OK
&& expect
== TRUE
) ||
308 (hr
== S_FALSE
&& expect
== FALSE
),
309 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
| DBTYPE_VECTOR
,
310 simple_convert
[dst_idx
].type
, hr
, expect
? "" : "not ");
312 /* dst DBTYPE_VECTOR */
313 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
, simple_convert
[dst_idx
].type
| DBTYPE_VECTOR
);
315 ok((hr
== S_OK
&& expect
== TRUE
) ||
316 (hr
== S_FALSE
&& expect
== FALSE
),
317 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
,
318 simple_convert
[dst_idx
].type
| DBTYPE_VECTOR
, hr
, expect
? "" : "not ");
320 /* src & dst DBTYPE_VECTOR */
321 hr
= IDataConvert_CanConvert(convert
, simple_convert
[src_idx
].type
| DBTYPE_VECTOR
, simple_convert
[dst_idx
].type
| DBTYPE_VECTOR
);
323 ok((hr
== S_OK
&& expect
== TRUE
) ||
324 (hr
== S_FALSE
&& expect
== FALSE
),
325 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert
[src_idx
].type
| DBTYPE_VECTOR
,
326 simple_convert
[dst_idx
].type
| DBTYPE_VECTOR
, hr
, expect
? "" : "not ");
332 static void test_converttoi2(void)
339 static const WCHAR ten
[] = {'1','0',0};
342 dst_len
= dst
= 0x1234;
343 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
344 ok(hr
== S_OK
, "got %08x\n", hr
);
345 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
346 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
347 ok(dst
== 0, "got %08x\n", dst
);
349 dst_len
= dst
= 0x1234;
350 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
351 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
352 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
353 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
354 ok(dst
== 0x1234, "got %08x\n", dst
);
356 dst_len
= dst
= 0x1234;
357 *(short *)src
= 0x4321;
358 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
359 ok(hr
== S_OK
, "got %08x\n", hr
);
360 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
361 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
362 ok(dst
== 0x4321, "got %08x\n", dst
);
364 dst_len
= dst
= 0x1234;
365 *(int *)src
= 0x4321cafe;
366 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
368 ok(hr
== DB_E_DATAOVERFLOW
, "got %08x\n", hr
);
369 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
370 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
371 ok(dst
== 0x1234, "got %08x\n", dst
);
373 dst_len
= dst
= 0x1234;
374 *(int *)src
= 0x4321;
375 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
376 ok(hr
== S_OK
, "got %08x\n", hr
);
377 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
378 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
379 ok(dst
== 0x4321, "got %08x\n", dst
);
381 dst_len
= dst
= 0x1234;
382 *(FLOAT
*)src
= 10.75;
383 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
384 ok(hr
== S_OK
, "got %08x\n", hr
);
385 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
386 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
387 ok(dst
== 11, "got %08x\n", dst
);
389 dst_len
= dst
= 0x1234;
390 *(FLOAT
*)src
= -10.75;
391 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
392 ok(hr
== S_OK
, "got %08x\n", hr
);
393 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
394 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
395 ok(dst
== -11, "got %08x\n", dst
);
397 dst_len
= dst
= 0x1234;
398 *(double *)src
= 10.75;
399 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
400 ok(hr
== S_OK
, "got %08x\n", hr
);
401 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
402 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
403 ok(dst
== 11, "got %08x\n", dst
);
405 dst_len
= dst
= 0x1234;
406 ((LARGE_INTEGER
*)src
)->QuadPart
= 107500;
407 hr
= IDataConvert_DataConvert(convert
, DBTYPE_CY
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
408 ok(hr
== S_OK
, "got %08x\n", hr
);
409 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
410 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
411 ok(dst
== 11, "got %08x\n", dst
);
413 dst_len
= dst
= 0x1234;
414 *(DATE
*)src
= 10.7500;
415 hr
= IDataConvert_DataConvert(convert
, DBTYPE_DATE
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
416 ok(hr
== S_OK
, "got %08x\n", hr
);
417 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
418 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
419 ok(dst
== 11, "got %08x\n", dst
);
421 dst_len
= dst
= 0x1234;
422 b
= SysAllocString(ten
);
424 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
425 ok(hr
== S_OK
, "got %08x\n", hr
);
426 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
427 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
428 ok(dst
== 10, "got %08x\n", dst
);
431 dst_len
= dst
= 0x1234;
432 *(SCODE
*)src
= 0x4321cafe;
433 hr
= IDataConvert_DataConvert(convert
, DBTYPE_ERROR
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
434 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
435 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
436 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
437 ok(dst
== 0x1234, "got %08x\n", dst
);
439 dst_len
= dst
= 0x1234;
440 *(VARIANT_BOOL
*)src
= VARIANT_TRUE
;
441 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BOOL
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
442 ok(hr
== S_OK
, "got %08x\n", hr
);
443 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
444 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
445 ok(dst
== -1, "got %08x\n", dst
);
447 dst_len
= dst
= 0x1234;
448 *(VARIANT_BOOL
*)src
= VARIANT_FALSE
;
449 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BOOL
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
450 ok(hr
== S_OK
, "got %08x\n", hr
);
451 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
452 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
453 ok(dst
== 0, "got %08x\n", dst
);
455 dst_len
= dst
= 0x1234;
456 V_VT((VARIANT
*)src
) = VT_I2
;
457 V_I2((VARIANT
*)src
) = 0x4321;
458 hr
= IDataConvert_DataConvert(convert
, DBTYPE_VARIANT
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
459 ok(hr
== S_OK
, "got %08x\n", hr
);
460 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
461 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
462 ok(dst
== 0x4321, "got %08x\n", dst
);
464 dst_len
= dst
= 0x1234;
465 memset(src
, 0, sizeof(DECIMAL
));
466 ((DECIMAL
*)src
)->u1
.Lo64
= 0x4321;
467 hr
= IDataConvert_DataConvert(convert
, DBTYPE_DECIMAL
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
468 ok(hr
== S_OK
, "got %08x\n", hr
);
469 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
470 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
471 ok(dst
== 0x4321, "got %08x\n", dst
);
473 dst_len
= dst
= 0x1234;
474 *(signed char*)src
= 0xab;
475 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I1
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
476 ok(hr
== S_OK
, "got %08x\n", hr
);
477 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
478 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
479 ok(dst
== (signed short)0xffab, "got %08x\n", dst
);
481 dst_len
= dst
= 0x1234;
483 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI1
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
484 ok(hr
== S_OK
, "got %08x\n", hr
);
485 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
486 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
487 ok(dst
== 0xab, "got %08x\n", dst
);
489 dst_len
= dst
= 0x1234;
490 *(WORD
*)src
= 0x4321;
491 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI2
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
492 ok(hr
== S_OK
, "got %08x\n", hr
);
493 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
494 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
495 ok(dst
== 0x4321, "got %08x\n", dst
);
497 dst_len
= dst
= 0x1234;
498 *(WORD
*)src
= 0xabcd;
499 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI2
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
500 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
501 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
503 ok(broken(dst_len
== sizeof(dst
)) || dst_len
== 0x1234 /* W2K+ */, "got %ld\n", dst_len
);
504 ok(dst
== 0x1234, "got %08x\n", dst
);
506 dst_len
= dst
= 0x1234;
507 *(DWORD
*)src
= 0xabcd1234;
508 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
510 ok(hr
== DB_E_DATAOVERFLOW
, "got %08x\n", hr
);
511 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
512 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
513 ok(dst
== 0x1234, "got %08x\n", dst
);
515 dst_len
= dst
= 0x1234;
516 *(DWORD
*)src
= 0x1234abcd;
517 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
519 ok(hr
== DB_E_DATAOVERFLOW
, "got %08x\n", hr
);
520 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
521 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
522 ok(dst
== 0x1234, "got %08x\n", dst
);
524 dst_len
= dst
= 0x1234;
525 *(DWORD
*)src
= 0x4321;
526 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
527 ok(hr
== S_OK
, "got %08x\n", hr
);
528 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
529 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
530 ok(dst
== 0x4321, "got %08x\n", dst
);
532 dst_len
= dst
= 0x1234;
533 ((LARGE_INTEGER
*)src
)->QuadPart
= 0x1234abcd;
534 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
535 ok(hr
== DB_E_ERRORSOCCURRED
||
536 broken(hr
== DB_E_UNSUPPORTEDCONVERSION
), /* win98 */
538 if(hr
!= DB_E_UNSUPPORTEDCONVERSION
) /* win98 doesn't support I8/UI8 */
540 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
541 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
542 ok(dst
== 0x1234, "got %08x\n", dst
);
544 dst_len
= dst
= 0x1234;
545 ((LARGE_INTEGER
*)src
)->QuadPart
= 0x4321;
546 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
547 ok(hr
== S_OK
, "got %08x\n", hr
);
548 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
549 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
550 ok(dst
== 0x4321, "got %08x\n", dst
);
552 dst_len
= dst
= 0x1234;
553 ((ULARGE_INTEGER
*)src
)->QuadPart
= 0x4321;
554 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI8
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
555 ok(hr
== S_OK
, "got %08x\n", hr
);
556 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
557 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
558 ok(dst
== 0x4321, "got %08x\n", dst
);
561 dst_len
= dst
= 0x1234;
562 strcpy((char *)src
, "10");
563 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_I2
, 2, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
564 ok(hr
== S_OK
, "got %08x\n", hr
);
565 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
566 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
567 ok(dst
== 10, "got %08x\n", dst
);
569 dst_len
= dst
= 0x1234;
570 strcpy((char *)src
, "10");
571 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
572 ok(hr
== S_OK
, "got %08x\n", hr
);
573 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
574 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
575 ok(dst
== 10, "got %08x\n", dst
);
577 dst_len
= dst
= 0x1234;
578 memcpy(src
, ten
, sizeof(ten
));
579 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_I2
, 4, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
580 ok(hr
== S_OK
, "got %08x\n", hr
);
581 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
582 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
583 ok(dst
== 10, "got %08x\n", dst
);
585 dst_len
= dst
= 0x1234;
586 memcpy(src
, ten
, sizeof(ten
));
587 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_I2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
588 ok(hr
== S_OK
, "got %08x\n", hr
);
589 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
590 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
591 ok(dst
== 10, "got %08x\n", dst
);
594 dst_len
= dst
= 0x1234;
595 *(WORD
*)src
= 0x4321;
596 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI2
, DBTYPE_UI2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
597 ok(hr
== S_OK
, "got %08x\n", hr
);
598 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
599 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
600 ok(dst
== 0x4321, "got %08x\n", dst
);
602 dst_len
= dst
= 0x1234;
603 *(DWORD
*)src
= 0xabcd1234;
604 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_UI2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
606 ok(hr
== DB_E_DATAOVERFLOW
, "got %08x\n", hr
);
607 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
608 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
609 ok(dst
== 0x1234, "got %08x\n", dst
);
611 dst_len
= dst
= 0x1234;
612 *(DWORD
*)src
= 0x1234abcd;
613 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_UI2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
615 ok(hr
== DB_E_DATAOVERFLOW
, "got %08x\n", hr
);
616 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
617 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
618 ok(dst
== 0x1234, "got %08x\n", dst
);
620 dst_len
= dst
= 0x1234;
621 *(DWORD
*)src
= 0x4321;
622 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_UI2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
623 ok(hr
== S_OK
, "got %08x\n", hr
);
624 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
625 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
626 ok(dst
== 0x4321, "got %08x\n", dst
);
628 dst_len
= dst
= 0x1234;
629 memcpy(src
, ten
, sizeof(ten
));
630 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_UI2
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
631 ok(hr
== S_OK
, "got %08x\n", hr
);
632 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
633 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
634 ok(dst
== 10, "got %08x\n", dst
);
637 static void test_converttoi4(void)
644 static const WCHAR ten
[] = {'1','0',0};
649 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
650 ok(hr
== S_OK
, "got %08x\n", hr
);
651 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
652 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
653 ok(i4
== 0, "got %08x\n", i4
);
657 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
658 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
659 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
660 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
661 ok(i4
== 0x12345678, "got %08x\n", i4
);
664 *(short *)src
= 0x4321;
666 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
667 ok(hr
== S_OK
, "got %08x\n", hr
);
668 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
669 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
670 ok(i4
== 0x4321, "got %08x\n", i4
);
673 *(int *)src
= 0x4321cafe;
675 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
676 ok(hr
== S_OK
, "got %08x\n", hr
);
677 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
678 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
679 ok(i4
== 0x4321cafe, "got %08x\n", i4
);
682 *(FLOAT
*)src
= 10.75;
683 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
684 ok(hr
== S_OK
, "got %08x\n", hr
);
685 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
686 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
687 ok(i4
== 11, "got %08x\n", i4
);
690 *(FLOAT
*)src
= -10.75;
692 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
693 ok(hr
== S_OK
, "got %08x\n", hr
);
694 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
695 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
696 ok(i4
== -11, "got %08x\n", i4
);
699 *(double *)src
= 10.75;
701 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
702 ok(hr
== S_OK
, "got %08x\n", hr
);
703 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
704 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
705 ok(i4
== 11, "got %08x\n", i4
);
708 ((LARGE_INTEGER
*)src
)->QuadPart
= 107500;
710 hr
= IDataConvert_DataConvert(convert
, DBTYPE_CY
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
711 ok(hr
== S_OK
, "got %08x\n", hr
);
712 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
713 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
714 ok(i4
== 11, "got %08x\n", i4
);
717 *(DATE
*)src
= 10.7500;
719 hr
= IDataConvert_DataConvert(convert
, DBTYPE_DATE
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
720 ok(hr
== S_OK
, "got %08x\n", hr
);
721 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
722 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
723 ok(i4
== 11, "got %08x\n", i4
);
726 b
= SysAllocString(ten
);
729 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
730 ok(hr
== S_OK
, "got %08x\n", hr
);
731 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
732 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
733 ok(i4
== 10, "got %08x\n", i4
);
737 *(SCODE
*)src
= 0x4321cafe;
739 hr
= IDataConvert_DataConvert(convert
, DBTYPE_ERROR
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
740 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
741 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
742 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
743 ok(i4
== 0x12345678, "got %08x\n", i4
);
746 *(VARIANT_BOOL
*)src
= VARIANT_TRUE
;
748 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BOOL
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
749 ok(hr
== S_OK
, "got %08x\n", hr
);
750 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
751 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
752 ok(i4
== 0xffffffff, "got %08x\n", i4
);
755 *(VARIANT_BOOL
*)src
= VARIANT_FALSE
;
757 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BOOL
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
758 ok(hr
== S_OK
, "got %08x\n", hr
);
759 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
760 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
761 ok(i4
== 0, "got %08x\n", i4
);
764 V_VT((VARIANT
*)src
) = VT_I2
;
765 V_I2((VARIANT
*)src
) = 0x1234;
767 hr
= IDataConvert_DataConvert(convert
, DBTYPE_VARIANT
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
768 ok(hr
== S_OK
, "got %08x\n", hr
);
769 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
770 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
771 ok(i4
== 0x1234, "got %08x\n", i4
);
774 memset(src
, 0, sizeof(DECIMAL
));
775 ((DECIMAL
*)src
)->u1
.Lo64
= 0x1234;
777 hr
= IDataConvert_DataConvert(convert
, DBTYPE_DECIMAL
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
778 ok(hr
== S_OK
, "got %08x\n", hr
);
779 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
780 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
781 ok(i4
== 0x1234, "got %08x\n", i4
);
784 *(signed char*)src
= 0xab;
786 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I1
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
787 ok(hr
== S_OK
, "got %08x\n", hr
);
788 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
789 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
790 ok(i4
== 0xffffffab, "got %08x\n", i4
);
795 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI1
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
796 ok(hr
== S_OK
, "got %08x\n", hr
);
797 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
798 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
799 ok(i4
== 0xab, "got %08x\n", i4
);
802 *(WORD
*)src
= 0xabcd;
804 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI2
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
805 ok(hr
== S_OK
, "got %08x\n", hr
);
806 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
807 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
808 ok(i4
== 0xabcd, "got %08x\n", i4
);
811 *(DWORD
*)src
= 0xabcd1234;
813 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
814 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
815 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
817 ok(broken(dst_len
== sizeof(i4
)) || dst_len
== 0x1234 /* W2K+ */, "got %ld\n", dst_len
);
818 ok(i4
== 0x12345678, "got %08x\n", i4
);
821 *(DWORD
*)src
= 0x1234abcd;
823 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
824 ok(hr
== S_OK
, "got %08x\n", hr
);
825 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
826 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
827 ok(i4
== 0x1234abcd, "got %08x\n", i4
);
830 ((LARGE_INTEGER
*)src
)->QuadPart
= 0x1234abcd;
832 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
834 broken(hr
== DB_E_UNSUPPORTEDCONVERSION
), /* win98 */
836 if(hr
!= DB_E_UNSUPPORTEDCONVERSION
) /* win98 doesn't support I8/UI8 */
838 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
839 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
840 ok(i4
== 0x1234abcd, "got %08x\n", i4
);
843 ((ULARGE_INTEGER
*)src
)->QuadPart
= 0x1234abcd;
845 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI8
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
846 ok(hr
== S_OK
, "got %08x\n", hr
);
847 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
848 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
849 ok(i4
== 0x1234abcd, "got %08x\n", i4
);
853 strcpy((char *)src
, "10");
855 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_I4
, 2, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
856 ok(hr
== S_OK
, "got %08x\n", hr
);
857 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
858 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
859 ok(i4
== 10, "got %08x\n", i4
);
862 strcpy((char *)src
, "10");
864 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
865 ok(hr
== S_OK
, "got %08x\n", hr
);
866 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
867 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
868 ok(i4
== 10, "got %08x\n", i4
);
871 memcpy(src
, ten
, sizeof(ten
));
873 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_I4
, 4, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, 0);
874 ok(hr
== S_OK
, "got %08x\n", hr
);
875 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
876 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
877 ok(i4
== 10, "got %08x\n", i4
);
880 memcpy(src
, ten
, sizeof(ten
));
882 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_I4
, 0, &dst_len
, src
, &i4
, sizeof(i4
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
883 ok(hr
== S_OK
, "got %08x\n", hr
);
884 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
885 ok(dst_len
== sizeof(i4
), "got %ld\n", dst_len
);
886 ok(i4
== 10, "got %08x\n", i4
);
889 static void test_converttoi8(void)
896 static const WCHAR ten
[] = {'1','0',0};
900 ((ULARGE_INTEGER
*)src
)->QuadPart
= 1234;
902 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_I8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
903 ok(hr
== S_OK
, "got %08x\n", hr
);
904 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
905 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
906 ok(dst
.QuadPart
== 1234, "got %d\n", (int)dst
.QuadPart
);
909 ((ULARGE_INTEGER
*)src
)->QuadPart
= 1234;
910 b
= SysAllocString(ten
);
912 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_I8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
913 ok(hr
== S_OK
, "got %08x\n", hr
);
914 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
915 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
916 ok(dst
.QuadPart
== 10, "got %d\n", (int)dst
.QuadPart
);
920 static void test_converttobstr(void)
927 static const WCHAR ten
[] = {'1','0',0};
932 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_BSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
933 ok(hr
== S_OK
, "got %08x\n", hr
);
934 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
935 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
936 ok(dst
!= NULL
, "got %p\n", dst
);
937 ok(SysStringLen(dst
) == 0, "got %d\n", SysStringLen(dst
));
941 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_BSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
942 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
943 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
944 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
945 ok(dst
== (void*)0x1234, "got %p\n", dst
);
947 *(short *)src
= 4321;
948 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_BSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
949 ok(hr
== S_OK
, "got %08x\n", hr
);
950 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
951 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
952 ok(dst
!= NULL
, "got %p\n", dst
);
953 ok(SysStringLen(dst
) == 4, "got %d\n", SysStringLen(dst
));
956 b
= SysAllocString(ten
);
958 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_BSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
959 ok(hr
== S_OK
, "got %08x\n", hr
);
960 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
961 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
962 ok(dst
!= NULL
, "got %p\n", dst
);
963 ok(dst
!= b
, "got %p src %p\n", dst
, b
);
964 ok(!lstrcmpW(b
, dst
), "got %s\n", wine_dbgstr_w(dst
));
968 b
= SysAllocString(ten
);
971 hr
= IDataConvert_DataConvert(convert
, DBTYPE_VARIANT
, DBTYPE_BSTR
, 0, &dst_len
, &v
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
972 ok(hr
== S_OK
, "got %08x\n", hr
);
973 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
974 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
975 ok(dst
!= NULL
, "got %p\n", dst
);
976 ok(dst
!= b
, "got %p src %p\n", dst
, b
);
977 ok(!lstrcmpW(b
, dst
), "got %s\n", wine_dbgstr_w(dst
));
982 static void test_converttowstr(void)
989 static const WCHAR ten
[] = {'1','0',0};
990 static const WCHAR fourthreetwoone
[] = {'4','3','2','1',0};
991 static const WCHAR guid_str
[] = {
992 '{','0','C','7','3','3','A','8','D','-','2','A','1','C','-','1','1','C','E','-',
993 'A','D','E','5','-','0','0','A','A','0','0','4','4','7','7','3','D','}',0};
994 static const WCHAR hexunpacked_w
[] = {'5','7','0','0','6','9','0','0','6','E','0','0','6','5','0','0','0','0','0','0', 0 };
995 static const WCHAR hexpacked_w
[] = {'W','i','n','e', 0 };
998 memset(dst
, 0xcc, sizeof(dst
));
1000 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1001 ok(hr
== S_OK
, "got %08x\n", hr
);
1002 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1003 ok(dst_len
== 0, "got %ld\n", dst_len
);
1004 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1005 ok(dst
[1] == 0xcccc, "got %02x\n", dst
[1]);
1007 memset(dst
, 0xcc, sizeof(dst
));
1009 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1010 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
1011 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
1012 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
1013 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1015 *(short *)src
= 4321;
1017 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1018 ok(hr
== S_OK
, "got %08x\n", hr
);
1019 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1020 ok(dst_len
== 8, "got %ld\n", dst_len
);
1021 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1023 *(short *)src
= 4321;
1024 memset(dst
, 0xcc, sizeof(dst
));
1026 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1027 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1028 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1029 ok(dst_len
== 8, "got %ld\n", dst_len
);
1030 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1032 *(short *)src
= 4321;
1033 memset(dst
, 0xcc, sizeof(dst
));
1035 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_WSTR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1036 ok(hr
== S_OK
, "got %08x\n", hr
);
1037 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1038 ok(dst_len
== 8, "got %ld\n", dst_len
);
1039 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1041 *(short *)src
= 4321;
1042 memset(dst
, 0xcc, sizeof(dst
));
1044 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1045 ok(hr
== S_OK
, "got %08x\n", hr
);
1046 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1047 ok(dst_len
== 8, "got %ld\n", dst_len
);
1048 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1049 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1050 ok(dst
[2] == 0xcccc, "got %02x\n", dst
[2]);
1052 *(short *)src
= 4321;
1053 memset(dst
, 0xcc, sizeof(dst
));
1055 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1056 ok(hr
== S_OK
, "got %08x\n", hr
);
1057 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1058 ok(dst_len
== 8, "got %ld\n", dst_len
);
1059 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1060 ok(dst
[1] == 0xcccc, "got %02x\n", dst
[1]);
1062 *(short *)src
= 4321;
1063 memset(dst
, 0xcc, sizeof(dst
));
1065 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 8, 0, &dst_status
, 0, 0, 0);
1066 ok(hr
== S_OK
, "got %08x\n", hr
);
1067 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1068 ok(dst_len
== 8, "got %ld\n", dst_len
);
1069 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1070 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1071 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1072 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1073 ok(dst
[4] == 0xcccc, "got %02x\n", dst
[4]);
1079 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1080 ok(hr
== S_OK
, "got %08x\n", hr
);
1081 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1082 ok(dst_len
== 8, "got %ld\n", dst_len
);
1083 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1086 memset(dst
, 0xcc, sizeof(dst
));
1088 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1089 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1090 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1091 ok(dst_len
== 8, "got %ld\n", dst_len
);
1092 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1095 memset(dst
, 0xcc, sizeof(dst
));
1096 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_WSTR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1097 ok(hr
== S_OK
, "got %08x\n", hr
);
1098 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1099 ok(dst_len
== 8, "got %ld\n", dst_len
);
1100 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1103 memset(dst
, 0xcc, sizeof(dst
));
1105 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1106 ok(hr
== S_OK
, "got %08x\n", hr
);
1107 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1108 ok(dst_len
== 8, "got %ld\n", dst_len
);
1109 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1110 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1111 ok(dst
[2] == 0xcccc, "got %02x\n", dst
[2]);
1114 memset(dst
, 0xcc, sizeof(dst
));
1116 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1117 ok(hr
== S_OK
, "got %08x\n", hr
);
1118 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1119 ok(dst_len
== 8, "got %ld\n", dst_len
);
1120 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1121 ok(dst
[1] == 0xcccc, "got %02x\n", dst
[1]);
1124 memset(dst
, 0xcc, sizeof(dst
));
1126 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 8, 0, &dst_status
, 0, 0, 0);
1127 ok(hr
== S_OK
, "got %08x\n", hr
);
1128 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1129 ok(dst_len
== 8, "got %ld\n", dst_len
);
1130 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1131 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1132 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1133 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1134 ok(dst
[4] == 0xcccc, "got %02x\n", dst
[4]);
1138 *(float *)src
= 4321;
1140 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1141 ok(hr
== S_OK
, "got %08x\n", hr
);
1142 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1143 ok(dst_len
== 8, "got %ld\n", dst_len
);
1144 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1146 *(float *)src
= 4321;
1147 memset(dst
, 0xcc, sizeof(dst
));
1149 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1150 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1151 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1152 ok(dst_len
== 8, "got %ld\n", dst_len
);
1153 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1155 *(float *)src
= 4321;
1156 memset(dst
, 0xcc, sizeof(dst
));
1157 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_WSTR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1158 ok(hr
== S_OK
, "got %08x\n", hr
);
1159 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1160 ok(dst_len
== 8, "got %ld\n", dst_len
);
1161 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1163 *(float *)src
= 4321;
1164 memset(dst
, 0xcc, sizeof(dst
));
1166 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1167 ok(hr
== S_OK
, "got %08x\n", hr
);
1168 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1169 ok(dst_len
== 8, "got %ld\n", dst_len
);
1170 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1171 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1172 ok(dst
[2] == 0xcccc, "got %02x\n", dst
[2]);
1174 *(float *)src
= 4321;
1175 memset(dst
, 0xcc, sizeof(dst
));
1177 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1178 ok(hr
== S_OK
, "got %08x\n", hr
);
1179 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1180 ok(dst_len
== 8, "got %ld\n", dst_len
);
1181 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1182 ok(dst
[1] == 0xcccc, "got %02x\n", dst
[1]);
1184 *(float *)src
= 4321;
1185 memset(dst
, 0xcc, sizeof(dst
));
1187 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 8, 0, &dst_status
, 0, 0, 0);
1188 ok(hr
== S_OK
, "got %08x\n", hr
);
1189 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1190 ok(dst_len
== 8, "got %ld\n", dst_len
);
1191 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1192 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1193 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1194 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1195 ok(dst
[4] == 0xcccc, "got %02x\n", dst
[4]);
1199 *(double *)src
= 4321;
1201 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1202 ok(hr
== S_OK
, "got %08x\n", hr
);
1203 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1204 ok(dst_len
== 8, "got %ld\n", dst_len
);
1205 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1207 *(double *)src
= 4321;
1208 memset(dst
, 0xcc, sizeof(dst
));
1209 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1210 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1211 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1212 ok(dst_len
== 8, "got %ld\n", dst_len
);
1213 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1215 *(double *)src
= 4321;
1216 memset(dst
, 0xcc, sizeof(dst
));
1218 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_WSTR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1219 ok(hr
== S_OK
, "got %08x\n", hr
);
1220 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1221 ok(dst_len
== 8, "got %ld\n", dst_len
);
1222 ok(dst
[0] == 0xcccc, "got %02x\n", dst
[0]);
1224 *(double *)src
= 4321;
1225 memset(dst
, 0xcc, sizeof(dst
));
1227 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1228 ok(hr
== S_OK
, "got %08x\n", hr
);
1229 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1230 ok(dst_len
== 8, "got %ld\n", dst_len
);
1231 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1232 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1233 ok(dst
[2] == 0xcccc, "got %02x\n", dst
[2]);
1235 *(double *)src
= 4321;
1236 memset(dst
, 0xcc, sizeof(dst
));
1238 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1239 ok(hr
== S_OK
, "got %08x\n", hr
);
1240 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1241 ok(dst_len
== 8, "got %ld\n", dst_len
);
1242 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1243 ok(dst
[1] == 0xcccc, "got %02x\n", dst
[1]);
1245 *(double *)src
= 4321;
1246 memset(dst
, 0xcc, sizeof(dst
));
1248 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, 8, 0, &dst_status
, 0, 0, 0);
1249 ok(hr
== S_OK
, "got %08x\n", hr
);
1250 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1251 ok(dst_len
== 8, "got %ld\n", dst_len
);
1252 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1253 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1254 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1255 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1256 ok(dst
[4] == 0xcccc, "got %02x\n", dst
[4]);
1260 memset(src
, 0, sizeof(src
));
1261 ((CY
*)src
)->int64
= 43210000;
1262 memset(dst
, 0xcc, sizeof(dst
));
1264 hr
= IDataConvert_DataConvert(convert
, DBTYPE_CY
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1265 ok(hr
== S_OK
, "got %08x\n", hr
);
1266 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1267 ok(dst_len
== 8, "got %ld\n", dst_len
);
1268 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1272 memset(src
, 0, sizeof(src
));
1273 *(signed char *)src
= 10;
1275 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I1
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1276 ok(hr
== S_OK
, "got %08x\n", hr
);
1277 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1278 ok(dst_len
== 4, "got %ld\n", dst_len
);
1279 ok(!lstrcmpW(dst
, ten
), "got %s\n", wine_dbgstr_w(dst
));
1281 memset(src
, 0, sizeof(src
));
1282 *(unsigned char *)src
= 10;
1284 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI1
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1285 ok(hr
== S_OK
, "got %08x\n", hr
);
1286 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1287 ok(dst_len
== 4, "got %ld\n", dst_len
);
1288 ok(!lstrcmpW(dst
, ten
), "got %s\n", wine_dbgstr_w(dst
));
1290 memset(src
, 0, sizeof(src
));
1291 *(unsigned short *)src
= 4321;
1293 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI2
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1294 ok(hr
== S_OK
, "got %08x\n", hr
);
1295 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1296 ok(dst_len
== 8, "got %ld\n", dst_len
);
1297 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1299 memset(src
, 0, sizeof(src
));
1300 *(unsigned int *)src
= 4321;
1302 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1303 ok(hr
== S_OK
, "got %08x\n", hr
);
1304 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1305 ok(dst_len
== 8, "got %ld\n", dst_len
);
1306 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1308 memset(src
, 0, sizeof(src
));
1309 ((LARGE_INTEGER
*)src
)->QuadPart
= 4321;
1311 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1312 ok(broken(DB_E_UNSUPPORTEDCONVERSION
) || hr
== S_OK
/* W2K+ */, "got %08x\n", hr
);
1313 ok(broken(dst_status
== DBSTATUS_E_BADACCESSOR
) || dst_status
== DBSTATUS_S_OK
/* W2K+ */, "got %08x\n", dst_status
);
1314 ok(broken(dst_len
== 0x1234) || dst_len
== 8 /* W2K+ */, "got %ld\n", dst_len
);
1315 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1317 memset(src
, 0, sizeof(src
));
1318 ((ULARGE_INTEGER
*)src
)->QuadPart
= 4321;
1319 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI8
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1320 ok(broken(DB_E_UNSUPPORTEDCONVERSION
) || hr
== S_OK
/* W2K+ */, "got %08x\n", hr
);
1321 ok(broken(dst_status
== DBSTATUS_E_BADACCESSOR
) || dst_status
== DBSTATUS_S_OK
/* W2K+ */, "got %08x\n", dst_status
);
1322 ok(broken(dst_len
== 0x1234) || dst_len
== 8 /* W2K+ */, "got %ld\n", dst_len
);
1323 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1327 memset(src
, 0, sizeof(src
));
1328 memcpy(src
, &IID_IDataConvert
, sizeof(GUID
));
1329 memset(dst
, 0xcc, sizeof(dst
));
1331 hr
= IDataConvert_DataConvert(convert
, DBTYPE_GUID
, DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1332 ok(hr
== S_OK
, "got %08x\n", hr
);
1333 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1334 ok(dst_len
== 76, "got %ld\n", dst_len
);
1335 ok(!lstrcmpW(dst
, guid_str
), "got %s\n", wine_dbgstr_w(dst
));
1339 b
= SysAllocString(ten
);
1342 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1343 ok(hr
== S_OK
, "got %08x\n", hr
);
1344 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1345 ok(dst_len
== 4, "got %ld\n", dst_len
);
1346 ok(!lstrcmpW(b
, dst
), "got %s\n", wine_dbgstr_w(dst
));
1349 memcpy(src
, ten
, sizeof(ten
));
1351 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_WSTR
, 2, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1352 ok(hr
== S_OK
, "got %08x\n", hr
);
1353 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1354 ok(dst_len
== 2, "got %ld\n", dst_len
);
1355 ok(dst
[0] == '1', "got %02x\n", dst
[0]);
1356 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1358 memcpy(src
, ten
, sizeof(ten
));
1360 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_WSTR
, 4, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1361 ok(hr
== S_OK
, "got %08x\n", hr
);
1362 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1363 ok(dst_len
== 4, "got %ld\n", dst_len
);
1364 ok(!lstrcmpW(ten
, dst
), "got %s\n", wine_dbgstr_w(dst
));
1366 memcpy(src
, ten
, sizeof(ten
));
1368 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
1369 ok(hr
== S_OK
, "got %08x\n", hr
);
1370 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1371 ok(dst_len
== 4, "got %ld\n", dst_len
);
1372 ok(!lstrcmpW(ten
, dst
), "got %s\n", wine_dbgstr_w(dst
));
1376 /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1377 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1378 memset(dst
, 0xcc, sizeof(dst
));
1380 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, sizeof(hexpacked_w
), &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1381 ok(hr
== S_OK
, "got %08x\n", hr
);
1382 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1383 ok(dst_len
== sizeof(hexpacked_w
) * 4, "got %ld\n", dst_len
);
1384 ok(!lstrcmpW(hexunpacked_w
, dst
), "got %s\n", wine_dbgstr_w(dst
));
1385 ok(dst
[sizeof(hexpacked_w
)/sizeof(WCHAR
) * 4 + 1] == 0xcccc, "clobbered buffer\n");
1387 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1388 memset(dst
, 0xcc, sizeof(dst
));
1390 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1391 ok(hr
== S_OK
, "got %08x\n", hr
);
1392 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1393 ok(dst_len
== 0, "got %ld\n", dst_len
);
1394 ok(dst
[0] == 0, "not null terminated\n");
1395 ok(dst
[1] == 0xcccc, "clobbered buffer\n");
1397 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1398 memset(dst
, 0xcc, sizeof(dst
));
1400 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, 4, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1401 ok(hr
== S_OK
, "got %08x\n", hr
);
1402 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1403 ok(dst_len
== 2 * sizeof(WCHAR
) * 4, "got %ld\n", dst_len
);
1404 ok(!memcmp(hexunpacked_w
, dst
, 2 * sizeof(WCHAR
) * 4 ), "got %s\n", wine_dbgstr_w(dst
));
1405 ok(dst
[2 * 4] == 0, "not null terminated\n");
1406 ok(dst
[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1408 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1409 memset(dst
, 0xcc, sizeof(dst
));
1411 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, sizeof(hexpacked_w
), &dst_len
, src
, dst
, 2 * sizeof(WCHAR
) * 4 + sizeof(WCHAR
), 0, &dst_status
, 0, 0, 0);
1412 ok(hr
== S_OK
, "got %08x\n", hr
);
1413 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1414 ok(dst_len
== sizeof(hexpacked_w
) * 4, "got %ld\n", dst_len
);
1415 ok(!memcmp(hexunpacked_w
, dst
, 2 * sizeof(WCHAR
) * 4 ), "got %s\n", wine_dbgstr_w(dst
));
1416 ok(dst
[2 * 4] == 0, "not null terminated\n");
1417 ok(dst
[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1419 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1420 memset(dst
, 0xcc, sizeof(dst
));
1422 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, sizeof(hexpacked_w
), &dst_len
, src
, dst
, 2 * sizeof(WCHAR
) * 4 +1, 0, &dst_status
, 0, 0, 0);
1423 ok(hr
== S_OK
, "got %08x\n", hr
);
1424 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1425 ok(dst_len
== sizeof(hexpacked_w
) * 4, "got %ld\n", dst_len
);
1426 ok(!memcmp(hexunpacked_w
, dst
, 2 * sizeof(WCHAR
) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst
));
1427 ok(dst
[2 * 4 - 1] == 0, "not null terminated\n");
1428 ok(dst
[2 * 4] == 0xcccc, "clobbered buffer\n");
1430 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1431 memset(dst
, 0xcc, sizeof(dst
));
1433 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, sizeof(hexpacked_w
), &dst_len
, src
, dst
, 2 * sizeof(WCHAR
) * 4, 0, &dst_status
, 0, 0, 0);
1434 ok(hr
== S_OK
, "got %08x\n", hr
);
1435 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1436 ok(dst_len
== sizeof(hexpacked_w
) * 4, "got %ld\n", dst_len
);
1437 ok(!memcmp(hexunpacked_w
, dst
, 2 * sizeof(WCHAR
) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst
));
1438 ok(dst
[2 * 4 - 1] == 0, "not null terminated\n");
1439 ok(dst
[2 * 4] == 0xcccc, "clobbered buffer\n");
1441 memcpy(src
, hexpacked_w
, sizeof(hexpacked_w
));
1442 memset(dst
, 0xcc, sizeof(dst
));
1444 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_WSTR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
1445 ok(hr
== S_OK
, "got %08x\n", hr
);
1446 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1447 ok(dst_len
== 0, "got %ld\n", dst_len
);
1448 ok(dst
[0] == 0, "not null terminated\n");
1449 ok(dst
[1] == 0xcccc, "clobbered buffer\n");
1452 static void test_converttostr(void)
1457 DBSTATUS dst_status
;
1459 static const WCHAR ten
[] = {'1','0',0};
1460 static const char ten_a
[] = "10";
1461 static const char fourthreetwoone
[] = "4321";
1462 static const char guid_str
[] = "{0C733A8D-2A1C-11CE-ADE5-00AA0044773D}";
1463 static const char hexunpacked_a
[] = "57696E6500";
1464 static const char hexpacked_a
[] = "Wine";
1467 memset(dst
, 0xcc, sizeof(dst
));
1469 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1470 ok(hr
== S_OK
, "got %08x\n", hr
);
1471 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1472 ok(dst_len
== 0, "got %ld\n", dst_len
);
1473 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1474 ok(dst
[1] == (char)0xcc, "got %02x\n", dst
[1]);
1476 memset(dst
, 0xcc, sizeof(dst
));
1478 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1479 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
1480 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
1481 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
1482 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1484 *(short *)src
= 4321;
1486 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1487 ok(hr
== S_OK
, "got %08x\n", hr
);
1488 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1489 ok(dst_len
== 4, "got %ld\n", dst_len
);
1490 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1492 *(short *)src
= 4321;
1493 memset(dst
, 0xcc, sizeof(dst
));
1495 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1496 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1497 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1498 ok(dst_len
== 4, "got %ld\n", dst_len
);
1499 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1501 *(short *)src
= 4321;
1502 memset(dst
, 0xcc, sizeof(dst
));
1504 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_STR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1505 ok(hr
== S_OK
, "got %08x\n", hr
);
1506 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1507 ok(dst_len
== 4, "got %ld\n", dst_len
);
1508 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1510 *(short *)src
= 4321;
1511 memset(dst
, 0xcc, sizeof(dst
));
1513 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1514 ok(hr
== S_OK
, "got %08x\n", hr
);
1515 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1516 ok(dst_len
== 4, "got %ld\n", dst_len
);
1517 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1518 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1519 ok(dst
[2] == (char)0xcc, "got %02x\n", dst
[2]);
1521 *(short *)src
= 4321;
1522 memset(dst
, 0xcc, sizeof(dst
));
1524 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 1, 0, &dst_status
, 0, 0, 0);
1525 ok(hr
== S_OK
, "got %08x\n", hr
);
1526 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1527 ok(dst_len
== 4, "got %ld\n", dst_len
);
1528 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1529 ok(dst
[1] == (char)0xcc, "got %02x\n", dst
[1]);
1531 *(short *)src
= 4321;
1532 memset(dst
, 0xcc, sizeof(dst
));
1534 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1535 ok(hr
== S_OK
, "got %08x\n", hr
);
1536 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1537 ok(dst_len
== 4, "got %ld\n", dst_len
);
1538 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1539 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1540 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1541 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1542 ok(dst
[4] == (char)0xcc, "got %02x\n", dst
[4]);
1547 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1548 ok(hr
== S_OK
, "got %08x\n", hr
);
1549 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1550 ok(dst_len
== 4, "got %ld\n", dst_len
);
1551 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1554 memset(dst
, 0xcc, sizeof(dst
));
1556 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1557 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1558 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1559 ok(dst_len
== 4, "got %ld\n", dst_len
);
1560 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1563 memset(dst
, 0xcc, sizeof(dst
));
1565 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_STR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1566 ok(hr
== S_OK
, "got %08x\n", hr
);
1567 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1568 ok(dst_len
== 4, "got %ld\n", dst_len
);
1569 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1572 memset(dst
, 0xcc, sizeof(dst
));
1574 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1575 ok(hr
== S_OK
, "got %08x\n", hr
);
1576 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1577 ok(dst_len
== 4, "got %ld\n", dst_len
);
1578 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1579 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1580 ok(dst
[2] == (char)0xcc, "got %02x\n", dst
[2]);
1583 memset(dst
, 0xcc, sizeof(dst
));
1585 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 1, 0, &dst_status
, 0, 0, 0);
1586 ok(hr
== S_OK
, "got %08x\n", hr
);
1587 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1588 ok(dst_len
== 4, "got %ld\n", dst_len
);
1589 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1590 ok(dst
[1] == (char)0xcc, "got %02x\n", dst
[1]);
1593 memset(dst
, 0xcc, sizeof(dst
));
1595 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1596 ok(hr
== S_OK
, "got %08x\n", hr
);
1597 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1598 ok(dst_len
== 4, "got %ld\n", dst_len
);
1599 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1600 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1601 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1602 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1603 ok(dst
[4] == (char)0xcc, "got %02x\n", dst
[4]);
1606 *(float *)src
= 4321;
1608 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1609 ok(hr
== S_OK
, "got %08x\n", hr
);
1610 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1611 ok(dst_len
== 4, "got %ld\n", dst_len
);
1612 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1614 *(float *)src
= 4321;
1615 memset(dst
, 0xcc, sizeof(dst
));
1617 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1618 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1619 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1620 ok(dst_len
== 4, "got %ld\n", dst_len
);
1621 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1623 *(float *)src
= 4321;
1624 memset(dst
, 0xcc, sizeof(dst
));
1626 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_STR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1627 ok(hr
== S_OK
, "got %08x\n", hr
);
1628 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1629 ok(dst_len
== 4, "got %ld\n", dst_len
);
1630 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1632 *(float *)src
= 4321;
1633 memset(dst
, 0xcc, sizeof(dst
));
1635 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1636 ok(hr
== S_OK
, "got %08x\n", hr
);
1637 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1638 ok(dst_len
== 4, "got %ld\n", dst_len
);
1639 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1640 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1641 ok(dst
[2] == (char)0xcc, "got %02x\n", dst
[2]);
1643 *(float *)src
= 4321;
1644 memset(dst
, 0xcc, sizeof(dst
));
1646 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 1, 0, &dst_status
, 0, 0, 0);
1647 ok(hr
== S_OK
, "got %08x\n", hr
);
1648 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1649 ok(dst_len
== 4, "got %ld\n", dst_len
);
1650 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1651 ok(dst
[1] == (char)0xcc, "got %02x\n", dst
[1]);
1653 *(float *)src
= 4321;
1654 memset(dst
, 0xcc, sizeof(dst
));
1656 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1657 ok(hr
== S_OK
, "got %08x\n", hr
);
1658 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1659 ok(dst_len
== 4, "got %ld\n", dst_len
);
1660 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1661 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1662 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1663 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1664 ok(dst
[4] == (char)0xcc, "got %02x\n", dst
[4]);
1667 *(double *)src
= 4321;
1669 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1670 ok(hr
== S_OK
, "got %08x\n", hr
);
1671 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1672 ok(dst_len
== 4, "got %ld\n", dst_len
);
1673 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1675 *(double *)src
= 4321;
1676 memset(dst
, 0xcc, sizeof(dst
));
1678 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 0, 0, &dst_status
, 0, 0, 0);
1679 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
1680 ok(dst_status
== DBSTATUS_E_DATAOVERFLOW
, "got %08x\n", dst_status
);
1681 ok(dst_len
== 4, "got %ld\n", dst_len
);
1682 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1684 *(double *)src
= 4321;
1685 memset(dst
, 0xcc, sizeof(dst
));
1687 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_STR
, 0, &dst_len
, src
, NULL
, 0, 0, &dst_status
, 0, 0, 0);
1688 ok(hr
== S_OK
, "got %08x\n", hr
);
1689 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1690 ok(dst_len
== 4, "got %ld\n", dst_len
);
1691 ok(dst
[0] == (char)0xcc, "got %02x\n", dst
[0]);
1693 *(double *)src
= 4321;
1694 memset(dst
, 0xcc, sizeof(dst
));
1696 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 2, 0, &dst_status
, 0, 0, 0);
1697 ok(hr
== S_OK
, "got %08x\n", hr
);
1698 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1699 ok(dst_len
== 4, "got %ld\n", dst_len
);
1700 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1701 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1702 ok(dst
[2] == (char)0xcc, "got %02x\n", dst
[2]);
1704 *(double *)src
= 4321;
1705 memset(dst
, 0xcc, sizeof(dst
));
1707 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 1, 0, &dst_status
, 0, 0, 0);
1708 ok(hr
== S_OK
, "got %08x\n", hr
);
1709 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1710 ok(dst_len
== 4, "got %ld\n", dst_len
);
1711 ok(dst
[0] == 0, "got %02x\n", dst
[0]);
1712 ok(dst
[1] == (char)0xcc, "got %02x\n", dst
[1]);
1714 *(double *)src
= 4321;
1715 memset(dst
, 0xcc, sizeof(dst
));
1717 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, 4, 0, &dst_status
, 0, 0, 0);
1718 ok(hr
== S_OK
, "got %08x\n", hr
);
1719 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1720 ok(dst_len
== 4, "got %ld\n", dst_len
);
1721 ok(dst
[0] == '4', "got %02x\n", dst
[0]);
1722 ok(dst
[1] == '3', "got %02x\n", dst
[1]);
1723 ok(dst
[2] == '2', "got %02x\n", dst
[2]);
1724 ok(dst
[3] == 0, "got %02x\n", dst
[3]);
1725 ok(dst
[4] == (char)0xcc, "got %02x\n", dst
[4]);
1729 memset(src
, 0, sizeof(src
));
1730 ((CY
*)src
)->int64
= 43210000;
1731 memset(dst
, 0xcc, sizeof(dst
));
1733 hr
= IDataConvert_DataConvert(convert
, DBTYPE_CY
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1734 ok(hr
== S_OK
, "got %08x\n", hr
);
1735 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1736 ok(dst_len
== 4, "got %ld\n", dst_len
);
1737 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1741 memset(src
, 0, sizeof(src
));
1742 *(signed char *)src
= 10;
1744 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I1
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1745 ok(hr
== S_OK
, "got %08x\n", hr
);
1746 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1747 ok(dst_len
== 2, "got %ld\n", dst_len
);
1748 ok(!lstrcmpA(dst
, ten_a
), "got %s\n", dst
);
1750 memset(src
, 0, sizeof(src
));
1751 *(unsigned char *)src
= 10;
1753 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI1
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1754 ok(hr
== S_OK
, "got %08x\n", hr
);
1755 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1756 ok(dst_len
== 2, "got %ld\n", dst_len
);
1757 ok(!lstrcmpA(dst
, ten_a
), "got %s\n", dst
);
1759 memset(src
, 0, sizeof(src
));
1760 *(unsigned short *)src
= 4321;
1762 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI2
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1763 ok(hr
== S_OK
, "got %08x\n", hr
);
1764 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1765 ok(dst_len
== 4, "got %ld\n", dst_len
);
1766 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1768 memset(src
, 0, sizeof(src
));
1769 *(unsigned int *)src
= 4321;
1771 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1772 ok(hr
== S_OK
, "got %08x\n", hr
);
1773 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1774 ok(dst_len
== 4, "got %ld\n", dst_len
);
1775 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1777 memset(src
, 0, sizeof(src
));
1778 ((LARGE_INTEGER
*)src
)->QuadPart
= 4321;
1780 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1781 ok(broken(DB_E_UNSUPPORTEDCONVERSION
) || hr
== S_OK
/* W2K+ */, "got %08x\n", hr
);
1782 ok(broken(dst_status
== DBSTATUS_E_BADACCESSOR
) || dst_status
== DBSTATUS_S_OK
/* W2K+ */, "got %08x\n", dst_status
);
1783 ok(broken(dst_len
== 0x1234) || dst_len
== 4 /* W2K+ */, "got %ld\n", dst_len
);
1784 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1786 memset(src
, 0, sizeof(src
));
1787 ((ULARGE_INTEGER
*)src
)->QuadPart
= 4321;
1789 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI8
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1790 ok(broken(DB_E_UNSUPPORTEDCONVERSION
) || hr
== S_OK
/* W2K+ */, "got %08x\n", hr
);
1791 ok(broken(dst_status
== DBSTATUS_E_BADACCESSOR
) || dst_status
== DBSTATUS_S_OK
/* W2K+ */, "got %08x\n", dst_status
);
1792 ok(broken(dst_len
== 0x1234) || dst_len
== 4 /* W2K+ */, "got %ld\n", dst_len
);
1793 ok(!lstrcmpA(dst
, fourthreetwoone
), "got %s\n", dst
);
1797 memset(src
, 0, sizeof(src
));
1798 memcpy(src
, &IID_IDataConvert
, sizeof(GUID
));
1799 memset(dst
, 0xcc, sizeof(dst
));
1801 hr
= IDataConvert_DataConvert(convert
, DBTYPE_GUID
, DBTYPE_STR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1802 ok(hr
== S_OK
, "got %08x\n", hr
);
1803 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1804 ok(dst_len
== 38, "got %ld\n", dst_len
);
1805 ok(!lstrcmpA(dst
, guid_str
), "got %s\n", dst
);
1809 b
= SysAllocString(ten
);
1811 memset(dst
, 0xcc, sizeof(dst
));
1813 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1814 ok(hr
== S_OK
, "got %08x\n", hr
);
1815 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1816 ok(dst_len
== 2, "got %ld\n", dst_len
);
1817 ok(!lstrcmpA(ten_a
, dst
), "got %s\n", dst
);
1820 memcpy(src
, ten
, sizeof(ten
));
1821 memset(dst
, 0xcc, sizeof(dst
));
1823 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_STR
, 2, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1824 ok(hr
== S_OK
, "got %08x\n", hr
);
1825 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1826 ok(dst_len
== 1, "got %ld\n", dst_len
);
1827 ok(dst
[0] == '1', "got %02x\n", dst
[0]);
1828 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
1830 memcpy(src
, ten
, sizeof(ten
));
1831 memset(dst
, 0xcc, sizeof(dst
));
1833 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_STR
, 4, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1834 ok(hr
== S_OK
, "got %08x\n", hr
);
1835 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1836 ok(dst_len
== 2, "got %ld\n", dst_len
);
1837 ok(!lstrcmpA(ten_a
, dst
), "got %s\n", dst
);
1839 memcpy(src
, ten
, sizeof(ten
));
1840 memset(dst
, 0xcc, sizeof(dst
));
1842 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
1843 ok(hr
== S_OK
, "got %08x\n", hr
);
1844 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1845 ok(dst_len
== 2, "got %ld\n", dst_len
);
1846 ok(!lstrcmpA(ten_a
, dst
), "got %s\n", dst
);
1848 memcpy(src
, ten_a
, sizeof(ten_a
));
1849 memset(dst
, 0xcc, sizeof(dst
));
1851 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_STR
, 2, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1852 ok(hr
== S_OK
, "got %08x\n", hr
);
1853 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1854 ok(dst_len
== 2, "got %ld\n", dst_len
);
1855 ok(dst
[0] == '1', "got %02x\n", dst
[0]);
1856 ok(dst
[1] == '0', "got %02x\n", dst
[1]);
1857 ok(dst
[2] == 0, "got %02x\n", dst
[2]);
1858 ok(dst
[3] == (char)0xcc, "got %02x\n", dst
[3]);
1860 memcpy(src
, ten_a
, sizeof(ten_a
));
1861 memset(dst
, 0xcc, sizeof(dst
));
1863 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_STR
, 4, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1864 ok(hr
== S_OK
, "got %08x\n", hr
);
1865 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1866 ok(dst_len
== 4, "got %ld\n", dst_len
);
1867 ok(!lstrcmpA(ten_a
, dst
), "got %s\n", dst
);
1869 memcpy(src
, ten_a
, sizeof(ten_a
));
1870 memset(dst
, 0xcc, sizeof(dst
));
1872 hr
= IDataConvert_DataConvert(convert
, DBTYPE_STR
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
1873 ok(hr
== S_OK
, "got %08x\n", hr
);
1874 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1875 ok(dst_len
== 2, "got %ld\n", dst_len
);
1876 ok(!lstrcmpA(ten_a
, dst
), "got %s\n", dst
);
1880 /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1881 memcpy(src
, hexpacked_a
, sizeof(hexpacked_a
));
1882 memset(dst
, 0xcc, sizeof(dst
));
1884 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_STR
, sizeof(hexpacked_a
), &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1885 ok(hr
== S_OK
, "got %08x\n", hr
);
1886 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1887 ok(dst_len
== sizeof(hexpacked_a
) * 2, "got %ld\n", dst_len
);
1888 ok(!lstrcmpA(hexunpacked_a
, dst
), "got %s\n", dst
);
1889 ok(dst
[sizeof(hexpacked_a
)/sizeof(char) * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1891 memcpy(src
, hexpacked_a
, sizeof(hexpacked_a
));
1892 memset(dst
, 0xcc, sizeof(dst
));
1894 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1895 ok(hr
== S_OK
, "got %08x\n", hr
);
1896 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1897 ok(dst_len
== 0, "got %ld\n", dst_len
);
1898 ok(dst
[0] == 0, "not null terminated\n");
1899 ok(dst
[1] == (char)0xcc, "clobbered buffer\n");
1901 memcpy(src
, hexpacked_a
, sizeof(hexpacked_a
));
1902 memset(dst
, 0xcc, sizeof(dst
));
1904 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_STR
, 4, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1905 ok(hr
== S_OK
, "got %08x\n", hr
);
1906 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1907 ok(dst_len
== 2 * sizeof(char) * 4, "got %ld\n", dst_len
);
1908 ok(!memcmp(hexunpacked_a
, dst
, 2 * sizeof(char) * 4 ), "got %s\n", dst
);
1909 ok(dst
[2 * 4] == 0, "not null terminated\n");
1910 ok(dst
[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1912 memcpy(src
, hexpacked_a
, sizeof(hexpacked_a
));
1913 memset(dst
, 0xcc, sizeof(dst
));
1915 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_STR
, sizeof(hexpacked_a
), &dst_len
, src
, dst
, 2 * sizeof(char) * 4 + sizeof(char), 0, &dst_status
, 0, 0, 0);
1916 ok(hr
== S_OK
, "got %08x\n", hr
);
1917 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1918 ok(dst_len
== sizeof(hexpacked_a
) * 2, "got %ld\n", dst_len
);
1919 ok(!memcmp(hexunpacked_a
, dst
, 2 * sizeof(char) * 4 ), "got %s\n", dst
);
1920 ok(dst
[2 * 4] == 0, "not null terminated\n");
1921 ok(dst
[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1923 memcpy(src
, hexpacked_a
, sizeof(hexpacked_a
));
1924 memset(dst
, 0xcc, sizeof(dst
));
1926 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_STR
, sizeof(hexpacked_a
), &dst_len
, src
, dst
, 2 * sizeof(char) * 4, 0, &dst_status
, 0, 0, 0);
1927 ok(hr
== S_OK
, "got %08x\n", hr
);
1928 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
1929 ok(dst_len
== sizeof(hexpacked_a
) * 2, "got %ld\n", dst_len
);
1930 ok(!memcmp(hexunpacked_a
, dst
, 2 * sizeof(char) * 4 - 2 ), "got %s\n", dst
);
1931 ok(dst
[2 * 4 - 1] == 0, "not null terminated\n");
1932 ok(dst
[2 * 4] == (char)0xcc, "clobbered buffer\n");
1934 memcpy(src
, hexpacked_a
, sizeof(hexpacked_a
));
1935 memset(dst
, 0xcc, sizeof(dst
));
1937 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_STR
, 0, &dst_len
, src
, dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
1938 ok(hr
== S_OK
, "got %08x\n", hr
);
1939 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1940 ok(dst_len
== 0, "got %ld\n", dst_len
);
1941 ok(dst
[0] == 0, "not null terminated\n");
1942 ok(dst
[1] == (char)0xcc, "clobbered buffer\n");
1945 static void test_converttobyrefwstr(void)
1950 DBSTATUS dst_status
;
1952 static const WCHAR ten
[] = {'1','0',0};
1953 static const WCHAR fourthreetwoone
[] = {'4','3','2','1',0};
1956 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_BYREF
| DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1957 ok(hr
== S_OK
, "got %08x\n", hr
);
1958 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1959 ok(dst_len
== 0, "got %ld\n", dst_len
);
1960 ok(dst
[0] == 0, "got %04x\n", dst
[0]);
1963 dst
= (void*)0x12345678;
1965 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_BYREF
| DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1966 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
1967 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
1968 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
1969 ok(dst
== (void*)0x12345678, "got %p\n", dst
);
1971 *(short *)src
= 4321;
1973 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_BYREF
| DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1974 ok(hr
== S_OK
, "got %08x\n", hr
);
1975 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1976 ok(dst_len
== 8, "got %ld\n", dst_len
);
1977 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1980 *(short *)src
= 4321;
1982 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_BYREF
| DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, 0, 0, &dst_status
, 0, 0, 0);
1983 ok(hr
== S_OK
, "got %08x\n", hr
);
1984 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1985 ok(dst_len
== 8, "got %ld\n", dst_len
);
1986 ok(!lstrcmpW(dst
, fourthreetwoone
), "got %s\n", wine_dbgstr_w(dst
));
1989 b
= SysAllocString(ten
);
1992 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BSTR
, DBTYPE_BYREF
| DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
1993 ok(hr
== S_OK
, "got %08x\n", hr
);
1994 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
1995 ok(dst_len
== 4, "got %ld\n", dst_len
);
1996 ok(!lstrcmpW(b
, dst
), "got %s\n", wine_dbgstr_w(dst
));
2000 memcpy(src
, ten
, sizeof(ten
));
2002 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_BYREF
| DBTYPE_WSTR
, 2, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2003 ok(hr
== S_OK
, "got %08x\n", hr
);
2004 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2005 ok(dst_len
== 2, "got %ld\n", dst_len
);
2006 ok(dst
[0] == '1', "got %02x\n", dst
[0]);
2007 ok(dst
[1] == 0, "got %02x\n", dst
[1]);
2010 memcpy(src
, ten
, sizeof(ten
));
2012 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_BYREF
| DBTYPE_WSTR
, 4, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2013 ok(hr
== S_OK
, "got %08x\n", hr
);
2014 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2015 ok(dst_len
== 4, "got %ld\n", dst_len
);
2016 ok(!lstrcmpW(ten
, dst
), "got %s\n", wine_dbgstr_w(dst
));
2019 memcpy(src
, ten
, sizeof(ten
));
2021 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_BYREF
| DBTYPE_WSTR
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, DBDATACONVERT_LENGTHFROMNTS
);
2022 ok(hr
== S_OK
, "got %08x\n", hr
);
2023 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2024 ok(dst_len
== 4, "got %ld\n", dst_len
);
2025 ok(!lstrcmpW(ten
, dst
), "got %s\n", wine_dbgstr_w(dst
));
2029 static void test_converttoguid(void)
2034 DBSTATUS dst_status
;
2039 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_GUID
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2040 ok(hr
== S_OK
, "got %08x\n", hr
);
2041 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2042 ok(dst_len
== sizeof(GUID
), "got %ld\n", dst_len
);
2043 ok(IsEqualGUID(&dst
, &GUID_NULL
), "didn't get GUID_NULL\n");
2047 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_GUID
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2048 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
2049 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
2050 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2051 ok(IsEqualGUID(&dst
, &IID_IDCInfo
), "dst has changed\n");
2054 memcpy(src
, &IID_IDataConvert
, sizeof(GUID
));
2056 hr
= IDataConvert_DataConvert(convert
, DBTYPE_GUID
, DBTYPE_GUID
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2057 ok(hr
== S_OK
, "got %08x\n", hr
);
2058 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2059 ok(dst_len
== sizeof(GUID
), "got %ld\n", dst_len
);
2060 ok(IsEqualGUID(&dst
, &IID_IDataConvert
), "didn't get IID_IDataConvert\n");
2063 static void test_converttofiletime(void)
2068 DBSTATUS dst_status
;
2071 memset(&dst
, 0xcc, sizeof(dst
));
2072 ((FILETIME
*)src
)->dwLowDateTime
= 0x12345678;
2073 ((FILETIME
*)src
)->dwHighDateTime
= 0x9abcdef0;
2075 hr
= IDataConvert_DataConvert(convert
, DBTYPE_FILETIME
, DBTYPE_FILETIME
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2077 broken(hr
== DB_E_BADBINDINFO
), /* win98 */
2081 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2082 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2083 ok(dst
.dwLowDateTime
== 0x12345678, "got %08x\n", dst
.dwLowDateTime
);
2084 ok(dst
.dwHighDateTime
== 0x9abcdef0, "got %08x\n", dst
.dwHighDateTime
);
2088 static void test_converttoui1(void)
2093 DBSTATUS dst_status
;
2098 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_UI1
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2099 ok(hr
== S_OK
, "got %08x\n", hr
);
2100 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2101 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2102 ok(dst
== 0, "got %08x\n", dst
);
2106 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_UI1
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2107 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
2108 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
2109 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2110 ok(dst
== 0x12, "got %08x\n", dst
);
2115 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI1
, DBTYPE_UI1
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2116 ok(hr
== S_OK
, "got %08x\n", hr
);
2117 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2118 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2119 ok(dst
== 0x43, "got %08x\n", dst
);
2124 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI1
, DBTYPE_UI1
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2125 ok(hr
== S_OK
, "got %08x\n", hr
);
2126 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2127 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2128 ok(dst
== 0xfe, "got %08x\n", dst
);
2131 static void test_converttoui4(void)
2136 DBSTATUS dst_status
;
2141 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_UI4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2142 ok(hr
== S_OK
, "got %08x\n", hr
);
2143 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2144 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2145 ok(dst
== 0, "got %08x\n", dst
);
2149 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_UI4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2150 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
2151 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
2152 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2153 ok(dst
== 0x12345678, "got %08x\n", dst
);
2156 *(DWORD
*)src
= 0x87654321;
2158 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI4
, DBTYPE_UI4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2159 ok(hr
== S_OK
, "got %08x\n", hr
);
2160 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2161 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2162 ok(dst
== 0x87654321, "got %08x\n", dst
);
2165 *(signed short *)src
= 0x4321;
2167 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_UI4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2168 ok(hr
== S_OK
, "got %08x\n", hr
);
2169 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2170 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2171 ok(dst
== 0x4321, "got %08x\n", dst
);
2174 *(signed short *)src
= -1;
2176 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I2
, DBTYPE_UI4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2177 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
2179 ok(dst_status
== DBSTATUS_E_SIGNMISMATCH
, "got %08x\n", dst_status
);
2181 ok(broken(dst_len
== sizeof(dst
)) || dst_len
== 0x1234 /* W2K+ */, "got %ld\n", dst_len
);
2182 ok(dst
== 0x12345678, "got %08x\n", dst
);
2184 dst_len
= dst
= 0x1234;
2185 V_VT((VARIANT
*)src
) = VT_I2
;
2186 V_I2((VARIANT
*)src
) = 0x4321;
2187 hr
= IDataConvert_DataConvert(convert
, DBTYPE_VARIANT
, DBTYPE_UI4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2188 ok(hr
== S_OK
, "got %08x\n", hr
);
2189 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2190 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2191 ok(dst
== 0x4321, "got %08x\n", dst
);
2194 static void test_converttor4(void)
2199 DBSTATUS dst_status
;
2204 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_R4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2205 ok(hr
== S_OK
, "got %08x\n", hr
);
2206 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2207 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2208 ok(dst
== 0.0, "got %f\n", dst
);
2212 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_R4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2213 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
2214 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
2215 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2216 ok(dst
== 1.0, "got %f\n", dst
);
2219 *(signed int*)src
= 12345678;
2221 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_R4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2222 ok(hr
== S_OK
, "got %08x\n", hr
);
2223 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2224 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2225 ok(dst
== 12345678.0, "got %f\n", dst
);
2228 *(FLOAT
*)src
= 10.0;
2230 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R4
, DBTYPE_R4
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2231 ok(hr
== S_OK
, "got %08x\n", hr
);
2232 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2233 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2234 ok(dst
== 10.0, "got %f\n", dst
);
2237 static void test_converttocy(void)
2242 DBSTATUS dst_status
;
2247 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_CY
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2248 ok(hr
== S_OK
, "got %08x\n", hr
);
2249 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2250 ok(dst_len
== sizeof(CY
), "got %ld\n", dst_len
);
2251 ok(dst
.int64
== 0, "didn't get 0\n");
2255 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_CY
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2256 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
2257 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
2258 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2259 ok(dst
.int64
== 0xcc, "dst changed\n");
2264 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_CY
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2265 ok(hr
== S_OK
, "got %08x\n", hr
);
2266 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2267 ok(dst_len
== sizeof(CY
), "got %ld\n", dst_len
);
2268 ok(dst
.int64
== 12340000, "got %d\n", dst
.s
.Lo
);
2271 ((CY
*)src
)->int64
= 1234;
2273 hr
= IDataConvert_DataConvert(convert
, DBTYPE_CY
, DBTYPE_CY
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2274 ok(hr
== S_OK
, "got %08x\n", hr
);
2275 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2276 ok(dst_len
== sizeof(CY
), "got %ld\n", dst_len
);
2277 ok(dst
.int64
== 1234, "got %d\n", dst
.s
.Lo
);
2280 static void test_converttoui8(void)
2285 DBSTATUS dst_status
;
2288 dst
.QuadPart
= 0xcc;
2290 hr
= IDataConvert_DataConvert(convert
, DBTYPE_EMPTY
, DBTYPE_UI8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2291 ok(hr
== S_OK
, "got %08x\n", hr
);
2292 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2293 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2294 ok(dst
.QuadPart
== 0, "got %d\n", (int)dst
.QuadPart
);
2296 dst
.QuadPart
= 0xcc;
2298 hr
= IDataConvert_DataConvert(convert
, DBTYPE_NULL
, DBTYPE_UI8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2299 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got %08x\n", hr
);
2300 ok(dst_status
== DBSTATUS_E_BADACCESSOR
, "got %08x\n", dst_status
);
2301 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2302 ok(dst
.QuadPart
== 0xcc, "dst changed\n");
2304 dst
.QuadPart
= 0xcc;
2307 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_UI8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2308 ok(hr
== S_OK
, "got %08x\n", hr
);
2309 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2310 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2311 ok(dst
.QuadPart
== 1234, "got %d\n", (int)dst
.QuadPart
);
2313 dst
.QuadPart
= 0xcc;
2316 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_UI8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2317 ok(hr
== DB_E_ERRORSOCCURRED
, "got %08x\n", hr
);
2319 ok(dst_status
== DBSTATUS_E_SIGNMISMATCH
, "got %08x\n", dst_status
);
2321 ok(dst_len
== 0x1234, "got %ld\n", dst_len
);
2322 ok(dst
.QuadPart
== 0xcc, "got %d\n", (int)dst
.QuadPart
);
2324 dst
.QuadPart
= 0xcc;
2325 ((ULARGE_INTEGER
*)src
)->QuadPart
= 1234;
2327 hr
= IDataConvert_DataConvert(convert
, DBTYPE_UI8
, DBTYPE_UI8
, 0, &dst_len
, src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2328 ok(hr
== S_OK
, "got %08x\n", hr
);
2329 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2330 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2331 ok(dst
.QuadPart
== 1234, "got %d\n", (int)dst
.QuadPart
);
2334 static void test_getconversionsize(void)
2340 static WCHAR strW
[] = {'t','e','s','t',0};
2341 static char strTest
[] = "test";
2344 /* same way as CanConvert fails here */
2346 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_NULL
, DBTYPE_BSTR
, NULL
, &dst_len
, NULL
);
2347 ok(hr
== DB_E_UNSUPPORTEDCONVERSION
, "got 0x%08x\n", hr
);
2350 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_I2
, DBTYPE_I4
, NULL
, &dst_len
, NULL
);
2351 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2352 ok(dst_len
== 4, "got %ld\n", dst_len
);
2354 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_I2
, DBTYPE_I4
, NULL
, NULL
, NULL
);
2355 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
2357 /* size doesn't include string size */
2358 str
= SysAllocStringLen(NULL
, 10);
2360 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_BSTR
, DBTYPE_VARIANT
, NULL
, &dst_len
, str
);
2361 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2362 ok(dst_len
== sizeof(VARIANT
), "%ld\n", dst_len
);
2366 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_WSTR
, DBTYPE_WSTR
, NULL
, &dst_len
, strW
);
2367 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2368 ok(dst_len
== 10, "%ld\n", dst_len
);
2372 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_WSTR
, DBTYPE_WSTR
, &src_len
, &dst_len
, strW
);
2373 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2374 ok(dst_len
== 4, "%ld\n", dst_len
);
2378 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_WSTR
, DBTYPE_WSTR
, &src_len
, &dst_len
, strW
);
2379 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2380 ok(dst_len
== 22, "%ld\n", dst_len
);
2383 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_STR
, DBTYPE_WSTR
, NULL
, &dst_len
, strTest
);
2384 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2385 ok(dst_len
== 10 || broken(dst_len
== 12), "%ld\n", dst_len
);
2389 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_STR
, DBTYPE_WSTR
, &src_len
, &dst_len
, strTest
);
2390 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2391 ok(dst_len
== 6, "%ld\n", dst_len
);
2395 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_STR
, DBTYPE_WSTR
, &src_len
, &dst_len
, strTest
);
2396 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2397 ok(dst_len
== 42, "%ld\n", dst_len
);
2400 V_VT(&var
) = VT_BSTR
;
2401 V_BSTR(&var
) = SysAllocString(strW
);
2402 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_VARIANT
, DBTYPE_WSTR
, NULL
, &dst_len
, &var
);
2403 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2404 ok(dst_len
== 10, "%ld\n", dst_len
);
2409 V_VT(&var
) = VT_BSTR
;
2410 V_BSTR(&var
) = SysAllocString(strW
);
2411 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_VARIANT
, DBTYPE_WSTR
, &src_len
, &dst_len
, &var
);
2412 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2413 ok(dst_len
== 10, "%ld\n", dst_len
);
2420 hr
= IDataConvert_GetConversionSize(convert
, DBTYPE_VARIANT
, DBTYPE_WSTR
, &src_len
, &dst_len
, &var
);
2421 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
2422 todo_wine
ok(dst_len
== 110, "%ld\n", dst_len
);
2427 static void test_converttobytes(void)
2431 BYTE byte_src
[] = {0, 1, 2, 4, 5};
2433 DBSTATUS dst_status
;
2436 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_BYTES
, sizeof(byte_src
), &dst_len
, byte_src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2437 ok(hr
== S_OK
, "got %08x\n", hr
);
2438 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2439 ok(dst_len
== sizeof(byte_src
), "got %ld\n", dst_len
);
2440 ok(!memcmp(byte_src
, dst
, dst_len
), "bytes differ\n");
2443 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_BYTES
, sizeof(byte_src
), &dst_len
, byte_src
, &dst
, 2, 0, &dst_status
, 0, 0, 0);
2444 ok(hr
== S_OK
, "got %08x\n", hr
);
2445 ok(dst_status
== DBSTATUS_S_TRUNCATED
, "got %08x\n", dst_status
);
2446 ok(dst_len
== sizeof(byte_src
), "got %ld\n", dst_len
);
2447 ok(!memcmp(byte_src
, dst
, 2 ), "bytes differ\n");
2450 static void test_converttovar(void)
2452 static WCHAR strW
[] = {'t','e','s','t',0};
2453 BYTE byte_src
[5] = {1, 2, 3, 4, 5};
2454 DBTIMESTAMP ts
= {2013, 5, 14, 2, 4, 12, 0};
2455 double dvalue
= 123.56;
2456 DBSTATUS dst_status
;
2464 VARIANT_BOOL boolean
= VARIANT_TRUE
;
2466 V_VT(&dst
) = VT_EMPTY
;
2468 dst_status
= DBSTATUS_S_DEFAULT
;
2469 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_VARIANT
, sizeof(strW
), &dst_len
, strW
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2470 ok(hr
== S_OK
, "got %08x\n", hr
);
2471 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2472 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2473 ok(V_VT(&dst
) == VT_BSTR
, "got %d\n", V_VT(&dst
));
2474 ok(!lstrcmpW(V_BSTR(&dst
), strW
), "got %s\n", wine_dbgstr_w(V_BSTR(&dst
)));
2477 /* with null dest length and status */
2478 V_VT(&dst
) = VT_EMPTY
;
2479 hr
= IDataConvert_DataConvert(convert
, DBTYPE_WSTR
, DBTYPE_VARIANT
, sizeof(strW
), NULL
, strW
, &dst
, sizeof(dst
), 0, NULL
, 0, 0, 0);
2480 ok(hr
== S_OK
, "got %08x\n", hr
);
2481 ok(V_VT(&dst
) == VT_BSTR
, "got %d\n", V_VT(&dst
));
2482 ok(!lstrcmpW(V_BSTR(&dst
), strW
), "got %s\n", wine_dbgstr_w(V_BSTR(&dst
)));
2485 V_VT(&dst
) = VT_EMPTY
;
2487 dst_status
= DBSTATUS_S_DEFAULT
;
2488 i8
.QuadPart
= 12345;
2490 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I8
, DBTYPE_VARIANT
, sizeof(i8
), &dst_len
, &i8
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2491 ok(hr
== S_OK
, "got %08x\n", hr
);
2492 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2493 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2494 ok(V_VT(&dst
) == VT_DECIMAL
, "got %d\n", V_VT(&dst
));
2495 ok(S(U(V_DECIMAL(&dst
))).scale
== 0 && S(U(V_DECIMAL(&dst
))).sign
== 0 &&
2496 V_DECIMAL(&dst
).Hi32
== 0 && U1(V_DECIMAL(&dst
)).Lo64
== 12345, "Not Equal\n");
2498 V_VT(&dst
) = VT_EMPTY
;
2500 dst_status
= DBSTATUS_S_DEFAULT
;
2501 hr
= IDataConvert_DataConvert(convert
, DBTYPE_R8
, DBTYPE_VARIANT
, sizeof(dvalue
), &dst_len
, &dvalue
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2502 ok(hr
== S_OK
, "got %08x\n", hr
);
2503 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2504 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2505 ok(V_VT(&dst
) == VT_R8
, "got %d\n", V_VT(&dst
));
2506 ok(V_R8(&dst
) == 123.56, "got %f\n", V_R8(&dst
));
2508 V_VT(&dst
) = VT_EMPTY
;
2510 dst_status
= DBSTATUS_S_DEFAULT
;
2511 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BOOL
, DBTYPE_VARIANT
, sizeof(boolean
), &dst_len
, &boolean
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2512 ok(hr
== S_OK
, "got %08x\n", hr
);
2513 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2514 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2515 ok(V_VT(&dst
) == VT_BOOL
, "got %d\n", V_VT(&dst
));
2516 ok(V_BOOL(&dst
) == VARIANT_TRUE
, "got %d\n", V_BOOL(&dst
));
2518 V_VT(&dst
) = VT_EMPTY
;
2520 dst_status
= DBSTATUS_S_DEFAULT
;
2522 hr
= IDataConvert_DataConvert(convert
, DBTYPE_I4
, DBTYPE_VARIANT
, sizeof(i4
), &dst_len
, &i4
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2523 ok(hr
== S_OK
, "got %08x\n", hr
);
2524 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2525 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2526 ok(V_VT(&dst
) == VT_I4
, "got %d\n", V_VT(&dst
));
2527 ok(V_I4(&dst
) == 123, "got %d\n", V_I4(&dst
));
2529 V_VT(&dst
) = VT_EMPTY
;
2531 dst_status
= DBSTATUS_S_DEFAULT
;
2533 hr
= IDataConvert_DataConvert(convert
, DBTYPE_DATE
, DBTYPE_VARIANT
, sizeof(date
), &dst_len
, &date
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2534 ok(hr
== S_OK
, "got %08x\n", hr
);
2535 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2536 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2537 ok(V_VT(&dst
) == VT_DATE
, "got %d\n", V_VT(&dst
));
2538 ok(V_DATE(&dst
) == 123.123, "got %f\n", V_DATE(&dst
));
2540 V_VT(&dst
) = VT_EMPTY
;
2542 dst_status
= DBSTATUS_S_DEFAULT
;
2545 hr
= IDataConvert_DataConvert(convert
, DBTYPE_CY
, DBTYPE_VARIANT
, sizeof(cy
), &dst_len
, &cy
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2546 ok(hr
== S_OK
, "got %08x\n", hr
);
2547 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2548 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2549 ok(V_VT(&dst
) == VT_CY
, "got %d\n", V_VT(&dst
));
2552 ok(S(cy2
).Lo
== S(cy
).Lo
&& S(cy2
).Hi
== S(cy
).Hi
, "got %d,%d\n", S(cy2
).Lo
, S(cy2
).Hi
);
2555 hr
= IDataConvert_DataConvert(convert
, DBTYPE_BYTES
, DBTYPE_VARIANT
, 0, &dst_len
, &byte_src
, &dst
, sizeof(dst
), 0, &dst_status
, 0, 0, 0);
2556 ok(hr
== S_OK
, "got %08x\n", hr
);
2557 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2558 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2559 ok(V_VT(&dst
) == (VT_ARRAY
|VT_UI1
), "got %d\n", V_VT(&dst
));
2563 hr
= IDataConvert_DataConvert(convert
, DBTYPE_DBTIMESTAMP
, DBTYPE_VARIANT
, 0, &dst_len
, &ts
, &dst
, sizeof(ts
), 0, &dst_status
, 0, 0, 0);
2564 ok(hr
== S_OK
, "got %08x\n", hr
);
2565 ok(dst_status
== DBSTATUS_S_OK
, "got %08x\n", dst_status
);
2566 ok(dst_len
== sizeof(dst
), "got %ld\n", dst_len
);
2567 ok(V_VT(&dst
) == VT_DATE
, "got %d\n", V_VT(&dst
));
2568 ok( (float)V_DATE(&dst
) == 41408.086250f
, "got %f\n", V_DATE(&dst
));
2575 OleInitialize(NULL
);
2579 hr
= CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY
, NULL
, CLSCTX_INPROC_SERVER
, &IID_IDataConvert
, (void**)&convert
);
2582 win_skip("Unable to create IDataConvert instance, 0x%08x\n", hr
);
2591 test_converttostr();
2592 test_converttobstr();
2593 test_converttowstr();
2594 test_converttobyrefwstr();
2595 test_converttoguid();
2596 test_converttoui1();
2597 test_converttoui4();
2599 test_converttofiletime();
2601 test_converttoui8();
2602 test_converttovar();
2603 test_converttobytes();
2604 test_getconversionsize();
2606 IDataConvert_Release(convert
);