?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comdlg32: Fix some alignment issues in the Dutch translation.
[wine/hramrach.git] / dlls / oledb32 / tests / convert.c
blob9cece28a8caf161db081064ccbaeb4455eb09b80
1 /* OLE DB Conversion library tests
2 *
3 * Copyright 2009 Huw Davies
4 *
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.
9 *
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.
14 *
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
18 */
19
20 #include <stdarg.h>
21
22 #define COBJMACROS
23 #define NONAMELESSUNION
24 #define NONAMELESSSTRUCT
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "ole2.h"
29 #include "msdadc.h"
30
31 #include "oledberr.h"
32
33 #include "initguid.h"
34 #include "msdaguid.h"
35
36 #include "wine/test.h"
37
38 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
39
40 static void test_dcinfo(void)
41 {
42 IDCInfo *info;
43 HRESULT hr;
44 DCINFOTYPE types[2];
45 DCINFO *inf;
46
47 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDCInfo, (void**)&info);
48 if(FAILED(hr))
49 {
50 win_skip("Unable to load oledb conversion library\n");
51 return;
52 }
53
54 types[0] = DCINFOTYPE_VERSION;
55 hr = IDCInfo_GetInfo(info, 1, types, &inf);
56 ok(hr == S_OK, "got %08x\n", hr);
57
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));
61
62 V_UI4(&inf->vData) = 0x200;
63 hr = IDCInfo_SetInfo(info, 1, inf);
64 ok(hr == S_OK, "got %08x\n", hr);
65 CoTaskMemFree(inf);
66
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));
72
73 V_UI4(&inf->vData) = 0x100;
74 hr = IDCInfo_SetInfo(info, 1, inf);
75 ok(hr == S_OK, "got %08x\n", hr);
76 CoTaskMemFree(inf);
77
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));
83
84 V_UI4(&inf->vData) = 0x500;
85 hr = IDCInfo_SetInfo(info, 1, inf);
86 ok(hr == S_OK, "got %08x\n", hr);
87 CoTaskMemFree(inf);
88
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));
94
95 V_UI4(&inf->vData) = 0xffff;
96 hr = IDCInfo_SetInfo(info, 1, inf);
97 ok(hr == S_OK, "got %08x\n", hr);
98 CoTaskMemFree(inf);
99
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));
105
106 V_UI4(&inf->vData) = 0x12345678;
107 hr = IDCInfo_SetInfo(info, 1, inf);
108 ok(hr == S_OK, "got %08x\n", hr);
109 CoTaskMemFree(inf);
110
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));
116
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);
122 CoTaskMemFree(inf);
123
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));
129 CoTaskMemFree(inf);
130
131 /* More than one type */
132 types[1] = 2;
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));
140
141 hr = IDCInfo_SetInfo(info, 2, inf);
142 ok(hr == S_OK, "got %08x\n", hr);
143 CoTaskMemFree(inf);
144
145
146 IDCInfo_Release(info);
147 }
148
149 struct can_convert
150 {
151 DBTYPE type;
152 DWORD can_convert_to;
153 } simple_convert[] =
154 {
155 {DBTYPE_EMPTY, 0x63bfd9ff},
156 {DBTYPE_NULL, 0x40001002},
157 {DBTYPE_I2, 0x3b9fd9ff},
158 {DBTYPE_I4, 0x3bdfd9ff},
159
160 {DBTYPE_R4, 0x3b9fd9ff},
161 {DBTYPE_R8, 0x3b9fd9ff},
162 {DBTYPE_CY, 0x039fd97f},
163 {DBTYPE_DATE, 0x799f99bf},
164
165 {DBTYPE_BSTR, 0x7bffd9ff},
166 {DBTYPE_IDISPATCH, 0x7bffffff},
167 {DBTYPE_ERROR, 0x01001500},
168 {DBTYPE_BOOL, 0x039fd9ff},
169
170 {DBTYPE_VARIANT, 0x7bffffff},
171 {DBTYPE_IUNKNOWN, 0x00003203},
172 {DBTYPE_DECIMAL, 0x3b9fd97f},
173 {DBTYPE_I1, 0x3b9fd9ff},
174
175 {DBTYPE_UI1, 0x3b9fd9ff},
176 {DBTYPE_UI2, 0x3b9fd9ff},
177 {DBTYPE_UI4, 0x3bdfd9ff},
178 {DBTYPE_I8, 0x43dfd97f},
179
180 {DBTYPE_UI8, 0x43dfd97f},
181 {DBTYPE_GUID, 0x01e01103},
182 {DBTYPE_BYTES, 0x01fc110b},
183 {DBTYPE_STR, 0x7bffd9ff},
184
185 {DBTYPE_WSTR, 0x7bffd9ff},
186 {DBTYPE_NUMERIC, 0x039fd97f},
187 {DBTYPE_UDT, 0x00000000},
188 {DBTYPE_DBDATE, 0x79801183},
189
190 {DBTYPE_DBTIME, 0x79801183},
191 {DBTYPE_DBTIMESTAMP, 0x79801183},
192 {DBTYPE_FILETIME, 0x79981183}
193 };
194
195
196 static inline BOOL array_type(DBTYPE type)
197 {
198 return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
199 }
200
201 static void test_canconvert(void)
202 {
203 IDataConvert *convert;
204 HRESULT hr;
205 int src_idx, dst_idx;
206
207 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
208 if(FAILED(hr))
209 {
210 win_skip("Unable to load oledb conversion library\n");
211 return;
212 }
213
214 /* Some older versions of the library don't support several conversions, we'll skip
215 if we have such a library */
216 hr = IDataConvert_CanConvert(convert, DBTYPE_EMPTY, DBTYPE_DBTIMESTAMP);
217 if(hr == S_FALSE)
218 {
219 win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
220 IDataConvert_Release(convert);
221 return;
222 }
223
224 /* Some older versions of the library don't support several conversions, we'll skip
225 if we have such a library */
226 hr = IDataConvert_CanConvert(convert, DBTYPE_EMPTY, DBTYPE_DBTIMESTAMP);
227 if(hr == S_FALSE)
228 {
229 win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
230 IDataConvert_Release(convert);
231 return;
232 }
233
234 for(src_idx = 0; src_idx < sizeof(simple_convert) / sizeof(simple_convert[0]); src_idx++)
235 for(dst_idx = 0; dst_idx < sizeof(simple_convert) / sizeof(simple_convert[0]); dst_idx++)
236 {
237 BOOL expect, simple_expect;
238 simple_expect = (simple_convert[src_idx].can_convert_to >> dst_idx) & 1;
239
240 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type);
241 expect = simple_expect;
242 ok((hr == S_OK && expect == TRUE) ||
243 (hr == S_FALSE && expect == FALSE),
244 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
245 simple_convert[dst_idx].type, hr, expect ? "" : "not ");
246
247 /* src DBTYPE_BYREF */
248 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_BYREF, simple_convert[dst_idx].type);
249 expect = simple_expect;
250 ok((hr == S_OK && expect == TRUE) ||
251 (hr == S_FALSE && expect == FALSE),
252 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_BYREF,
253 simple_convert[dst_idx].type, hr, expect ? "" : "not ");
254
255 /* dst DBTYPE_BYREF */
256 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_BYREF);
257 expect = FALSE;
258 if(simple_expect &&
259 (simple_convert[dst_idx].type == DBTYPE_BYTES ||
260 simple_convert[dst_idx].type == DBTYPE_STR ||
261 simple_convert[dst_idx].type == DBTYPE_WSTR))
262 expect = TRUE;
263 ok((hr == S_OK && expect == TRUE) ||
264 (hr == S_FALSE && expect == FALSE),
265 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
266 simple_convert[dst_idx].type | DBTYPE_BYREF, hr, expect ? "" : "not ");
267
268 /* src & dst DBTYPE_BYREF */
269 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_BYREF, simple_convert[dst_idx].type | DBTYPE_BYREF);
270 expect = FALSE;
271 if(simple_expect &&
272 (simple_convert[dst_idx].type == DBTYPE_BYTES ||
273 simple_convert[dst_idx].type == DBTYPE_STR ||
274 simple_convert[dst_idx].type == DBTYPE_WSTR))
275 expect = TRUE;
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_BYREF,
279 simple_convert[dst_idx].type | DBTYPE_BYREF, hr, expect ? "" : "not ");
280
281 /* src DBTYPE_ARRAY */
282 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_ARRAY, simple_convert[dst_idx].type);
283 expect = FALSE;
284 if(array_type(simple_convert[src_idx].type) && simple_convert[dst_idx].type == DBTYPE_VARIANT)
285 expect = TRUE;
286 ok((hr == S_OK && expect == TRUE) ||
287 (hr == S_FALSE && expect == FALSE),
288 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_ARRAY,
289 simple_convert[dst_idx].type, hr, expect ? "" : "not ");
290
291 /* dst DBTYPE_ARRAY */
292 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_ARRAY);
293 expect = FALSE;
294 if(array_type(simple_convert[dst_idx].type) &&
295 (simple_convert[src_idx].type == DBTYPE_IDISPATCH ||
296 simple_convert[src_idx].type == DBTYPE_VARIANT))
297 expect = TRUE;
298 ok((hr == S_OK && expect == TRUE) ||
299 (hr == S_FALSE && expect == FALSE),
300 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
301 simple_convert[dst_idx].type | DBTYPE_ARRAY, hr, expect ? "" : "not ");
302
303 /* src & dst DBTYPE_ARRAY */
304 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_ARRAY, simple_convert[dst_idx].type | DBTYPE_ARRAY);
305 expect = FALSE;
306 if(array_type(simple_convert[src_idx].type) &&
307 simple_convert[src_idx].type == simple_convert[dst_idx].type)
308 expect = TRUE;
309 ok((hr == S_OK && expect == TRUE) ||
310 (hr == S_FALSE && expect == FALSE),
311 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_ARRAY,
312 simple_convert[dst_idx].type | DBTYPE_ARRAY, hr, expect ? "" : "not ");
313
314 /* src DBTYPE_VECTOR */
315 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_VECTOR, simple_convert[dst_idx].type);
316 expect = FALSE;
317 ok((hr == S_OK && expect == TRUE) ||
318 (hr == S_FALSE && expect == FALSE),
319 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_VECTOR,
320 simple_convert[dst_idx].type, hr, expect ? "" : "not ");
321
322 /* dst DBTYPE_VECTOR */
323 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_VECTOR);
324 expect = FALSE;
325 ok((hr == S_OK && expect == TRUE) ||
326 (hr == S_FALSE && expect == FALSE),
327 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
328 simple_convert[dst_idx].type | DBTYPE_VECTOR, hr, expect ? "" : "not ");
329
330 /* src & dst DBTYPE_VECTOR */
331 hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_VECTOR, simple_convert[dst_idx].type | DBTYPE_VECTOR);
332 expect = FALSE;
333 ok((hr == S_OK && expect == TRUE) ||
334 (hr == S_FALSE && expect == FALSE),
335 "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_VECTOR,
336 simple_convert[dst_idx].type | DBTYPE_VECTOR, hr, expect ? "" : "not ");
337
338
339 }
340
341 IDataConvert_Release(convert);
342 }
343
344 static void test_converttoi2(void)
345 {
346 IDataConvert *convert;
347 HRESULT hr;
348 signed short dst;
349 BYTE src[20];
350 DBSTATUS dst_status;
351 DBLENGTH dst_len;
352 static const WCHAR ten[] = {'1','0',0};
353 BSTR b;
354
355 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
356 if(FAILED(hr))
357 {
358 win_skip("Unable to load oledb conversion library\n");
359 return;
360 }
361
362 dst = 0x1234;
363 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
364 ok(hr == S_OK, "got %08x\n", hr);
365 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
366 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
367 ok(dst == 0, "got %08x\n", dst);
368
369 dst = 0x1234;
370 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
371 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
372 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
373 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
374 ok(dst == 0x1234, "got %08x\n", dst);
375
376 dst = 0x1234;
377 *(short *)src = 0x4321;
378 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
379 ok(hr == S_OK, "got %08x\n", hr);
380 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
381 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
382 ok(dst == 0x4321, "got %08x\n", dst);
383
384 dst = 0x1234;
385 *(int *)src = 0x4321cafe;
386 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
387 todo_wine
388 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
389 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
390 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
391 ok(dst == 0x1234, "got %08x\n", dst);
392
393 dst = 0x1234;
394 *(int *)src = 0x4321;
395 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
396 ok(hr == S_OK, "got %08x\n", hr);
397 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
398 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
399 ok(dst == 0x4321, "got %08x\n", dst);
400
401 dst = 0x1234;
402 *(FLOAT *)src = 10.75;
403 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
404 ok(hr == S_OK, "got %08x\n", hr);
405 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
406 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
407 ok(dst == 11, "got %08x\n", dst);
408
409 dst = 0x1234;
410 *(FLOAT *)src = -10.75;
411 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
412 ok(hr == S_OK, "got %08x\n", hr);
413 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
414 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
415 ok(dst == -11, "got %08x\n", dst);
416
417 dst = 0x1234;
418 *(double *)src = 10.75;
419 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
420 ok(hr == S_OK, "got %08x\n", hr);
421 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
422 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
423 ok(dst == 11, "got %08x\n", dst);
424
425 dst = 0x1234;
426 ((LARGE_INTEGER *)src)->QuadPart = 107500;
427 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
428 ok(hr == S_OK, "got %08x\n", hr);
429 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
430 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
431 ok(dst == 11, "got %08x\n", dst);
432
433 dst = 0x1234;
434 *(DATE *)src = 10.7500;
435 hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
436 ok(hr == S_OK, "got %08x\n", hr);
437 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
438 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
439 ok(dst == 11, "got %08x\n", dst);
440
441 dst = 0x1234;
442 b = SysAllocString(ten);
443 *(BSTR *)src = b;
444 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
445 ok(hr == S_OK, "got %08x\n", hr);
446 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
447 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
448 ok(dst == 10, "got %08x\n", dst);
449 SysFreeString(b);
450
451 dst = 0x1234;
452 *(SCODE *)src = 0x4321cafe;
453 hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
454 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
455 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
456 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
457 ok(dst == 0x1234, "got %08x\n", dst);
458
459 dst = 0x1234;
460 *(VARIANT_BOOL *)src = VARIANT_TRUE;
461 hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
462 ok(hr == S_OK, "got %08x\n", hr);
463 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
464 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
465 ok(dst == -1, "got %08x\n", dst);
466
467 dst = 0x1234;
468 *(VARIANT_BOOL *)src = VARIANT_FALSE;
469 hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
470 ok(hr == S_OK, "got %08x\n", hr);
471 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
472 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
473 ok(dst == 0, "got %08x\n", dst);
474
475 dst = 0x1234;
476 V_VT((VARIANT*)src) = VT_I2;
477 V_I2((VARIANT*)src) = 0x4321;
478 hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
479 todo_wine
480 {
481 ok(hr == S_OK, "got %08x\n", hr);
482 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
483 }
484 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
485 todo_wine
486 ok(dst == 0x4321, "got %08x\n", dst);
487
488 dst = 0x1234;
489 memset(src, 0, sizeof(DECIMAL));
490 ((DECIMAL*)src)->u1.Lo64 = 0x4321;
491 hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, 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 %d\n", dst_len);
495 ok(dst == 0x4321, "got %08x\n", dst);
496
497 dst = 0x1234;
498 *(signed char*)src = 0xab;
499 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
500 ok(hr == S_OK, "got %08x\n", hr);
501 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
502 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
503 ok(dst == (signed short)0xffab, "got %08x\n", dst);
504
505 dst = 0x1234;
506 *(BYTE*)src = 0xab;
507 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
508 ok(hr == S_OK, "got %08x\n", hr);
509 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
510 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
511 ok(dst == 0xab, "got %08x\n", dst);
512
513 dst = 0x1234;
514 *(WORD*)src = 0x4321;
515 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
516 ok(hr == S_OK, "got %08x\n", hr);
517 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
518 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
519 ok(dst == 0x4321, "got %08x\n", dst);
520
521 dst = 0x1234;
522 *(WORD*)src = 0xabcd;
523 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
524 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
525 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
526 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
527 ok(dst == 0x1234, "got %08x\n", dst);
528
529 dst = 0x1234;
530 *(DWORD*)src = 0xabcd1234;
531 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
532 todo_wine
533 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
534 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
535 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
536 ok(dst == 0x1234, "got %08x\n", dst);
537
538 dst = 0x1234;
539 *(DWORD*)src = 0x1234abcd;
540 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
541 todo_wine
542 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
543 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
544 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
545 ok(dst == 0x1234, "got %08x\n", dst);
546
547 dst = 0x1234;
548 *(DWORD*)src = 0x4321;
549 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
550 ok(hr == S_OK, "got %08x\n", hr);
551 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
552 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
553 ok(dst == 0x4321, "got %08x\n", dst);
554
555 dst = 0x1234;
556 ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
557 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
558 ok(hr == DB_E_ERRORSOCCURRED ||
559 broken(hr == DB_E_UNSUPPORTEDCONVERSION), /* win98 */
560 "got %08x\n", hr);
561 if(hr != DB_E_UNSUPPORTEDCONVERSION) /* win98 doesn't support I8/UI8 */
562 {
563 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
564 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
565 ok(dst == 0x1234, "got %08x\n", dst);
566
567 dst = 0x1234;
568 ((LARGE_INTEGER*)src)->QuadPart = 0x4321;
569 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
570 ok(hr == S_OK, "got %08x\n", hr);
571 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
572 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
573 ok(dst == 0x4321, "got %08x\n", dst);
574
575 dst = 0x1234;
576 ((ULARGE_INTEGER*)src)->QuadPart = 0x4321;
577 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
578 ok(hr == S_OK, "got %08x\n", hr);
579 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
580 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
581 ok(dst == 0x4321, "got %08x\n", dst);
582 }
583
584 dst = 0x1234;
585 strcpy((char *)src, "10");
586 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
587 ok(hr == S_OK, "got %08x\n", hr);
588 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
589 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
590 ok(dst == 10, "got %08x\n", dst);
591
592 dst = 0x1234;
593 strcpy((char *)src, "10");
594 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
595 ok(hr == S_OK, "got %08x\n", hr);
596 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
597 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
598 ok(dst == 10, "got %08x\n", dst);
599
600 dst = 0x1234;
601 memcpy(src, ten, sizeof(ten));
602 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
603 ok(hr == S_OK, "got %08x\n", hr);
604 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
605 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
606 ok(dst == 10, "got %08x\n", dst);
607
608 dst = 0x1234;
609 memcpy(src, ten, sizeof(ten));
610 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
611 ok(hr == S_OK, "got %08x\n", hr);
612 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
613 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
614 ok(dst == 10, "got %08x\n", dst);
615
616 IDataConvert_Release(convert);
617 }
618
619 static void test_converttoi4(void)
620 {
621 IDataConvert *convert;
622 HRESULT hr;
623 INT i4;
624 BYTE src[20];
625 DBSTATUS dst_status;
626 DBLENGTH dst_len;
627 static const WCHAR ten[] = {'1','0',0};
628 BSTR b;
629
630 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
631 if(FAILED(hr))
632 {
633 win_skip("Unable to load oledb conversion library\n");
634 return;
635 }
636
637 i4 = 0x12345678;
638 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
639 ok(hr == S_OK, "got %08x\n", hr);
640 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
641 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
642 ok(i4 == 0, "got %08x\n", i4);
643
644 i4 = 0x12345678;
645 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
646 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
647 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
648 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
649 ok(i4 == 0x12345678, "got %08x\n", i4);
650
651 i4 = 0x12345678;
652 *(short *)src = 0x4321;
653 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
654 ok(hr == S_OK, "got %08x\n", hr);
655 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
656 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
657 ok(i4 == 0x4321, "got %08x\n", i4);
658
659 i4 = 0x12345678;
660 *(int *)src = 0x4321cafe;
661 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
662 ok(hr == S_OK, "got %08x\n", hr);
663 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
664 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
665 ok(i4 == 0x4321cafe, "got %08x\n", i4);
666
667 i4 = 0x12345678;
668 *(FLOAT *)src = 10.75;
669 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
670 ok(hr == S_OK, "got %08x\n", hr);
671 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
672 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
673 ok(i4 == 11, "got %08x\n", i4);
674
675 i4 = 0x12345678;
676 *(FLOAT *)src = -10.75;
677 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
678 ok(hr == S_OK, "got %08x\n", hr);
679 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
680 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
681 ok(i4 == -11, "got %08x\n", i4);
682
683 i4 = 0x12345678;
684 *(double *)src = 10.75;
685 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
686 ok(hr == S_OK, "got %08x\n", hr);
687 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
688 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
689 ok(i4 == 11, "got %08x\n", i4);
690
691 i4 = 0x12345678;
692 ((LARGE_INTEGER *)src)->QuadPart = 107500;
693 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
694 ok(hr == S_OK, "got %08x\n", hr);
695 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
696 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
697 ok(i4 == 11, "got %08x\n", i4);
698
699 i4 = 0x12345678;
700 *(DATE *)src = 10.7500;
701 hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, 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 %d\n", dst_len);
705 ok(i4 == 11, "got %08x\n", i4);
706
707 i4 = 0x12345678;
708 b = SysAllocString(ten);
709 *(BSTR *)src = b;
710 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, 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 %d\n", dst_len);
714 ok(i4 == 10, "got %08x\n", i4);
715 SysFreeString(b);
716
717 i4 = 0x12345678;
718 *(SCODE *)src = 0x4321cafe;
719 hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
720 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
721 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
722 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
723 ok(i4 == 0x12345678, "got %08x\n", i4);
724
725 i4 = 0x12345678;
726 *(VARIANT_BOOL *)src = VARIANT_TRUE;
727 hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
728 ok(hr == S_OK, "got %08x\n", hr);
729 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
730 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
731 ok(i4 == 0xffffffff, "got %08x\n", i4);
732
733 i4 = 0x12345678;
734 *(VARIANT_BOOL *)src = VARIANT_FALSE;
735 hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
736 ok(hr == S_OK, "got %08x\n", hr);
737 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
738 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
739 ok(i4 == 0, "got %08x\n", i4);
740
741 i4 = 0x12345678;
742 V_VT((VARIANT*)src) = VT_I2;
743 V_I2((VARIANT*)src) = 0x1234;
744 hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
745 todo_wine
746 {
747 ok(hr == S_OK, "got %08x\n", hr);
748 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
749 }
750 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
751 todo_wine
752 ok(i4 == 0x1234, "got %08x\n", i4);
753
754 i4 = 0x12345678;
755 memset(src, 0, sizeof(DECIMAL));
756 ((DECIMAL*)src)->u1.Lo64 = 0x1234;
757 hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, 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 %d\n", dst_len);
761 ok(i4 == 0x1234, "got %08x\n", i4);
762
763 i4 = 0x12345678;
764 *(signed char*)src = 0xab;
765 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
766 ok(hr == S_OK, "got %08x\n", hr);
767 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
768 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
769 ok(i4 == 0xffffffab, "got %08x\n", i4);
770
771 i4 = 0x12345678;
772 *(BYTE*)src = 0xab;
773 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
774 ok(hr == S_OK, "got %08x\n", hr);
775 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
776 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
777 ok(i4 == 0xab, "got %08x\n", i4);
778
779 i4 = 0x12345678;
780 *(WORD*)src = 0xabcd;
781 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
782 ok(hr == S_OK, "got %08x\n", hr);
783 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
784 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
785 ok(i4 == 0xabcd, "got %08x\n", i4);
786
787 i4 = 0x12345678;
788 *(DWORD*)src = 0xabcd1234;
789 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
790 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
791 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
792 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
793 ok(i4 == 0x12345678, "got %08x\n", i4);
794
795 i4 = 0x12345678;
796 *(DWORD*)src = 0x1234abcd;
797 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
798 ok(hr == S_OK, "got %08x\n", hr);
799 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
800 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
801 ok(i4 == 0x1234abcd, "got %08x\n", i4);
802
803 i4 = 0x12345678;
804 ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
805 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
806 ok(hr == S_OK ||
807 broken(hr == DB_E_UNSUPPORTEDCONVERSION), /* win98 */
808 "got %08x\n", hr);
809 if(hr != DB_E_UNSUPPORTEDCONVERSION) /* win98 doesn't support I8/UI8 */
810 {
811 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
812 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
813 ok(i4 == 0x1234abcd, "got %08x\n", i4);
814
815 i4 = 0x12345678;
816 ((ULARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
817 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
818 ok(hr == S_OK, "got %08x\n", hr);
819 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
820 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
821 ok(i4 == 0x1234abcd, "got %08x\n", i4);
822 }
823
824 i4 = 0x12345678;
825 strcpy((char *)src, "10");
826 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 2, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
827 ok(hr == S_OK, "got %08x\n", hr);
828 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
829 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
830 ok(i4 == 10, "got %08x\n", i4);
831
832 i4 = 0x12345678;
833 strcpy((char *)src, "10");
834 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
835 ok(hr == S_OK, "got %08x\n", hr);
836 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
837 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
838 ok(i4 == 10, "got %08x\n", i4);
839
840 i4 = 0x12345678;
841 memcpy(src, ten, sizeof(ten));
842 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 4, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
843 ok(hr == S_OK, "got %08x\n", hr);
844 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
845 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
846 ok(i4 == 10, "got %08x\n", i4);
847
848 i4 = 0x12345678;
849 memcpy(src, ten, sizeof(ten));
850 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
851 ok(hr == S_OK, "got %08x\n", hr);
852 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
853 ok(dst_len == sizeof(i4), "got %d\n", dst_len);
854 ok(i4 == 10, "got %08x\n", i4);
855
856 IDataConvert_Release(convert);
857 }
858
859 static void test_converttobstr(void)
860 {
861 IDataConvert *convert;
862 HRESULT hr;
863 BSTR dst;
864 BYTE src[20];
865 DBSTATUS dst_status;
866 DBLENGTH dst_len;
867 static const WCHAR ten[] = {'1','0',0};
868 BSTR b;
869
870 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
871 if(FAILED(hr))
872 {
873 win_skip("Unable to load oledb conversion library\n");
874 return;
875 }
876
877 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
878 ok(hr == S_OK, "got %08x\n", hr);
879 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
880 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
881 ok(dst != NULL, "got %p\n", dst);
882 ok(SysStringLen(dst) == 0, "got %d\n", SysStringLen(dst));
883 SysFreeString(dst);
884
885 dst = (void*)0x1234;
886 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
887 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
888 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
889 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
890 ok(dst == (void*)0x1234, "got %p\n", dst);
891
892 *(short *)src = 4321;
893 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
894 ok(hr == S_OK, "got %08x\n", hr);
895 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
896 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
897 ok(dst != NULL, "got %p\n", dst);
898 ok(SysStringLen(dst) == 4, "got %d\n", SysStringLen(dst));
899 SysFreeString(dst);
900
901 b = SysAllocString(ten);
902 *(BSTR *)src = b;
903 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
904 ok(hr == S_OK, "got %08x\n", hr);
905 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
906 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
907 ok(dst != NULL, "got %p\n", dst);
908 ok(dst != b, "got %p src %p\n", dst, b);
909 ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
910 SysFreeString(dst);
911 SysFreeString(b);
912
913 IDataConvert_Release(convert);
914 }
915
916 static void test_converttowstr(void)
917 {
918 IDataConvert *convert;
919 HRESULT hr;
920 WCHAR dst[100];
921 BYTE src[20];
922 DBSTATUS dst_status;
923 DBLENGTH dst_len;
924 static const WCHAR ten[] = {'1','0',0};
925 static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
926 static const WCHAR guid_str[] = {
927 '{','0','C','7','3','3','A','8','D','-','2','A','1','C','-','1','1','C','E','-',
928 'A','D','E','5','-','0','0','A','A','0','0','4','4','7','7','3','D','}',0};
929 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 };
930 static const WCHAR hexpacked_w[] = {'W','i','n','e', 0 };
931 BSTR b;
932
933 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
934 if(FAILED(hr))
935 {
936 win_skip("Unable to load oledb conversion library\n");
937 return;
938 }
939
940
941 memset(dst, 0xcc, sizeof(dst));
942 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
943 ok(hr == S_OK, "got %08x\n", hr);
944 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
945 ok(dst_len == 0, "got %d\n", dst_len);
946 ok(dst[0] == 0, "got %02x\n", dst[0]);
947 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
948
949 memset(dst, 0xcc, sizeof(dst));
950 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
951 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
952 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
953 ok(dst_len == 0, "got %d\n", dst_len);
954 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
955
956 *(short *)src = 4321;
957 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
958 ok(hr == S_OK, "got %08x\n", hr);
959 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
960 ok(dst_len == 8, "got %d\n", dst_len);
961 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
962
963 *(short *)src = 4321;
964 memset(dst, 0xcc, sizeof(dst));
965 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
966 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
967 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
968 ok(dst_len == 8, "got %d\n", dst_len);
969 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
970
971 *(short *)src = 4321;
972 memset(dst, 0xcc, sizeof(dst));
973 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
974 ok(hr == S_OK, "got %08x\n", hr);
975 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
976 ok(dst_len == 8, "got %d\n", dst_len);
977 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
978
979 *(short *)src = 4321;
980 memset(dst, 0xcc, sizeof(dst));
981 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
982 ok(hr == S_OK, "got %08x\n", hr);
983 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
984 ok(dst_len == 8, "got %d\n", dst_len);
985 ok(dst[0] == '4', "got %02x\n", dst[0]);
986 ok(dst[1] == 0, "got %02x\n", dst[1]);
987 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
988
989 *(short *)src = 4321;
990 memset(dst, 0xcc, sizeof(dst));
991 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
992 ok(hr == S_OK, "got %08x\n", hr);
993 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
994 ok(dst_len == 8, "got %d\n", dst_len);
995 ok(dst[0] == 0, "got %02x\n", dst[0]);
996 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
997
998 *(short *)src = 4321;
999 memset(dst, 0xcc, sizeof(dst));
1000 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1001 ok(hr == S_OK, "got %08x\n", hr);
1002 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1003 ok(dst_len == 8, "got %d\n", dst_len);
1004 ok(dst[0] == '4', "got %02x\n", dst[0]);
1005 ok(dst[1] == '3', "got %02x\n", dst[1]);
1006 ok(dst[2] == '2', "got %02x\n", dst[2]);
1007 ok(dst[3] == 0, "got %02x\n", dst[3]);
1008 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1009
1010
1011
1012 *(int *)src = 4321;
1013 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1014 ok(hr == S_OK, "got %08x\n", hr);
1015 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1016 ok(dst_len == 8, "got %d\n", dst_len);
1017 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1018
1019 *(int *)src = 4321;
1020 memset(dst, 0xcc, sizeof(dst));
1021 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1022 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1023 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1024 ok(dst_len == 8, "got %d\n", dst_len);
1025 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1026
1027 *(int *)src = 4321;
1028 memset(dst, 0xcc, sizeof(dst));
1029 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1030 ok(hr == S_OK, "got %08x\n", hr);
1031 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1032 ok(dst_len == 8, "got %d\n", dst_len);
1033 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1034
1035 *(int *)src = 4321;
1036 memset(dst, 0xcc, sizeof(dst));
1037 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1038 ok(hr == S_OK, "got %08x\n", hr);
1039 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1040 ok(dst_len == 8, "got %d\n", dst_len);
1041 ok(dst[0] == '4', "got %02x\n", dst[0]);
1042 ok(dst[1] == 0, "got %02x\n", dst[1]);
1043 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1044
1045 *(int *)src = 4321;
1046 memset(dst, 0xcc, sizeof(dst));
1047 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1048 ok(hr == S_OK, "got %08x\n", hr);
1049 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1050 ok(dst_len == 8, "got %d\n", dst_len);
1051 ok(dst[0] == 0, "got %02x\n", dst[0]);
1052 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1053
1054 *(int *)src = 4321;
1055 memset(dst, 0xcc, sizeof(dst));
1056 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1057 ok(hr == S_OK, "got %08x\n", hr);
1058 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1059 ok(dst_len == 8, "got %d\n", dst_len);
1060 ok(dst[0] == '4', "got %02x\n", dst[0]);
1061 ok(dst[1] == '3', "got %02x\n", dst[1]);
1062 ok(dst[2] == '2', "got %02x\n", dst[2]);
1063 ok(dst[3] == 0, "got %02x\n", dst[3]);
1064 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1065
1066
1067
1068 *(float *)src = 4321;
1069 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1070 ok(hr == S_OK, "got %08x\n", hr);
1071 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1072 ok(dst_len == 8, "got %d\n", dst_len);
1073 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1074
1075 *(float *)src = 4321;
1076 memset(dst, 0xcc, sizeof(dst));
1077 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1078 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1079 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1080 ok(dst_len == 8, "got %d\n", dst_len);
1081 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1082
1083 *(float *)src = 4321;
1084 memset(dst, 0xcc, sizeof(dst));
1085 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1086 ok(hr == S_OK, "got %08x\n", hr);
1087 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1088 ok(dst_len == 8, "got %d\n", dst_len);
1089 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1090
1091 *(float *)src = 4321;
1092 memset(dst, 0xcc, sizeof(dst));
1093 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1094 ok(hr == S_OK, "got %08x\n", hr);
1095 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1096 ok(dst_len == 8, "got %d\n", dst_len);
1097 ok(dst[0] == '4', "got %02x\n", dst[0]);
1098 ok(dst[1] == 0, "got %02x\n", dst[1]);
1099 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1100
1101 *(float *)src = 4321;
1102 memset(dst, 0xcc, sizeof(dst));
1103 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1104 ok(hr == S_OK, "got %08x\n", hr);
1105 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1106 ok(dst_len == 8, "got %d\n", dst_len);
1107 ok(dst[0] == 0, "got %02x\n", dst[0]);
1108 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1109
1110 *(float *)src = 4321;
1111 memset(dst, 0xcc, sizeof(dst));
1112 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1113 ok(hr == S_OK, "got %08x\n", hr);
1114 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1115 ok(dst_len == 8, "got %d\n", dst_len);
1116 ok(dst[0] == '4', "got %02x\n", dst[0]);
1117 ok(dst[1] == '3', "got %02x\n", dst[1]);
1118 ok(dst[2] == '2', "got %02x\n", dst[2]);
1119 ok(dst[3] == 0, "got %02x\n", dst[3]);
1120 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1121
1122
1123
1124 *(double *)src = 4321;
1125 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1126 ok(hr == S_OK, "got %08x\n", hr);
1127 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1128 ok(dst_len == 8, "got %d\n", dst_len);
1129 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1130
1131 *(double *)src = 4321;
1132 memset(dst, 0xcc, sizeof(dst));
1133 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1134 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1135 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1136 ok(dst_len == 8, "got %d\n", dst_len);
1137 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1138
1139 *(double *)src = 4321;
1140 memset(dst, 0xcc, sizeof(dst));
1141 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1142 ok(hr == S_OK, "got %08x\n", hr);
1143 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1144 ok(dst_len == 8, "got %d\n", dst_len);
1145 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1146
1147 *(double *)src = 4321;
1148 memset(dst, 0xcc, sizeof(dst));
1149 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1150 ok(hr == S_OK, "got %08x\n", hr);
1151 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1152 ok(dst_len == 8, "got %d\n", dst_len);
1153 ok(dst[0] == '4', "got %02x\n", dst[0]);
1154 ok(dst[1] == 0, "got %02x\n", dst[1]);
1155 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1156
1157 *(double *)src = 4321;
1158 memset(dst, 0xcc, sizeof(dst));
1159 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1160 ok(hr == S_OK, "got %08x\n", hr);
1161 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1162 ok(dst_len == 8, "got %d\n", dst_len);
1163 ok(dst[0] == 0, "got %02x\n", dst[0]);
1164 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1165
1166 *(double *)src = 4321;
1167 memset(dst, 0xcc, sizeof(dst));
1168 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1169 ok(hr == S_OK, "got %08x\n", hr);
1170 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1171 ok(dst_len == 8, "got %d\n", dst_len);
1172 ok(dst[0] == '4', "got %02x\n", dst[0]);
1173 ok(dst[1] == '3', "got %02x\n", dst[1]);
1174 ok(dst[2] == '2', "got %02x\n", dst[2]);
1175 ok(dst[3] == 0, "got %02x\n", dst[3]);
1176 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1177
1178
1179
1180 memset(src, 0, sizeof(src));
1181 ((CY*)src)->int64 = 43210000;
1182 memset(dst, 0xcc, sizeof(dst));
1183 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1184 ok(hr == S_OK, "got %08x\n", hr);
1185 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1186 ok(dst_len == 8, "got %d\n", dst_len);
1187 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1188
1189
1190
1191 memset(src, 0, sizeof(src));
1192 *(signed char *)src = 10;
1193 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1194 ok(hr == S_OK, "got %08x\n", hr);
1195 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1196 ok(dst_len == 4, "got %d\n", dst_len);
1197 ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1198
1199 memset(src, 0, sizeof(src));
1200 *(unsigned char *)src = 10;
1201 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, 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 == 4, "got %d\n", dst_len);
1205 ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1206
1207 memset(src, 0, sizeof(src));
1208 *(unsigned short *)src = 4321;
1209 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1210 ok(hr == S_OK, "got %08x\n", hr);
1211 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1212 ok(dst_len == 8, "got %d\n", dst_len);
1213 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1214
1215 memset(src, 0, sizeof(src));
1216 *(unsigned int *)src = 4321;
1217 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1218 ok(hr == S_OK, "got %08x\n", hr);
1219 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1220 ok(dst_len == 8, "got %d\n", dst_len);
1221 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1222
1223 memset(src, 0, sizeof(src));
1224 ((LARGE_INTEGER*)src)->QuadPart = 4321;
1225 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1226 ok(hr == S_OK, "got %08x\n", hr);
1227 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1228 ok(dst_len == 8, "got %d\n", dst_len);
1229 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1230
1231 memset(src, 0, sizeof(src));
1232 ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1233 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1234 ok(hr == S_OK, "got %08x\n", hr);
1235 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1236 ok(dst_len == 8, "got %d\n", dst_len);
1237 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1238
1239
1240
1241 memset(src, 0, sizeof(src));
1242 memcpy(src, &IID_IDataConvert, sizeof(GUID));
1243 memset(dst, 0xcc, sizeof(dst));
1244 hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1245 ok(hr == S_OK, "got %08x\n", hr);
1246 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1247 ok(dst_len == 76, "got %d\n", dst_len);
1248 ok(!lstrcmpW(dst, guid_str), "got %s\n", wine_dbgstr_w(dst));
1249
1250
1251
1252 b = SysAllocString(ten);
1253 *(BSTR *)src = b;
1254 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1255 ok(hr == S_OK, "got %08x\n", hr);
1256 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1257 ok(dst_len == 4, "got %d\n", dst_len);
1258 ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1259 SysFreeString(b);
1260
1261 memcpy(src, ten, sizeof(ten));
1262 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1263 ok(hr == S_OK, "got %08x\n", hr);
1264 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1265 ok(dst_len == 2, "got %d\n", dst_len);
1266 ok(dst[0] == '1', "got %02x\n", dst[0]);
1267 ok(dst[1] == 0, "got %02x\n", dst[1]);
1268
1269 memcpy(src, ten, sizeof(ten));
1270 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1271 ok(hr == S_OK, "got %08x\n", hr);
1272 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1273 ok(dst_len == 4, "got %d\n", dst_len);
1274 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1275
1276 memcpy(src, ten, sizeof(ten));
1277 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1278 ok(hr == S_OK, "got %08x\n", hr);
1279 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1280 ok(dst_len == 4, "got %d\n", dst_len);
1281 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1282
1283
1284
1285 /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1286 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1287 memset(dst, 0xcc, sizeof(dst));
1288 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1289 ok(hr == S_OK, "got %08x\n", hr);
1290 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1291 ok(dst_len == sizeof(hexpacked_w) * 4, "got %d\n", dst_len);
1292 ok(!lstrcmpW(hexunpacked_w, dst), "got %s\n", wine_dbgstr_w(dst));
1293 ok(dst[sizeof(hexpacked_w)/sizeof(WCHAR) * 4 + 1] == 0xcccc, "clobbered buffer\n");
1294
1295 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1296 memset(dst, 0xcc, sizeof(dst));
1297 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1298 ok(hr == S_OK, "got %08x\n", hr);
1299 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1300 ok(dst_len == 0, "got %d\n", dst_len);
1301 ok(dst[0] == 0, "not null terminated\n");
1302 ok(dst[1] == 0xcccc, "clobbered buffer\n");
1303
1304 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1305 memset(dst, 0xcc, sizeof(dst));
1306 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1307 ok(hr == S_OK, "got %08x\n", hr);
1308 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1309 ok(dst_len == 2 * sizeof(WCHAR) * 4, "got %d\n", dst_len);
1310 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1311 ok(dst[2 * 4] == 0, "not null terminated\n");
1312 ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1313
1314 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1315 memset(dst, 0xcc, sizeof(dst));
1316 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);
1317 ok(hr == S_OK, "got %08x\n", hr);
1318 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1319 ok(dst_len == sizeof(hexpacked_w) * 4, "got %d\n", dst_len);
1320 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1321 ok(dst[2 * 4] == 0, "not null terminated\n");
1322 ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1323
1324 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1325 memset(dst, 0xcc, sizeof(dst));
1326 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);
1327 ok(hr == S_OK, "got %08x\n", hr);
1328 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1329 ok(dst_len == sizeof(hexpacked_w) * 4, "got %d\n", dst_len);
1330 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1331 ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1332 ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1333
1334 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1335 memset(dst, 0xcc, sizeof(dst));
1336 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);
1337 ok(hr == S_OK, "got %08x\n", hr);
1338 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1339 ok(dst_len == sizeof(hexpacked_w) * 4, "got %d\n", dst_len);
1340 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1341 ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1342 ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1343
1344 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1345 memset(dst, 0xcc, sizeof(dst));
1346 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1347 ok(hr == S_OK, "got %08x\n", hr);
1348 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1349 ok(dst_len == 0, "got %d\n", dst_len);
1350 ok(dst[0] == 0, "not null terminated\n");
1351 ok(dst[1] == 0xcccc, "clobbered buffer\n");
1352
1353
1354 IDataConvert_Release(convert);
1355 }
1356
1357 static void test_converttostr(void)
1358 {
1359 IDataConvert *convert;
1360 HRESULT hr;
1361 char dst[100];
1362 BYTE src[64];
1363 DBSTATUS dst_status;
1364 DBLENGTH dst_len;
1365 static const WCHAR ten[] = {'1','0',0};
1366 static const char ten_a[] = "10";
1367 static const char fourthreetwoone[] = "4321";
1368 static const char guid_str[] = "{0C733A8D-2A1C-11CE-ADE5-00AA0044773D}";
1369 static const char hexunpacked_a[] = "57696E6500";
1370 static const char hexpacked_a[] = "Wine";
1371 BSTR b;
1372
1373 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1374 if(FAILED(hr))
1375 {
1376 win_skip("Unable to load oledb conversion library\n");
1377 return;
1378 }
1379
1380
1381 memset(dst, 0xcc, sizeof(dst));
1382 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1383 ok(hr == S_OK, "got %08x\n", hr);
1384 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1385 ok(dst_len == 0, "got %d\n", dst_len);
1386 ok(dst[0] == 0, "got %02x\n", dst[0]);
1387 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1388
1389 memset(dst, 0xcc, sizeof(dst));
1390 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1391 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1392 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1393 ok(dst_len == 0, "got %d\n", dst_len);
1394 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1395
1396 *(short *)src = 4321;
1397 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1398 ok(hr == S_OK, "got %08x\n", hr);
1399 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1400 ok(dst_len == 4, "got %d\n", dst_len);
1401 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1402
1403 *(short *)src = 4321;
1404 memset(dst, 0xcc, sizeof(dst));
1405 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1406 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1407 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1408 ok(dst_len == 4, "got %d\n", dst_len);
1409 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1410
1411 *(short *)src = 4321;
1412 memset(dst, 0xcc, sizeof(dst));
1413 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1414 ok(hr == S_OK, "got %08x\n", hr);
1415 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1416 ok(dst_len == 4, "got %d\n", dst_len);
1417 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1418
1419 *(short *)src = 4321;
1420 memset(dst, 0xcc, sizeof(dst));
1421 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1422 ok(hr == S_OK, "got %08x\n", hr);
1423 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1424 ok(dst_len == 4, "got %d\n", dst_len);
1425 ok(dst[0] == '4', "got %02x\n", dst[0]);
1426 ok(dst[1] == 0, "got %02x\n", dst[1]);
1427 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1428
1429 *(short *)src = 4321;
1430 memset(dst, 0xcc, sizeof(dst));
1431 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1432 ok(hr == S_OK, "got %08x\n", hr);
1433 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1434 ok(dst_len == 4, "got %d\n", dst_len);
1435 ok(dst[0] == 0, "got %02x\n", dst[0]);
1436 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1437
1438 *(short *)src = 4321;
1439 memset(dst, 0xcc, sizeof(dst));
1440 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1441 ok(hr == S_OK, "got %08x\n", hr);
1442 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1443 ok(dst_len == 4, "got %d\n", dst_len);
1444 ok(dst[0] == '4', "got %02x\n", dst[0]);
1445 ok(dst[1] == '3', "got %02x\n", dst[1]);
1446 ok(dst[2] == '2', "got %02x\n", dst[2]);
1447 ok(dst[3] == 0, "got %02x\n", dst[3]);
1448 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1449
1450
1451 *(int *)src = 4321;
1452 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1453 ok(hr == S_OK, "got %08x\n", hr);
1454 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1455 ok(dst_len == 4, "got %d\n", dst_len);
1456 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1457
1458 *(int *)src = 4321;
1459 memset(dst, 0xcc, sizeof(dst));
1460 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1461 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1462 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1463 ok(dst_len == 4, "got %d\n", dst_len);
1464 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1465
1466 *(int *)src = 4321;
1467 memset(dst, 0xcc, sizeof(dst));
1468 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1469 ok(hr == S_OK, "got %08x\n", hr);
1470 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1471 ok(dst_len == 4, "got %d\n", dst_len);
1472 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1473
1474 *(int *)src = 4321;
1475 memset(dst, 0xcc, sizeof(dst));
1476 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1477 ok(hr == S_OK, "got %08x\n", hr);
1478 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1479 ok(dst_len == 4, "got %d\n", dst_len);
1480 ok(dst[0] == '4', "got %02x\n", dst[0]);
1481 ok(dst[1] == 0, "got %02x\n", dst[1]);
1482 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1483
1484 *(int *)src = 4321;
1485 memset(dst, 0xcc, sizeof(dst));
1486 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1487 ok(hr == S_OK, "got %08x\n", hr);
1488 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1489 ok(dst_len == 4, "got %d\n", dst_len);
1490 ok(dst[0] == 0, "got %02x\n", dst[0]);
1491 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1492
1493 *(int *)src = 4321;
1494 memset(dst, 0xcc, sizeof(dst));
1495 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1496 ok(hr == S_OK, "got %08x\n", hr);
1497 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1498 ok(dst_len == 4, "got %d\n", dst_len);
1499 ok(dst[0] == '4', "got %02x\n", dst[0]);
1500 ok(dst[1] == '3', "got %02x\n", dst[1]);
1501 ok(dst[2] == '2', "got %02x\n", dst[2]);
1502 ok(dst[3] == 0, "got %02x\n", dst[3]);
1503 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1504
1505
1506 *(float *)src = 4321;
1507 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1508 ok(hr == S_OK, "got %08x\n", hr);
1509 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1510 ok(dst_len == 4, "got %d\n", dst_len);
1511 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1512
1513 *(float *)src = 4321;
1514 memset(dst, 0xcc, sizeof(dst));
1515 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1516 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1517 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1518 ok(dst_len == 4, "got %d\n", dst_len);
1519 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1520
1521 *(float *)src = 4321;
1522 memset(dst, 0xcc, sizeof(dst));
1523 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1524 ok(hr == S_OK, "got %08x\n", hr);
1525 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1526 ok(dst_len == 4, "got %d\n", dst_len);
1527 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1528
1529 *(float *)src = 4321;
1530 memset(dst, 0xcc, sizeof(dst));
1531 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1532 ok(hr == S_OK, "got %08x\n", hr);
1533 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1534 ok(dst_len == 4, "got %d\n", dst_len);
1535 ok(dst[0] == '4', "got %02x\n", dst[0]);
1536 ok(dst[1] == 0, "got %02x\n", dst[1]);
1537 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1538
1539 *(float *)src = 4321;
1540 memset(dst, 0xcc, sizeof(dst));
1541 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1542 ok(hr == S_OK, "got %08x\n", hr);
1543 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1544 ok(dst_len == 4, "got %d\n", dst_len);
1545 ok(dst[0] == 0, "got %02x\n", dst[0]);
1546 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1547
1548 *(float *)src = 4321;
1549 memset(dst, 0xcc, sizeof(dst));
1550 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1551 ok(hr == S_OK, "got %08x\n", hr);
1552 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1553 ok(dst_len == 4, "got %d\n", dst_len);
1554 ok(dst[0] == '4', "got %02x\n", dst[0]);
1555 ok(dst[1] == '3', "got %02x\n", dst[1]);
1556 ok(dst[2] == '2', "got %02x\n", dst[2]);
1557 ok(dst[3] == 0, "got %02x\n", dst[3]);
1558 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1559
1560
1561 *(double *)src = 4321;
1562 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1563 ok(hr == S_OK, "got %08x\n", hr);
1564 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1565 ok(dst_len == 4, "got %d\n", dst_len);
1566 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1567
1568 *(double *)src = 4321;
1569 memset(dst, 0xcc, sizeof(dst));
1570 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1571 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1572 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1573 ok(dst_len == 4, "got %d\n", dst_len);
1574 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1575
1576 *(double *)src = 4321;
1577 memset(dst, 0xcc, sizeof(dst));
1578 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1579 ok(hr == S_OK, "got %08x\n", hr);
1580 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1581 ok(dst_len == 4, "got %d\n", dst_len);
1582 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1583
1584 *(double *)src = 4321;
1585 memset(dst, 0xcc, sizeof(dst));
1586 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1587 ok(hr == S_OK, "got %08x\n", hr);
1588 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1589 ok(dst_len == 4, "got %d\n", dst_len);
1590 ok(dst[0] == '4', "got %02x\n", dst[0]);
1591 ok(dst[1] == 0, "got %02x\n", dst[1]);
1592 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1593
1594 *(double *)src = 4321;
1595 memset(dst, 0xcc, sizeof(dst));
1596 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1597 ok(hr == S_OK, "got %08x\n", hr);
1598 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1599 ok(dst_len == 4, "got %d\n", dst_len);
1600 ok(dst[0] == 0, "got %02x\n", dst[0]);
1601 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1602
1603 *(double *)src = 4321;
1604 memset(dst, 0xcc, sizeof(dst));
1605 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1606 ok(hr == S_OK, "got %08x\n", hr);
1607 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1608 ok(dst_len == 4, "got %d\n", dst_len);
1609 ok(dst[0] == '4', "got %02x\n", dst[0]);
1610 ok(dst[1] == '3', "got %02x\n", dst[1]);
1611 ok(dst[2] == '2', "got %02x\n", dst[2]);
1612 ok(dst[3] == 0, "got %02x\n", dst[3]);
1613 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1614
1615
1616
1617 memset(src, 0, sizeof(src));
1618 ((CY*)src)->int64 = 43210000;
1619 memset(dst, 0xcc, sizeof(dst));
1620 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1621 ok(hr == S_OK, "got %08x\n", hr);
1622 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1623 ok(dst_len == 4, "got %d\n", dst_len);
1624 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1625
1626
1627
1628 memset(src, 0, sizeof(src));
1629 *(signed char *)src = 10;
1630 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1631 ok(hr == S_OK, "got %08x\n", hr);
1632 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1633 ok(dst_len == 2, "got %d\n", dst_len);
1634 ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1635
1636 memset(src, 0, sizeof(src));
1637 *(unsigned char *)src = 10;
1638 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1639 ok(hr == S_OK, "got %08x\n", hr);
1640 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1641 ok(dst_len == 2, "got %d\n", dst_len);
1642 ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1643
1644 memset(src, 0, sizeof(src));
1645 *(unsigned short *)src = 4321;
1646 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1647 ok(hr == S_OK, "got %08x\n", hr);
1648 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1649 ok(dst_len == 4, "got %d\n", dst_len);
1650 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1651
1652 memset(src, 0, sizeof(src));
1653 *(unsigned int *)src = 4321;
1654 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1655 ok(hr == S_OK, "got %08x\n", hr);
1656 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1657 ok(dst_len == 4, "got %d\n", dst_len);
1658 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1659
1660 memset(src, 0, sizeof(src));
1661 ((LARGE_INTEGER*)src)->QuadPart = 4321;
1662 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1663 ok(hr == S_OK, "got %08x\n", hr);
1664 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1665 ok(dst_len == 4, "got %d\n", dst_len);
1666 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1667
1668 memset(src, 0, sizeof(src));
1669 ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1670 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1671 ok(hr == S_OK, "got %08x\n", hr);
1672 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1673 ok(dst_len == 4, "got %d\n", dst_len);
1674 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1675
1676
1677
1678 memset(src, 0, sizeof(src));
1679 memcpy(src, &IID_IDataConvert, sizeof(GUID));
1680 memset(dst, 0xcc, sizeof(dst));
1681 hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_STR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1682 ok(hr == S_OK, "got %08x\n", hr);
1683 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1684 ok(dst_len == 38, "got %d\n", dst_len);
1685 ok(!lstrcmpA(dst, guid_str), "got %s\n", dst);
1686
1687
1688
1689 b = SysAllocString(ten);
1690 *(BSTR *)src = b;
1691 memset(dst, 0xcc, sizeof(dst));
1692 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1693 ok(hr == S_OK, "got %08x\n", hr);
1694 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1695 ok(dst_len == 2, "got %d\n", dst_len);
1696 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1697 SysFreeString(b);
1698
1699 memcpy(src, ten, sizeof(ten));
1700 memset(dst, 0xcc, sizeof(dst));
1701 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1702 ok(hr == S_OK, "got %08x\n", hr);
1703 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1704 ok(dst_len == 1, "got %d\n", dst_len);
1705 ok(dst[0] == '1', "got %02x\n", dst[0]);
1706 ok(dst[1] == 0, "got %02x\n", dst[1]);
1707
1708 memcpy(src, ten, sizeof(ten));
1709 memset(dst, 0xcc, sizeof(dst));
1710 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1711 ok(hr == S_OK, "got %08x\n", hr);
1712 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1713 ok(dst_len == 2, "got %d\n", dst_len);
1714 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1715
1716 memcpy(src, ten, sizeof(ten));
1717 memset(dst, 0xcc, sizeof(dst));
1718 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1719 ok(hr == S_OK, "got %08x\n", hr);
1720 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1721 ok(dst_len == 2, "got %d\n", dst_len);
1722 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1723
1724 memcpy(src, ten_a, sizeof(ten_a));
1725 memset(dst, 0xcc, sizeof(dst));
1726 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1727 ok(hr == S_OK, "got %08x\n", hr);
1728 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1729 ok(dst_len == 2, "got %d\n", dst_len);
1730 ok(dst[0] == '1', "got %02x\n", dst[0]);
1731 ok(dst[1] == '0', "got %02x\n", dst[1]);
1732 ok(dst[2] == 0, "got %02x\n", dst[2]);
1733 ok(dst[3] == (char)0xcc, "got %02x\n", dst[3]);
1734
1735 memcpy(src, ten_a, sizeof(ten_a));
1736 memset(dst, 0xcc, sizeof(dst));
1737 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1738 ok(hr == S_OK, "got %08x\n", hr);
1739 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1740 ok(dst_len == 4, "got %d\n", dst_len);
1741 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1742
1743 memcpy(src, ten_a, sizeof(ten_a));
1744 memset(dst, 0xcc, sizeof(dst));
1745 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1746 ok(hr == S_OK, "got %08x\n", hr);
1747 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1748 ok(dst_len == 2, "got %d\n", dst_len);
1749 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1750
1751
1752
1753 /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1754 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1755 memset(dst, 0xcc, sizeof(dst));
1756 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, sizeof(hexpacked_a), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1757 ok(hr == S_OK, "got %08x\n", hr);
1758 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1759 ok(dst_len == sizeof(hexpacked_a) * 2, "got %d\n", dst_len);
1760 ok(!lstrcmpA(hexunpacked_a, dst), "got %s\n", dst);
1761 ok(dst[sizeof(hexpacked_a)/sizeof(char) * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1762
1763 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1764 memset(dst, 0xcc, sizeof(dst));
1765 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1766 ok(hr == S_OK, "got %08x\n", hr);
1767 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1768 ok(dst_len == 0, "got %d\n", dst_len);
1769 ok(dst[0] == 0, "not null terminated\n");
1770 ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1771
1772 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1773 memset(dst, 0xcc, sizeof(dst));
1774 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1775 ok(hr == S_OK, "got %08x\n", hr);
1776 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1777 ok(dst_len == 2 * sizeof(char) * 4, "got %d\n", dst_len);
1778 ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1779 ok(dst[2 * 4] == 0, "not null terminated\n");
1780 ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1781
1782 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1783 memset(dst, 0xcc, sizeof(dst));
1784 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);
1785 ok(hr == S_OK, "got %08x\n", hr);
1786 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1787 ok(dst_len == sizeof(hexpacked_a) * 2, "got %d\n", dst_len);
1788 ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1789 ok(dst[2 * 4] == 0, "not null terminated\n");
1790 ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1791
1792 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1793 memset(dst, 0xcc, sizeof(dst));
1794 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);
1795 ok(hr == S_OK, "got %08x\n", hr);
1796 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1797 ok(dst_len == sizeof(hexpacked_a) * 2, "got %d\n", dst_len);
1798 ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 - 2 ), "got %s\n", dst);
1799 ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1800 ok(dst[2 * 4] == (char)0xcc, "clobbered buffer\n");
1801
1802 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1803 memset(dst, 0xcc, sizeof(dst));
1804 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1805 ok(hr == S_OK, "got %08x\n", hr);
1806 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1807 ok(dst_len == 0, "got %d\n", dst_len);
1808 ok(dst[0] == 0, "not null terminated\n");
1809 ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1810
1811 IDataConvert_Release(convert);
1812 }
1813
1814 static void test_converttobyrefwstr(void)
1815 {
1816 IDataConvert *convert;
1817 HRESULT hr;
1818 WCHAR *dst;
1819 BYTE src[20];
1820 DBSTATUS dst_status;
1821 DBLENGTH dst_len;
1822 static const WCHAR ten[] = {'1','0',0};
1823 static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1824 BSTR b;
1825
1826 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1827 if(FAILED(hr))
1828 {
1829 win_skip("Unable to load oledb conversion library\n");
1830 return;
1831 }
1832
1833 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BYREF | DBTYPE_WSTR, 0, &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 == 0, "got %d\n", dst_len);
1837 ok(dst[0] == 0, "got %04x\n", dst[0]);
1838 CoTaskMemFree(dst);
1839
1840 dst = (void*)0x12345678;
1841 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1842 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1843 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1844 ok(dst_len == 0, "got %d\n", dst_len);
1845 ok(dst == (void*)0x12345678, "got %p\n", dst);
1846
1847 *(short *)src = 4321;
1848 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1849 ok(hr == S_OK, "got %08x\n", hr);
1850 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1851 ok(dst_len == 8, "got %d\n", dst_len);
1852 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1853 CoTaskMemFree(dst);
1854
1855 *(short *)src = 4321;
1856 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, 0, 0, &dst_status, 0, 0, 0);
1857 ok(hr == S_OK, "got %08x\n", hr);
1858 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1859 ok(dst_len == 8, "got %d\n", dst_len);
1860 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1861 CoTaskMemFree(dst);
1862
1863 b = SysAllocString(ten);
1864 *(BSTR *)src = b;
1865 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1866 ok(hr == S_OK, "got %08x\n", hr);
1867 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1868 ok(dst_len == 4, "got %d\n", dst_len);
1869 ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1870 CoTaskMemFree(dst);
1871 SysFreeString(b);
1872
1873 memcpy(src, ten, sizeof(ten));
1874 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1875 ok(hr == S_OK, "got %08x\n", hr);
1876 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1877 ok(dst_len == 2, "got %d\n", dst_len);
1878 ok(dst[0] == '1', "got %02x\n", dst[0]);
1879 ok(dst[1] == 0, "got %02x\n", dst[1]);
1880 CoTaskMemFree(dst);
1881
1882 memcpy(src, ten, sizeof(ten));
1883 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1884 ok(hr == S_OK, "got %08x\n", hr);
1885 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1886 ok(dst_len == 4, "got %d\n", dst_len);
1887 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1888 CoTaskMemFree(dst);
1889
1890 memcpy(src, ten, sizeof(ten));
1891 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1892 ok(hr == S_OK, "got %08x\n", hr);
1893 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1894 ok(dst_len == 4, "got %d\n", dst_len);
1895 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1896 CoTaskMemFree(dst);
1897
1898 IDataConvert_Release(convert);
1899 }
1900
1901 static void test_converttoguid(void)
1902 {
1903 IDataConvert *convert;
1904 HRESULT hr;
1905 GUID dst;
1906 BYTE src[20];
1907 DBSTATUS dst_status;
1908 DBLENGTH dst_len;
1909
1910 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1911 if(FAILED(hr))
1912 {
1913 win_skip("Unable to load oledb conversion library\n");
1914 return;
1915 }
1916
1917 dst = IID_IDCInfo;
1918 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1919 ok(hr == S_OK, "got %08x\n", hr);
1920 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1921 ok(dst_len == sizeof(GUID), "got %d\n", dst_len);
1922 ok(IsEqualGUID(&dst, &GUID_NULL), "didn't get GUID_NULL\n");
1923
1924 dst = IID_IDCInfo;
1925 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1926 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1927 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1928 ok(dst_len == sizeof(GUID), "got %d\n", dst_len);
1929 ok(IsEqualGUID(&dst, &IID_IDCInfo), "dst has changed\n");
1930
1931 dst = IID_IDCInfo;
1932 memcpy(src, &IID_IDataConvert, sizeof(GUID));
1933 hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1934 ok(hr == S_OK, "got %08x\n", hr);
1935 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1936 ok(dst_len == sizeof(GUID), "got %d\n", dst_len);
1937 ok(IsEqualGUID(&dst, &IID_IDataConvert), "didn't get IID_IDataConvert\n");
1938
1939 IDataConvert_Release(convert);
1940 }
1941
1942 static void test_converttofiletime(void)
1943 {
1944 IDataConvert *convert;
1945 HRESULT hr;
1946 FILETIME dst;
1947 BYTE src[20];
1948 DBSTATUS dst_status;
1949 DBLENGTH dst_len;
1950
1951 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1952 if(FAILED(hr))
1953 {
1954 win_skip("Unable to load oledb conversion library\n");
1955 return;
1956 }
1957
1958 memset(&dst, 0xcc, sizeof(dst));
1959 ((FILETIME *)src)->dwLowDateTime = 0x12345678;
1960 ((FILETIME *)src)->dwHighDateTime = 0x9abcdef0;
1961 hr = IDataConvert_DataConvert(convert, DBTYPE_FILETIME, DBTYPE_FILETIME, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1962 ok(hr == S_OK ||
1963 broken(hr == DB_E_BADBINDINFO), /* win98 */
1964 "got %08x\n", hr);
1965 if(SUCCEEDED(hr))
1966 {
1967 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1968 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1969 ok(dst.dwLowDateTime == 0x12345678, "got %08x\n", dst.dwLowDateTime);
1970 ok(dst.dwHighDateTime == 0x9abcdef0, "got %08x\n", dst.dwHighDateTime);
1971 }
1972
1973 IDataConvert_Release(convert);
1974 }
1975
1976 static void test_converttoui1(void)
1977 {
1978 IDataConvert *convert;
1979 HRESULT hr;
1980 BYTE dst;
1981 BYTE src[20];
1982 DBSTATUS dst_status;
1983 DBLENGTH dst_len;
1984
1985 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1986 if(FAILED(hr))
1987 {
1988 win_skip("Unable to load oledb conversion library\n");
1989 return;
1990 }
1991
1992 dst = 0x12;
1993 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1994 ok(hr == S_OK, "got %08x\n", hr);
1995 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1996 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1997 ok(dst == 0, "got %08x\n", dst);
1998
1999 dst = 0x12;
2000 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2001 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2002 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2003 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2004 ok(dst == 0x12, "got %08x\n", dst);
2005
2006 dst = 0x12;
2007 src[0] = 0x43;
2008 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2009 ok(hr == S_OK, "got %08x\n", hr);
2010 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2011 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2012 ok(dst == 0x43, "got %08x\n", dst);
2013
2014 dst = 0x12;
2015 src[0] = 0xfe;
2016 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2017 ok(hr == S_OK, "got %08x\n", hr);
2018 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2019 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2020 ok(dst == 0xfe, "got %08x\n", dst);
2021
2022 IDataConvert_Release(convert);
2023 }
2024
2025 static void test_converttoui4(void)
2026 {
2027 IDataConvert *convert;
2028 HRESULT hr;
2029 DWORD dst;
2030 BYTE src[20];
2031 DBSTATUS dst_status;
2032 DBLENGTH dst_len;
2033
2034 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2035 if(FAILED(hr))
2036 {
2037 win_skip("Unable to load oledb conversion library\n");
2038 return;
2039 }
2040
2041 dst = 0x12345678;
2042 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2043 ok(hr == S_OK, "got %08x\n", hr);
2044 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2045 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2046 ok(dst == 0, "got %08x\n", dst);
2047
2048 dst = 0x12345678;
2049 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2050 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2051 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2052 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2053 ok(dst == 0x12345678, "got %08x\n", dst);
2054
2055 dst = 0x12345678;
2056 *(DWORD*)src = 0x87654321;
2057 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2058 ok(hr == S_OK, "got %08x\n", hr);
2059 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2060 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2061 ok(dst == 0x87654321, "got %08x\n", dst);
2062
2063 dst = 0x12345678;
2064 *(signed short *)src = 0x4321;
2065 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2066 ok(hr == S_OK, "got %08x\n", hr);
2067 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2068 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2069 ok(dst == 0x4321, "got %08x\n", dst);
2070
2071 dst = 0x12345678;
2072 *(signed short *)src = -1;
2073 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2074 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2075 todo_wine
2076 ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2077 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2078 ok(dst == 0x12345678, "got %08x\n", dst);
2079
2080 IDataConvert_Release(convert);
2081 }
2082
2083 static void test_converttor4(void)
2084 {
2085 IDataConvert *convert;
2086 HRESULT hr;
2087 FLOAT dst;
2088 BYTE src[20];
2089 DBSTATUS dst_status;
2090 DBLENGTH dst_len;
2091
2092 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2093 if(FAILED(hr))
2094 {
2095 win_skip("Unable to load oledb conversion library\n");
2096 return;
2097 }
2098
2099 dst = 1.0;
2100 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2101 ok(hr == S_OK, "got %08x\n", hr);
2102 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2103 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2104 ok(dst == 0.0, "got %f\n", dst);
2105
2106 dst = 1.0;
2107 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2108 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2109 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2110 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2111 ok(dst == 1.0, "got %f\n", dst);
2112
2113 dst = 1.0;
2114 *(signed int*)src = 12345678;
2115 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_R4, 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 %d\n", dst_len);
2119 ok(dst == 12345678.0, "got %f\n", dst);
2120
2121 dst = 1.0;
2122 *(FLOAT *)src = 10.0;
2123 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2124 ok(hr == S_OK, "got %08x\n", hr);
2125 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2126 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2127 ok(dst == 10.0, "got %f\n", dst);
2128
2129 IDataConvert_Release(convert);
2130 }
2131
2132 static void test_converttocy(void)
2133 {
2134 IDataConvert *convert;
2135 HRESULT hr;
2136 CY dst;
2137 BYTE src[20];
2138 DBSTATUS dst_status;
2139 DBLENGTH dst_len;
2140
2141 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2142 if(FAILED(hr))
2143 {
2144 win_skip("Unable to load oledb conversion library\n");
2145 return;
2146 }
2147
2148 dst.int64 = 0xcc;
2149 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2150 ok(hr == S_OK, "got %08x\n", hr);
2151 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2152 ok(dst_len == sizeof(CY), "got %d\n", dst_len);
2153 ok(dst.int64 == 0, "didn't get 0\n");
2154
2155 dst.int64 = 0xcc;
2156 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2157 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2158 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2159 ok(dst_len == sizeof(CY), "got %d\n", dst_len);
2160 ok(dst.int64 == 0xcc, "dst changed\n");
2161
2162 dst.int64 = 0xcc;
2163 *(int*)src = 1234;
2164 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2165 ok(hr == S_OK, "got %08x\n", hr);
2166 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2167 ok(dst_len == sizeof(CY), "got %d\n", dst_len);
2168 ok(dst.int64 == 12340000, "got %d\n", dst.s.Lo);
2169
2170 dst.int64 = 0xcc;
2171 ((CY*)src)->int64 = 1234;
2172 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2173 ok(hr == S_OK, "got %08x\n", hr);
2174 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2175 ok(dst_len == sizeof(CY), "got %d\n", dst_len);
2176 ok(dst.int64 == 1234, "got %d\n", dst.s.Lo);
2177
2178 IDataConvert_Release(convert);
2179 }
2180
2181 static void test_converttoui8(void)
2182 {
2183 IDataConvert *convert;
2184 HRESULT hr;
2185 ULARGE_INTEGER dst;
2186 BYTE src[20];
2187 DBSTATUS dst_status;
2188 DBLENGTH dst_len;
2189
2190 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2191 if(FAILED(hr))
2192 {
2193 win_skip("Unable to load oledb conversion library\n");
2194 return;
2195 }
2196
2197 dst.QuadPart = 0xcc;
2198 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2199 ok(hr == S_OK, "got %08x\n", hr);
2200 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2201 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2202 ok(dst.QuadPart == 0, "got %d\n", (int)dst.QuadPart);
2203
2204 dst.QuadPart = 0xcc;
2205 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2206 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2207 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2208 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2209 ok(dst.QuadPart == 0xcc, "dst changed\n");
2210
2211 dst.QuadPart = 0xcc;
2212 *(int*)src = 1234;
2213 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2214 ok(hr == S_OK, "got %08x\n", hr);
2215 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2216 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2217 ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2218
2219 dst.QuadPart = 0xcc;
2220 *(int*)src = -1234;
2221 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2222 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2223 todo_wine
2224 ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2225 ok(dst_len == sizeof(dst), "got %d\n", dst_len);
2226 ok(dst.QuadPart == 0xcc, "got %d\n", (int)dst.QuadPart);
2227
2228 dst.QuadPart = 0xcc;
2229 ((ULARGE_INTEGER*)src)->QuadPart = 1234;
2230 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_UI8, 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 %d\n", dst_len);
2234 ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2235
2236 IDataConvert_Release(convert);
2237 }
2238
2239 START_TEST(convert)
2240 {
2241 OleInitialize(NULL);
2242 test_dcinfo();
2243 test_canconvert();
2244 test_converttoi2();
2245 test_converttoi4();
2246 test_converttostr();
2247 test_converttobstr();
2248 test_converttowstr();
2249 test_converttobyrefwstr();
2250 test_converttoguid();
2251 test_converttoui1();
2252 test_converttoui4();
2253 test_converttor4();
2254 test_converttofiletime();
2255 test_converttocy();
2256 test_converttoui8();
2257 OleUninitialize();
2258 }
an attempt at megring old patches into wine