?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add AppDefaults app selection to control panel
[wine/gsoc-2012-control.git] / dlls / oledb32 / tests / convert.c
blob1a1ea9affa6f943a14ccfd34d80217837adb4c1f
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 static const 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_len = 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 %ld\n", dst_len);
367 ok(dst == 0, "got %08x\n", dst);
368
369 dst_len = 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 == 0x1234, "got %ld\n", dst_len);
374 ok(dst == 0x1234, "got %08x\n", dst);
375
376 dst_len = 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 %ld\n", dst_len);
382 ok(dst == 0x4321, "got %08x\n", dst);
383
384 dst_len = 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 %ld\n", dst_len);
391 ok(dst == 0x1234, "got %08x\n", dst);
392
393 dst_len = 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 %ld\n", dst_len);
399 ok(dst == 0x4321, "got %08x\n", dst);
400
401 dst_len = 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 %ld\n", dst_len);
407 ok(dst == 11, "got %08x\n", dst);
408
409 dst_len = 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 %ld\n", dst_len);
415 ok(dst == -11, "got %08x\n", dst);
416
417 dst_len = 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 %ld\n", dst_len);
423 ok(dst == 11, "got %08x\n", dst);
424
425 dst_len = 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 %ld\n", dst_len);
431 ok(dst == 11, "got %08x\n", dst);
432
433 dst_len = 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 %ld\n", dst_len);
439 ok(dst == 11, "got %08x\n", dst);
440
441 dst_len = 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 %ld\n", dst_len);
448 ok(dst == 10, "got %08x\n", dst);
449 SysFreeString(b);
450
451 dst_len = 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 == 0x1234, "got %ld\n", dst_len);
457 ok(dst == 0x1234, "got %08x\n", dst);
458
459 dst_len = 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 %ld\n", dst_len);
465 ok(dst == -1, "got %08x\n", dst);
466
467 dst_len = 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 %ld\n", dst_len);
473 ok(dst == 0, "got %08x\n", dst);
474
475 dst_len = 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 ok(hr == S_OK, "got %08x\n", hr);
480 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
481 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
482 ok(dst == 0x4321, "got %08x\n", dst);
483
484 dst_len = dst = 0x1234;
485 memset(src, 0, sizeof(DECIMAL));
486 ((DECIMAL*)src)->u1.Lo64 = 0x4321;
487 hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
488 ok(hr == S_OK, "got %08x\n", hr);
489 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
490 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
491 ok(dst == 0x4321, "got %08x\n", dst);
492
493 dst_len = dst = 0x1234;
494 *(signed char*)src = 0xab;
495 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
496 ok(hr == S_OK, "got %08x\n", hr);
497 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
498 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
499 ok(dst == (signed short)0xffab, "got %08x\n", dst);
500
501 dst_len = dst = 0x1234;
502 *(BYTE*)src = 0xab;
503 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
504 ok(hr == S_OK, "got %08x\n", hr);
505 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
506 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
507 ok(dst == 0xab, "got %08x\n", dst);
508
509 dst_len = dst = 0x1234;
510 *(WORD*)src = 0x4321;
511 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
512 ok(hr == S_OK, "got %08x\n", hr);
513 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
514 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
515 ok(dst == 0x4321, "got %08x\n", dst);
516
517 dst_len = dst = 0x1234;
518 *(WORD*)src = 0xabcd;
519 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
520 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
521 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
522 todo_wine
523 ok(broken(dst_len == sizeof(dst)) || dst_len == 0x1234 /* W2K+ */, "got %ld\n", dst_len);
524 ok(dst == 0x1234, "got %08x\n", dst);
525
526 dst_len = dst = 0x1234;
527 *(DWORD*)src = 0xabcd1234;
528 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
529 todo_wine
530 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
531 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
532 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
533 ok(dst == 0x1234, "got %08x\n", dst);
534
535 dst_len = dst = 0x1234;
536 *(DWORD*)src = 0x1234abcd;
537 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
538 todo_wine
539 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
540 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
541 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
542 ok(dst == 0x1234, "got %08x\n", dst);
543
544 dst_len = dst = 0x1234;
545 *(DWORD*)src = 0x4321;
546 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
547 ok(hr == S_OK, "got %08x\n", hr);
548 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
549 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
550 ok(dst == 0x4321, "got %08x\n", dst);
551
552 dst_len = dst = 0x1234;
553 ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
554 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
555 ok(hr == DB_E_ERRORSOCCURRED ||
556 broken(hr == DB_E_UNSUPPORTEDCONVERSION), /* win98 */
557 "got %08x\n", hr);
558 if(hr != DB_E_UNSUPPORTEDCONVERSION) /* win98 doesn't support I8/UI8 */
559 {
560 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
561 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
562 ok(dst == 0x1234, "got %08x\n", dst);
563
564 dst_len = dst = 0x1234;
565 ((LARGE_INTEGER*)src)->QuadPart = 0x4321;
566 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
567 ok(hr == S_OK, "got %08x\n", hr);
568 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
569 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
570 ok(dst == 0x4321, "got %08x\n", dst);
571
572 dst_len = dst = 0x1234;
573 ((ULARGE_INTEGER*)src)->QuadPart = 0x4321;
574 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
575 ok(hr == S_OK, "got %08x\n", hr);
576 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
577 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
578 ok(dst == 0x4321, "got %08x\n", dst);
579 }
580
581 dst_len = dst = 0x1234;
582 strcpy((char *)src, "10");
583 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
584 ok(hr == S_OK, "got %08x\n", hr);
585 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
586 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
587 ok(dst == 10, "got %08x\n", dst);
588
589 dst_len = dst = 0x1234;
590 strcpy((char *)src, "10");
591 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
592 ok(hr == S_OK, "got %08x\n", hr);
593 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
594 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
595 ok(dst == 10, "got %08x\n", dst);
596
597 dst_len = dst = 0x1234;
598 memcpy(src, ten, sizeof(ten));
599 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
600 ok(hr == S_OK, "got %08x\n", hr);
601 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
602 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
603 ok(dst == 10, "got %08x\n", dst);
604
605 dst_len = dst = 0x1234;
606 memcpy(src, ten, sizeof(ten));
607 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
608 ok(hr == S_OK, "got %08x\n", hr);
609 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
610 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
611 ok(dst == 10, "got %08x\n", dst);
612
613 /* */
614 dst_len = dst = 0x1234;
615 *(WORD*)src = 0x4321;
616 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_UI2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
617 ok(hr == S_OK, "got %08x\n", hr);
618 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
619 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
620 ok(dst == 0x4321, "got %08x\n", dst);
621
622 dst_len = dst = 0x1234;
623 *(DWORD*)src = 0xabcd1234;
624 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
625 todo_wine
626 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
627 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
628 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
629 ok(dst == 0x1234, "got %08x\n", dst);
630
631 dst_len = dst = 0x1234;
632 *(DWORD*)src = 0x1234abcd;
633 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
634 todo_wine
635 ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
636 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
637 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
638 ok(dst == 0x1234, "got %08x\n", dst);
639
640 dst_len = dst = 0x1234;
641 *(DWORD*)src = 0x4321;
642 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
643 ok(hr == S_OK, "got %08x\n", hr);
644 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
645 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
646 ok(dst == 0x4321, "got %08x\n", dst);
647
648 dst_len = dst = 0x1234;
649 memcpy(src, ten, sizeof(ten));
650 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_UI2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
651 ok(hr == S_OK, "got %08x\n", hr);
652 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
653 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
654 ok(dst == 10, "got %08x\n", dst);
655
656 IDataConvert_Release(convert);
657 }
658
659 static void test_converttoi4(void)
660 {
661 IDataConvert *convert;
662 HRESULT hr;
663 INT i4;
664 BYTE src[20];
665 DBSTATUS dst_status;
666 DBLENGTH dst_len;
667 static const WCHAR ten[] = {'1','0',0};
668 BSTR b;
669
670 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
671 if(FAILED(hr))
672 {
673 win_skip("Unable to load oledb conversion library\n");
674 return;
675 }
676
677 i4 = 0x12345678;
678 dst_len = 0x1234;
679 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
680 ok(hr == S_OK, "got %08x\n", hr);
681 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
682 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
683 ok(i4 == 0, "got %08x\n", i4);
684
685 i4 = 0x12345678;
686 dst_len = 0x1234;
687 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
688 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
689 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
690 ok(dst_len == 0x1234, "got %ld\n", dst_len);
691 ok(i4 == 0x12345678, "got %08x\n", i4);
692
693 i4 = 0x12345678;
694 *(short *)src = 0x4321;
695 dst_len = 0x1234;
696 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
697 ok(hr == S_OK, "got %08x\n", hr);
698 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
699 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
700 ok(i4 == 0x4321, "got %08x\n", i4);
701
702 i4 = 0x12345678;
703 *(int *)src = 0x4321cafe;
704 dst_len = 0x1234;
705 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
706 ok(hr == S_OK, "got %08x\n", hr);
707 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
708 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
709 ok(i4 == 0x4321cafe, "got %08x\n", i4);
710
711 i4 = 0x12345678;
712 *(FLOAT *)src = 10.75;
713 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
714 ok(hr == S_OK, "got %08x\n", hr);
715 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
716 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
717 ok(i4 == 11, "got %08x\n", i4);
718
719 i4 = 0x12345678;
720 *(FLOAT *)src = -10.75;
721 dst_len = 0x1234;
722 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
723 ok(hr == S_OK, "got %08x\n", hr);
724 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
725 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
726 ok(i4 == -11, "got %08x\n", i4);
727
728 i4 = 0x12345678;
729 *(double *)src = 10.75;
730 dst_len = 0x1234;
731 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
732 ok(hr == S_OK, "got %08x\n", hr);
733 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
734 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
735 ok(i4 == 11, "got %08x\n", i4);
736
737 i4 = 0x12345678;
738 ((LARGE_INTEGER *)src)->QuadPart = 107500;
739 dst_len = 0x1234;
740 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
741 ok(hr == S_OK, "got %08x\n", hr);
742 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
743 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
744 ok(i4 == 11, "got %08x\n", i4);
745
746 i4 = 0x12345678;
747 *(DATE *)src = 10.7500;
748 dst_len = 0x1234;
749 hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
750 ok(hr == S_OK, "got %08x\n", hr);
751 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
752 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
753 ok(i4 == 11, "got %08x\n", i4);
754
755 i4 = 0x12345678;
756 b = SysAllocString(ten);
757 *(BSTR *)src = b;
758 dst_len = 0x1234;
759 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
760 ok(hr == S_OK, "got %08x\n", hr);
761 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
762 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
763 ok(i4 == 10, "got %08x\n", i4);
764 SysFreeString(b);
765
766 i4 = 0x12345678;
767 *(SCODE *)src = 0x4321cafe;
768 dst_len = 0x1234;
769 hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
770 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
771 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
772 ok(dst_len == 0x1234, "got %ld\n", dst_len);
773 ok(i4 == 0x12345678, "got %08x\n", i4);
774
775 i4 = 0x12345678;
776 *(VARIANT_BOOL *)src = VARIANT_TRUE;
777 dst_len = 0x1234;
778 hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
779 ok(hr == S_OK, "got %08x\n", hr);
780 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
781 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
782 ok(i4 == 0xffffffff, "got %08x\n", i4);
783
784 i4 = 0x12345678;
785 *(VARIANT_BOOL *)src = VARIANT_FALSE;
786 dst_len = 0x1234;
787 hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
788 ok(hr == S_OK, "got %08x\n", hr);
789 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
790 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
791 ok(i4 == 0, "got %08x\n", i4);
792
793 i4 = 0x12345678;
794 V_VT((VARIANT*)src) = VT_I2;
795 V_I2((VARIANT*)src) = 0x1234;
796 dst_len = 0x1234;
797 hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, 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 %ld\n", dst_len);
801 ok(i4 == 0x1234, "got %08x\n", i4);
802
803 i4 = 0x12345678;
804 memset(src, 0, sizeof(DECIMAL));
805 ((DECIMAL*)src)->u1.Lo64 = 0x1234;
806 dst_len = 0x1234;
807 hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
808 ok(hr == S_OK, "got %08x\n", hr);
809 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
810 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
811 ok(i4 == 0x1234, "got %08x\n", i4);
812
813 i4 = 0x12345678;
814 *(signed char*)src = 0xab;
815 dst_len = 0x1234;
816 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
817 ok(hr == S_OK, "got %08x\n", hr);
818 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
819 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
820 ok(i4 == 0xffffffab, "got %08x\n", i4);
821
822 i4 = 0x12345678;
823 *(BYTE*)src = 0xab;
824 dst_len = 0x1234;
825 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
826 ok(hr == S_OK, "got %08x\n", hr);
827 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
828 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
829 ok(i4 == 0xab, "got %08x\n", i4);
830
831 i4 = 0x12345678;
832 *(WORD*)src = 0xabcd;
833 dst_len = 0x1234;
834 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
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 %ld\n", dst_len);
838 ok(i4 == 0xabcd, "got %08x\n", i4);
839
840 i4 = 0x12345678;
841 *(DWORD*)src = 0xabcd1234;
842 dst_len = 0x1234;
843 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
844 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
845 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
846 todo_wine
847 ok(broken(dst_len == sizeof(i4)) || dst_len == 0x1234 /* W2K+ */, "got %ld\n", dst_len);
848 ok(i4 == 0x12345678, "got %08x\n", i4);
849
850 i4 = 0x12345678;
851 *(DWORD*)src = 0x1234abcd;
852 dst_len = 0x1234;
853 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
854 ok(hr == S_OK, "got %08x\n", hr);
855 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
856 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
857 ok(i4 == 0x1234abcd, "got %08x\n", i4);
858
859 i4 = 0x12345678;
860 ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
861 dst_len = 0x1234;
862 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
863 ok(hr == S_OK ||
864 broken(hr == DB_E_UNSUPPORTEDCONVERSION), /* win98 */
865 "got %08x\n", hr);
866 if(hr != DB_E_UNSUPPORTEDCONVERSION) /* win98 doesn't support I8/UI8 */
867 {
868 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
869 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
870 ok(i4 == 0x1234abcd, "got %08x\n", i4);
871
872 i4 = 0x12345678;
873 ((ULARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
874 dst_len = 0x1234;
875 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
876 ok(hr == S_OK, "got %08x\n", hr);
877 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
878 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
879 ok(i4 == 0x1234abcd, "got %08x\n", i4);
880 }
881
882 i4 = 0x12345678;
883 strcpy((char *)src, "10");
884 dst_len = 0x1234;
885 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 2, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
886 ok(hr == S_OK, "got %08x\n", hr);
887 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
888 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
889 ok(i4 == 10, "got %08x\n", i4);
890
891 i4 = 0x12345678;
892 strcpy((char *)src, "10");
893 dst_len = 0x1234;
894 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
895 ok(hr == S_OK, "got %08x\n", hr);
896 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
897 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
898 ok(i4 == 10, "got %08x\n", i4);
899
900 i4 = 0x12345678;
901 memcpy(src, ten, sizeof(ten));
902 dst_len = 0x1234;
903 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 4, &dst_len, src, &i4, sizeof(i4), 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(i4), "got %ld\n", dst_len);
907 ok(i4 == 10, "got %08x\n", i4);
908
909 i4 = 0x12345678;
910 memcpy(src, ten, sizeof(ten));
911 dst_len = 0x1234;
912 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
913 ok(hr == S_OK, "got %08x\n", hr);
914 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
915 ok(dst_len == sizeof(i4), "got %ld\n", dst_len);
916 ok(i4 == 10, "got %08x\n", i4);
917
918 IDataConvert_Release(convert);
919 }
920
921 static void test_converttobstr(void)
922 {
923 IDataConvert *convert;
924 HRESULT hr;
925 BSTR dst;
926 BYTE src[20];
927 DBSTATUS dst_status;
928 DBLENGTH dst_len;
929 static const WCHAR ten[] = {'1','0',0};
930 BSTR b;
931
932 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
933 if(FAILED(hr))
934 {
935 win_skip("Unable to load oledb conversion library\n");
936 return;
937 }
938
939 dst_len = 0x1234;
940 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
941 ok(hr == S_OK, "got %08x\n", hr);
942 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
943 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
944 ok(dst != NULL, "got %p\n", dst);
945 ok(SysStringLen(dst) == 0, "got %d\n", SysStringLen(dst));
946 SysFreeString(dst);
947
948 dst = (void*)0x1234;
949 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
950 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
951 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
952 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
953 ok(dst == (void*)0x1234, "got %p\n", dst);
954
955 *(short *)src = 4321;
956 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
957 ok(hr == S_OK, "got %08x\n", hr);
958 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
959 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
960 ok(dst != NULL, "got %p\n", dst);
961 ok(SysStringLen(dst) == 4, "got %d\n", SysStringLen(dst));
962 SysFreeString(dst);
963
964 b = SysAllocString(ten);
965 *(BSTR *)src = b;
966 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
967 ok(hr == S_OK, "got %08x\n", hr);
968 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
969 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
970 ok(dst != NULL, "got %p\n", dst);
971 ok(dst != b, "got %p src %p\n", dst, b);
972 ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
973 SysFreeString(dst);
974 SysFreeString(b);
975
976 IDataConvert_Release(convert);
977 }
978
979 static void test_converttowstr(void)
980 {
981 IDataConvert *convert;
982 HRESULT hr;
983 WCHAR dst[100];
984 BYTE src[20];
985 DBSTATUS dst_status;
986 DBLENGTH dst_len;
987 static const WCHAR ten[] = {'1','0',0};
988 static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
989 static const WCHAR guid_str[] = {
990 '{','0','C','7','3','3','A','8','D','-','2','A','1','C','-','1','1','C','E','-',
991 'A','D','E','5','-','0','0','A','A','0','0','4','4','7','7','3','D','}',0};
992 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 };
993 static const WCHAR hexpacked_w[] = {'W','i','n','e', 0 };
994 BSTR b;
995
996 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
997 if(FAILED(hr))
998 {
999 win_skip("Unable to load oledb conversion library\n");
1000 return;
1001 }
1002
1003
1004 memset(dst, 0xcc, sizeof(dst));
1005 dst_len = 0x1234;
1006 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1007 ok(hr == S_OK, "got %08x\n", hr);
1008 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1009 ok(dst_len == 0, "got %ld\n", dst_len);
1010 ok(dst[0] == 0, "got %02x\n", dst[0]);
1011 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1012
1013 memset(dst, 0xcc, sizeof(dst));
1014 dst_len = 0x1234;
1015 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1016 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1017 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1018 ok(dst_len == 0x1234, "got %ld\n", dst_len);
1019 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1020
1021 *(short *)src = 4321;
1022 dst_len = 0x1234;
1023 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1024 ok(hr == S_OK, "got %08x\n", hr);
1025 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1026 ok(dst_len == 8, "got %ld\n", dst_len);
1027 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1028
1029 *(short *)src = 4321;
1030 memset(dst, 0xcc, sizeof(dst));
1031 dst_len = 0x1234;
1032 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1033 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1034 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1035 ok(dst_len == 8, "got %ld\n", dst_len);
1036 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1037
1038 *(short *)src = 4321;
1039 memset(dst, 0xcc, sizeof(dst));
1040 dst_len = 0x1234;
1041 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1042 ok(hr == S_OK, "got %08x\n", hr);
1043 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1044 ok(dst_len == 8, "got %ld\n", dst_len);
1045 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1046
1047 *(short *)src = 4321;
1048 memset(dst, 0xcc, sizeof(dst));
1049 dst_len = 0x1234;
1050 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1051 ok(hr == S_OK, "got %08x\n", hr);
1052 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1053 ok(dst_len == 8, "got %ld\n", dst_len);
1054 ok(dst[0] == '4', "got %02x\n", dst[0]);
1055 ok(dst[1] == 0, "got %02x\n", dst[1]);
1056 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1057
1058 *(short *)src = 4321;
1059 memset(dst, 0xcc, sizeof(dst));
1060 dst_len = 0x1234;
1061 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1062 ok(hr == S_OK, "got %08x\n", hr);
1063 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1064 ok(dst_len == 8, "got %ld\n", dst_len);
1065 ok(dst[0] == 0, "got %02x\n", dst[0]);
1066 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1067
1068 *(short *)src = 4321;
1069 memset(dst, 0xcc, sizeof(dst));
1070 dst_len = 0x1234;
1071 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1072 ok(hr == S_OK, "got %08x\n", hr);
1073 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1074 ok(dst_len == 8, "got %ld\n", dst_len);
1075 ok(dst[0] == '4', "got %02x\n", dst[0]);
1076 ok(dst[1] == '3', "got %02x\n", dst[1]);
1077 ok(dst[2] == '2', "got %02x\n", dst[2]);
1078 ok(dst[3] == 0, "got %02x\n", dst[3]);
1079 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1080
1081
1082
1083 *(int *)src = 4321;
1084 dst_len = 0x1234;
1085 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 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 %ld\n", dst_len);
1089 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1090
1091 *(int *)src = 4321;
1092 memset(dst, 0xcc, sizeof(dst));
1093 dst_len = 0x1234;
1094 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1095 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1096 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1097 ok(dst_len == 8, "got %ld\n", dst_len);
1098 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1099
1100 *(int *)src = 4321;
1101 memset(dst, 0xcc, sizeof(dst));
1102 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1103 ok(hr == S_OK, "got %08x\n", hr);
1104 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1105 ok(dst_len == 8, "got %ld\n", dst_len);
1106 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1107
1108 *(int *)src = 4321;
1109 memset(dst, 0xcc, sizeof(dst));
1110 dst_len = 0x1234;
1111 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1112 ok(hr == S_OK, "got %08x\n", hr);
1113 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1114 ok(dst_len == 8, "got %ld\n", dst_len);
1115 ok(dst[0] == '4', "got %02x\n", dst[0]);
1116 ok(dst[1] == 0, "got %02x\n", dst[1]);
1117 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1118
1119 *(int *)src = 4321;
1120 memset(dst, 0xcc, sizeof(dst));
1121 dst_len = 0x1234;
1122 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1123 ok(hr == S_OK, "got %08x\n", hr);
1124 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1125 ok(dst_len == 8, "got %ld\n", dst_len);
1126 ok(dst[0] == 0, "got %02x\n", dst[0]);
1127 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1128
1129 *(int *)src = 4321;
1130 memset(dst, 0xcc, sizeof(dst));
1131 dst_len = 0x1234;
1132 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1133 ok(hr == S_OK, "got %08x\n", hr);
1134 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1135 ok(dst_len == 8, "got %ld\n", dst_len);
1136 ok(dst[0] == '4', "got %02x\n", dst[0]);
1137 ok(dst[1] == '3', "got %02x\n", dst[1]);
1138 ok(dst[2] == '2', "got %02x\n", dst[2]);
1139 ok(dst[3] == 0, "got %02x\n", dst[3]);
1140 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1141
1142
1143
1144 *(float *)src = 4321;
1145 dst_len = 0x1234;
1146 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1147 ok(hr == S_OK, "got %08x\n", hr);
1148 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1149 ok(dst_len == 8, "got %ld\n", dst_len);
1150 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1151
1152 *(float *)src = 4321;
1153 memset(dst, 0xcc, sizeof(dst));
1154 dst_len = 0x1234;
1155 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1156 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1157 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1158 ok(dst_len == 8, "got %ld\n", dst_len);
1159 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1160
1161 *(float *)src = 4321;
1162 memset(dst, 0xcc, sizeof(dst));
1163 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1164 ok(hr == S_OK, "got %08x\n", hr);
1165 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1166 ok(dst_len == 8, "got %ld\n", dst_len);
1167 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1168
1169 *(float *)src = 4321;
1170 memset(dst, 0xcc, sizeof(dst));
1171 dst_len = 0x1234;
1172 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1173 ok(hr == S_OK, "got %08x\n", hr);
1174 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1175 ok(dst_len == 8, "got %ld\n", dst_len);
1176 ok(dst[0] == '4', "got %02x\n", dst[0]);
1177 ok(dst[1] == 0, "got %02x\n", dst[1]);
1178 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1179
1180 *(float *)src = 4321;
1181 memset(dst, 0xcc, sizeof(dst));
1182 dst_len = 0x1234;
1183 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1184 ok(hr == S_OK, "got %08x\n", hr);
1185 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1186 ok(dst_len == 8, "got %ld\n", dst_len);
1187 ok(dst[0] == 0, "got %02x\n", dst[0]);
1188 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1189
1190 *(float *)src = 4321;
1191 memset(dst, 0xcc, sizeof(dst));
1192 dst_len = 0x1234;
1193 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1194 ok(hr == S_OK, "got %08x\n", hr);
1195 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1196 ok(dst_len == 8, "got %ld\n", dst_len);
1197 ok(dst[0] == '4', "got %02x\n", dst[0]);
1198 ok(dst[1] == '3', "got %02x\n", dst[1]);
1199 ok(dst[2] == '2', "got %02x\n", dst[2]);
1200 ok(dst[3] == 0, "got %02x\n", dst[3]);
1201 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1202
1203
1204
1205 *(double *)src = 4321;
1206 dst_len = 0x1234;
1207 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1208 ok(hr == S_OK, "got %08x\n", hr);
1209 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1210 ok(dst_len == 8, "got %ld\n", dst_len);
1211 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1212
1213 *(double *)src = 4321;
1214 memset(dst, 0xcc, sizeof(dst));
1215 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1216 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1217 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1218 ok(dst_len == 8, "got %ld\n", dst_len);
1219 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1220
1221 *(double *)src = 4321;
1222 memset(dst, 0xcc, sizeof(dst));
1223 dst_len = 0x1234;
1224 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1225 ok(hr == S_OK, "got %08x\n", hr);
1226 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1227 ok(dst_len == 8, "got %ld\n", dst_len);
1228 ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1229
1230 *(double *)src = 4321;
1231 memset(dst, 0xcc, sizeof(dst));
1232 dst_len = 0x1234;
1233 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1234 ok(hr == S_OK, "got %08x\n", hr);
1235 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1236 ok(dst_len == 8, "got %ld\n", dst_len);
1237 ok(dst[0] == '4', "got %02x\n", dst[0]);
1238 ok(dst[1] == 0, "got %02x\n", dst[1]);
1239 ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1240
1241 *(double *)src = 4321;
1242 memset(dst, 0xcc, sizeof(dst));
1243 dst_len = 0x1234;
1244 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1245 ok(hr == S_OK, "got %08x\n", hr);
1246 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1247 ok(dst_len == 8, "got %ld\n", dst_len);
1248 ok(dst[0] == 0, "got %02x\n", dst[0]);
1249 ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1250
1251 *(double *)src = 4321;
1252 memset(dst, 0xcc, sizeof(dst));
1253 dst_len = 0x1234;
1254 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1255 ok(hr == S_OK, "got %08x\n", hr);
1256 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1257 ok(dst_len == 8, "got %ld\n", dst_len);
1258 ok(dst[0] == '4', "got %02x\n", dst[0]);
1259 ok(dst[1] == '3', "got %02x\n", dst[1]);
1260 ok(dst[2] == '2', "got %02x\n", dst[2]);
1261 ok(dst[3] == 0, "got %02x\n", dst[3]);
1262 ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1263
1264
1265
1266 memset(src, 0, sizeof(src));
1267 ((CY*)src)->int64 = 43210000;
1268 memset(dst, 0xcc, sizeof(dst));
1269 dst_len = 0x1234;
1270 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_WSTR, 0, &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 == 8, "got %ld\n", dst_len);
1274 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1275
1276
1277
1278 memset(src, 0, sizeof(src));
1279 *(signed char *)src = 10;
1280 dst_len = 0x1234;
1281 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1282 ok(hr == S_OK, "got %08x\n", hr);
1283 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1284 ok(dst_len == 4, "got %ld\n", dst_len);
1285 ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1286
1287 memset(src, 0, sizeof(src));
1288 *(unsigned char *)src = 10;
1289 dst_len = 0x1234;
1290 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1291 ok(hr == S_OK, "got %08x\n", hr);
1292 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1293 ok(dst_len == 4, "got %ld\n", dst_len);
1294 ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1295
1296 memset(src, 0, sizeof(src));
1297 *(unsigned short *)src = 4321;
1298 dst_len = 0x1234;
1299 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1300 ok(hr == S_OK, "got %08x\n", hr);
1301 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1302 ok(dst_len == 8, "got %ld\n", dst_len);
1303 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1304
1305 memset(src, 0, sizeof(src));
1306 *(unsigned int *)src = 4321;
1307 dst_len = 0x1234;
1308 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1309 ok(hr == S_OK, "got %08x\n", hr);
1310 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1311 ok(dst_len == 8, "got %ld\n", dst_len);
1312 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1313
1314 memset(src, 0, sizeof(src));
1315 ((LARGE_INTEGER*)src)->QuadPart = 4321;
1316 dst_len = 0x1234;
1317 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1318 ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1319 ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1320 ok(broken(dst_len == 0x1234) || dst_len == 8 /* W2K+ */, "got %ld\n", dst_len);
1321 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1322
1323 memset(src, 0, sizeof(src));
1324 ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1325 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1326 ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1327 ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1328 ok(broken(dst_len == 0x1234) || dst_len == 8 /* W2K+ */, "got %ld\n", dst_len);
1329 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1330
1331
1332
1333 memset(src, 0, sizeof(src));
1334 memcpy(src, &IID_IDataConvert, sizeof(GUID));
1335 memset(dst, 0xcc, sizeof(dst));
1336 dst_len = 0x1234;
1337 hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1338 ok(hr == S_OK, "got %08x\n", hr);
1339 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1340 ok(dst_len == 76, "got %ld\n", dst_len);
1341 ok(!lstrcmpW(dst, guid_str), "got %s\n", wine_dbgstr_w(dst));
1342
1343
1344
1345 b = SysAllocString(ten);
1346 *(BSTR *)src = b;
1347 dst_len = 0x1234;
1348 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1349 ok(hr == S_OK, "got %08x\n", hr);
1350 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1351 ok(dst_len == 4, "got %ld\n", dst_len);
1352 ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1353 SysFreeString(b);
1354
1355 memcpy(src, ten, sizeof(ten));
1356 dst_len = 0x1234;
1357 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1358 ok(hr == S_OK, "got %08x\n", hr);
1359 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1360 ok(dst_len == 2, "got %ld\n", dst_len);
1361 ok(dst[0] == '1', "got %02x\n", dst[0]);
1362 ok(dst[1] == 0, "got %02x\n", dst[1]);
1363
1364 memcpy(src, ten, sizeof(ten));
1365 dst_len = 0x1234;
1366 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1367 ok(hr == S_OK, "got %08x\n", hr);
1368 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1369 ok(dst_len == 4, "got %ld\n", dst_len);
1370 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1371
1372 memcpy(src, ten, sizeof(ten));
1373 dst_len = 0x1234;
1374 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1375 ok(hr == S_OK, "got %08x\n", hr);
1376 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1377 ok(dst_len == 4, "got %ld\n", dst_len);
1378 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1379
1380
1381
1382 /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1383 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1384 memset(dst, 0xcc, sizeof(dst));
1385 dst_len = 0x1234;
1386 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1387 ok(hr == S_OK, "got %08x\n", hr);
1388 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1389 ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1390 ok(!lstrcmpW(hexunpacked_w, dst), "got %s\n", wine_dbgstr_w(dst));
1391 ok(dst[sizeof(hexpacked_w)/sizeof(WCHAR) * 4 + 1] == 0xcccc, "clobbered buffer\n");
1392
1393 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1394 memset(dst, 0xcc, sizeof(dst));
1395 dst_len = 0x1234;
1396 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1397 ok(hr == S_OK, "got %08x\n", hr);
1398 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1399 ok(dst_len == 0, "got %ld\n", dst_len);
1400 ok(dst[0] == 0, "not null terminated\n");
1401 ok(dst[1] == 0xcccc, "clobbered buffer\n");
1402
1403 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1404 memset(dst, 0xcc, sizeof(dst));
1405 dst_len = 0x1234;
1406 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1407 ok(hr == S_OK, "got %08x\n", hr);
1408 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1409 ok(dst_len == 2 * sizeof(WCHAR) * 4, "got %ld\n", dst_len);
1410 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1411 ok(dst[2 * 4] == 0, "not null terminated\n");
1412 ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1413
1414 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1415 memset(dst, 0xcc, sizeof(dst));
1416 dst_len = 0x1234;
1417 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);
1418 ok(hr == S_OK, "got %08x\n", hr);
1419 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1420 ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1421 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1422 ok(dst[2 * 4] == 0, "not null terminated\n");
1423 ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1424
1425 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1426 memset(dst, 0xcc, sizeof(dst));
1427 dst_len = 0x1234;
1428 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);
1429 ok(hr == S_OK, "got %08x\n", hr);
1430 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1431 ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1432 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1433 ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1434 ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1435
1436 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1437 memset(dst, 0xcc, sizeof(dst));
1438 dst_len = 0x1234;
1439 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);
1440 ok(hr == S_OK, "got %08x\n", hr);
1441 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1442 ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1443 ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1444 ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1445 ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1446
1447 memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1448 memset(dst, 0xcc, sizeof(dst));
1449 dst_len = 0x1234;
1450 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1451 ok(hr == S_OK, "got %08x\n", hr);
1452 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1453 ok(dst_len == 0, "got %ld\n", dst_len);
1454 ok(dst[0] == 0, "not null terminated\n");
1455 ok(dst[1] == 0xcccc, "clobbered buffer\n");
1456
1457
1458 IDataConvert_Release(convert);
1459 }
1460
1461 static void test_converttostr(void)
1462 {
1463 IDataConvert *convert;
1464 HRESULT hr;
1465 char dst[100];
1466 BYTE src[64];
1467 DBSTATUS dst_status;
1468 DBLENGTH dst_len;
1469 static const WCHAR ten[] = {'1','0',0};
1470 static const char ten_a[] = "10";
1471 static const char fourthreetwoone[] = "4321";
1472 static const char guid_str[] = "{0C733A8D-2A1C-11CE-ADE5-00AA0044773D}";
1473 static const char hexunpacked_a[] = "57696E6500";
1474 static const char hexpacked_a[] = "Wine";
1475 BSTR b;
1476
1477 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1478 if(FAILED(hr))
1479 {
1480 win_skip("Unable to load oledb conversion library\n");
1481 return;
1482 }
1483
1484
1485 memset(dst, 0xcc, sizeof(dst));
1486 dst_len = 0x1234;
1487 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1488 ok(hr == S_OK, "got %08x\n", hr);
1489 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1490 ok(dst_len == 0, "got %ld\n", dst_len);
1491 ok(dst[0] == 0, "got %02x\n", dst[0]);
1492 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1493
1494 memset(dst, 0xcc, sizeof(dst));
1495 dst_len = 0x1234;
1496 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1497 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1498 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1499 ok(dst_len == 0x1234, "got %ld\n", dst_len);
1500 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1501
1502 *(short *)src = 4321;
1503 dst_len = 0x1234;
1504 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1505 ok(hr == S_OK, "got %08x\n", hr);
1506 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1507 ok(dst_len == 4, "got %ld\n", dst_len);
1508 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1509
1510 *(short *)src = 4321;
1511 memset(dst, 0xcc, sizeof(dst));
1512 dst_len = 0x1234;
1513 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1514 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1515 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1516 ok(dst_len == 4, "got %ld\n", dst_len);
1517 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1518
1519 *(short *)src = 4321;
1520 memset(dst, 0xcc, sizeof(dst));
1521 dst_len = 0x1234;
1522 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1523 ok(hr == S_OK, "got %08x\n", hr);
1524 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1525 ok(dst_len == 4, "got %ld\n", dst_len);
1526 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1527
1528 *(short *)src = 4321;
1529 memset(dst, 0xcc, sizeof(dst));
1530 dst_len = 0x1234;
1531 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, 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 %ld\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 *(short *)src = 4321;
1540 memset(dst, 0xcc, sizeof(dst));
1541 dst_len = 0x1234;
1542 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1543 ok(hr == S_OK, "got %08x\n", hr);
1544 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1545 ok(dst_len == 4, "got %ld\n", dst_len);
1546 ok(dst[0] == 0, "got %02x\n", dst[0]);
1547 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1548
1549 *(short *)src = 4321;
1550 memset(dst, 0xcc, sizeof(dst));
1551 dst_len = 0x1234;
1552 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1553 ok(hr == S_OK, "got %08x\n", hr);
1554 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1555 ok(dst_len == 4, "got %ld\n", dst_len);
1556 ok(dst[0] == '4', "got %02x\n", dst[0]);
1557 ok(dst[1] == '3', "got %02x\n", dst[1]);
1558 ok(dst[2] == '2', "got %02x\n", dst[2]);
1559 ok(dst[3] == 0, "got %02x\n", dst[3]);
1560 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1561
1562
1563 *(int *)src = 4321;
1564 dst_len = 0x1234;
1565 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1566 ok(hr == S_OK, "got %08x\n", hr);
1567 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1568 ok(dst_len == 4, "got %ld\n", dst_len);
1569 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1570
1571 *(int *)src = 4321;
1572 memset(dst, 0xcc, sizeof(dst));
1573 dst_len = 0x1234;
1574 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1575 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1576 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1577 ok(dst_len == 4, "got %ld\n", dst_len);
1578 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1579
1580 *(int *)src = 4321;
1581 memset(dst, 0xcc, sizeof(dst));
1582 dst_len = 0x1234;
1583 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1584 ok(hr == S_OK, "got %08x\n", hr);
1585 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1586 ok(dst_len == 4, "got %ld\n", dst_len);
1587 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1588
1589 *(int *)src = 4321;
1590 memset(dst, 0xcc, sizeof(dst));
1591 dst_len = 0x1234;
1592 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1593 ok(hr == S_OK, "got %08x\n", hr);
1594 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1595 ok(dst_len == 4, "got %ld\n", dst_len);
1596 ok(dst[0] == '4', "got %02x\n", dst[0]);
1597 ok(dst[1] == 0, "got %02x\n", dst[1]);
1598 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1599
1600 *(int *)src = 4321;
1601 memset(dst, 0xcc, sizeof(dst));
1602 dst_len = 0x1234;
1603 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1604 ok(hr == S_OK, "got %08x\n", hr);
1605 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1606 ok(dst_len == 4, "got %ld\n", dst_len);
1607 ok(dst[0] == 0, "got %02x\n", dst[0]);
1608 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1609
1610 *(int *)src = 4321;
1611 memset(dst, 0xcc, sizeof(dst));
1612 dst_len = 0x1234;
1613 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1614 ok(hr == S_OK, "got %08x\n", hr);
1615 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1616 ok(dst_len == 4, "got %ld\n", dst_len);
1617 ok(dst[0] == '4', "got %02x\n", dst[0]);
1618 ok(dst[1] == '3', "got %02x\n", dst[1]);
1619 ok(dst[2] == '2', "got %02x\n", dst[2]);
1620 ok(dst[3] == 0, "got %02x\n", dst[3]);
1621 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1622
1623
1624 *(float *)src = 4321;
1625 dst_len = 0x1234;
1626 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1627 ok(hr == S_OK, "got %08x\n", hr);
1628 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1629 ok(dst_len == 4, "got %ld\n", dst_len);
1630 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1631
1632 *(float *)src = 4321;
1633 memset(dst, 0xcc, sizeof(dst));
1634 dst_len = 0x1234;
1635 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1636 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1637 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1638 ok(dst_len == 4, "got %ld\n", dst_len);
1639 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1640
1641 *(float *)src = 4321;
1642 memset(dst, 0xcc, sizeof(dst));
1643 dst_len = 0x1234;
1644 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1645 ok(hr == S_OK, "got %08x\n", hr);
1646 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1647 ok(dst_len == 4, "got %ld\n", dst_len);
1648 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1649
1650 *(float *)src = 4321;
1651 memset(dst, 0xcc, sizeof(dst));
1652 dst_len = 0x1234;
1653 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1654 ok(hr == S_OK, "got %08x\n", hr);
1655 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1656 ok(dst_len == 4, "got %ld\n", dst_len);
1657 ok(dst[0] == '4', "got %02x\n", dst[0]);
1658 ok(dst[1] == 0, "got %02x\n", dst[1]);
1659 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1660
1661 *(float *)src = 4321;
1662 memset(dst, 0xcc, sizeof(dst));
1663 dst_len = 0x1234;
1664 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1665 ok(hr == S_OK, "got %08x\n", hr);
1666 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1667 ok(dst_len == 4, "got %ld\n", dst_len);
1668 ok(dst[0] == 0, "got %02x\n", dst[0]);
1669 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1670
1671 *(float *)src = 4321;
1672 memset(dst, 0xcc, sizeof(dst));
1673 dst_len = 0x1234;
1674 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1675 ok(hr == S_OK, "got %08x\n", hr);
1676 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1677 ok(dst_len == 4, "got %ld\n", dst_len);
1678 ok(dst[0] == '4', "got %02x\n", dst[0]);
1679 ok(dst[1] == '3', "got %02x\n", dst[1]);
1680 ok(dst[2] == '2', "got %02x\n", dst[2]);
1681 ok(dst[3] == 0, "got %02x\n", dst[3]);
1682 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1683
1684
1685 *(double *)src = 4321;
1686 dst_len = 0x1234;
1687 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1688 ok(hr == S_OK, "got %08x\n", hr);
1689 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1690 ok(dst_len == 4, "got %ld\n", dst_len);
1691 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1692
1693 *(double *)src = 4321;
1694 memset(dst, 0xcc, sizeof(dst));
1695 dst_len = 0x1234;
1696 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1697 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1698 ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1699 ok(dst_len == 4, "got %ld\n", dst_len);
1700 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1701
1702 *(double *)src = 4321;
1703 memset(dst, 0xcc, sizeof(dst));
1704 dst_len = 0x1234;
1705 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1706 ok(hr == S_OK, "got %08x\n", hr);
1707 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1708 ok(dst_len == 4, "got %ld\n", dst_len);
1709 ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1710
1711 *(double *)src = 4321;
1712 memset(dst, 0xcc, sizeof(dst));
1713 dst_len = 0x1234;
1714 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1715 ok(hr == S_OK, "got %08x\n", hr);
1716 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1717 ok(dst_len == 4, "got %ld\n", dst_len);
1718 ok(dst[0] == '4', "got %02x\n", dst[0]);
1719 ok(dst[1] == 0, "got %02x\n", dst[1]);
1720 ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1721
1722 *(double *)src = 4321;
1723 memset(dst, 0xcc, sizeof(dst));
1724 dst_len = 0x1234;
1725 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1726 ok(hr == S_OK, "got %08x\n", hr);
1727 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1728 ok(dst_len == 4, "got %ld\n", dst_len);
1729 ok(dst[0] == 0, "got %02x\n", dst[0]);
1730 ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1731
1732 *(double *)src = 4321;
1733 memset(dst, 0xcc, sizeof(dst));
1734 dst_len = 0x1234;
1735 hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1736 ok(hr == S_OK, "got %08x\n", hr);
1737 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1738 ok(dst_len == 4, "got %ld\n", dst_len);
1739 ok(dst[0] == '4', "got %02x\n", dst[0]);
1740 ok(dst[1] == '3', "got %02x\n", dst[1]);
1741 ok(dst[2] == '2', "got %02x\n", dst[2]);
1742 ok(dst[3] == 0, "got %02x\n", dst[3]);
1743 ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1744
1745
1746
1747 memset(src, 0, sizeof(src));
1748 ((CY*)src)->int64 = 43210000;
1749 memset(dst, 0xcc, sizeof(dst));
1750 dst_len = 0x1234;
1751 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1752 ok(hr == S_OK, "got %08x\n", hr);
1753 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1754 ok(dst_len == 4, "got %ld\n", dst_len);
1755 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1756
1757
1758
1759 memset(src, 0, sizeof(src));
1760 *(signed char *)src = 10;
1761 dst_len = 0x1234;
1762 hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1763 ok(hr == S_OK, "got %08x\n", hr);
1764 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1765 ok(dst_len == 2, "got %ld\n", dst_len);
1766 ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1767
1768 memset(src, 0, sizeof(src));
1769 *(unsigned char *)src = 10;
1770 dst_len = 0x1234;
1771 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1772 ok(hr == S_OK, "got %08x\n", hr);
1773 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1774 ok(dst_len == 2, "got %ld\n", dst_len);
1775 ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1776
1777 memset(src, 0, sizeof(src));
1778 *(unsigned short *)src = 4321;
1779 dst_len = 0x1234;
1780 hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1781 ok(hr == S_OK, "got %08x\n", hr);
1782 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1783 ok(dst_len == 4, "got %ld\n", dst_len);
1784 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1785
1786 memset(src, 0, sizeof(src));
1787 *(unsigned int *)src = 4321;
1788 dst_len = 0x1234;
1789 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1790 ok(hr == S_OK, "got %08x\n", hr);
1791 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1792 ok(dst_len == 4, "got %ld\n", dst_len);
1793 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1794
1795 memset(src, 0, sizeof(src));
1796 ((LARGE_INTEGER*)src)->QuadPart = 4321;
1797 dst_len = 0x1234;
1798 hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1799 ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1800 ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1801 ok(broken(dst_len == 0x1234) || dst_len == 4 /* W2K+ */, "got %ld\n", dst_len);
1802 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1803
1804 memset(src, 0, sizeof(src));
1805 ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1806 dst_len = 0x1234;
1807 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1808 ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1809 ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1810 ok(broken(dst_len == 0x1234) || dst_len == 4 /* W2K+ */, "got %ld\n", dst_len);
1811 ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1812
1813
1814
1815 memset(src, 0, sizeof(src));
1816 memcpy(src, &IID_IDataConvert, sizeof(GUID));
1817 memset(dst, 0xcc, sizeof(dst));
1818 dst_len = 0x1234;
1819 hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_STR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1820 ok(hr == S_OK, "got %08x\n", hr);
1821 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1822 ok(dst_len == 38, "got %ld\n", dst_len);
1823 ok(!lstrcmpA(dst, guid_str), "got %s\n", dst);
1824
1825
1826
1827 b = SysAllocString(ten);
1828 *(BSTR *)src = b;
1829 memset(dst, 0xcc, sizeof(dst));
1830 dst_len = 0x1234;
1831 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1832 ok(hr == S_OK, "got %08x\n", hr);
1833 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1834 ok(dst_len == 2, "got %ld\n", dst_len);
1835 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1836 SysFreeString(b);
1837
1838 memcpy(src, ten, sizeof(ten));
1839 memset(dst, 0xcc, sizeof(dst));
1840 dst_len = 0x1234;
1841 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1842 ok(hr == S_OK, "got %08x\n", hr);
1843 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1844 ok(dst_len == 1, "got %ld\n", dst_len);
1845 ok(dst[0] == '1', "got %02x\n", dst[0]);
1846 ok(dst[1] == 0, "got %02x\n", dst[1]);
1847
1848 memcpy(src, ten, sizeof(ten));
1849 memset(dst, 0xcc, sizeof(dst));
1850 dst_len = 0x1234;
1851 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1852 ok(hr == S_OK, "got %08x\n", hr);
1853 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1854 ok(dst_len == 2, "got %ld\n", dst_len);
1855 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1856
1857 memcpy(src, ten, sizeof(ten));
1858 memset(dst, 0xcc, sizeof(dst));
1859 dst_len = 0x1234;
1860 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1861 ok(hr == S_OK, "got %08x\n", hr);
1862 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1863 ok(dst_len == 2, "got %ld\n", dst_len);
1864 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1865
1866 memcpy(src, ten_a, sizeof(ten_a));
1867 memset(dst, 0xcc, sizeof(dst));
1868 dst_len = 0x1234;
1869 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1870 ok(hr == S_OK, "got %08x\n", hr);
1871 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1872 ok(dst_len == 2, "got %ld\n", dst_len);
1873 ok(dst[0] == '1', "got %02x\n", dst[0]);
1874 ok(dst[1] == '0', "got %02x\n", dst[1]);
1875 ok(dst[2] == 0, "got %02x\n", dst[2]);
1876 ok(dst[3] == (char)0xcc, "got %02x\n", dst[3]);
1877
1878 memcpy(src, ten_a, sizeof(ten_a));
1879 memset(dst, 0xcc, sizeof(dst));
1880 dst_len = 0x1234;
1881 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1882 ok(hr == S_OK, "got %08x\n", hr);
1883 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1884 ok(dst_len == 4, "got %ld\n", dst_len);
1885 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1886
1887 memcpy(src, ten_a, sizeof(ten_a));
1888 memset(dst, 0xcc, sizeof(dst));
1889 dst_len = 0x1234;
1890 hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1891 ok(hr == S_OK, "got %08x\n", hr);
1892 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1893 ok(dst_len == 2, "got %ld\n", dst_len);
1894 ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1895
1896
1897
1898 /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1899 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1900 memset(dst, 0xcc, sizeof(dst));
1901 dst_len = 0x1234;
1902 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, sizeof(hexpacked_a), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1903 ok(hr == S_OK, "got %08x\n", hr);
1904 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1905 ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1906 ok(!lstrcmpA(hexunpacked_a, dst), "got %s\n", dst);
1907 ok(dst[sizeof(hexpacked_a)/sizeof(char) * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1908
1909 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1910 memset(dst, 0xcc, sizeof(dst));
1911 dst_len = 0x1234;
1912 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1913 ok(hr == S_OK, "got %08x\n", hr);
1914 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1915 ok(dst_len == 0, "got %ld\n", dst_len);
1916 ok(dst[0] == 0, "not null terminated\n");
1917 ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1918
1919 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1920 memset(dst, 0xcc, sizeof(dst));
1921 dst_len = 0x1234;
1922 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1923 ok(hr == S_OK, "got %08x\n", hr);
1924 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1925 ok(dst_len == 2 * sizeof(char) * 4, "got %ld\n", dst_len);
1926 ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1927 ok(dst[2 * 4] == 0, "not null terminated\n");
1928 ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1929
1930 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1931 memset(dst, 0xcc, sizeof(dst));
1932 dst_len = 0x1234;
1933 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);
1934 ok(hr == S_OK, "got %08x\n", hr);
1935 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1936 ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1937 ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1938 ok(dst[2 * 4] == 0, "not null terminated\n");
1939 ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1940
1941 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1942 memset(dst, 0xcc, sizeof(dst));
1943 dst_len = 0x1234;
1944 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);
1945 ok(hr == S_OK, "got %08x\n", hr);
1946 ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1947 ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1948 ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 - 2 ), "got %s\n", dst);
1949 ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1950 ok(dst[2 * 4] == (char)0xcc, "clobbered buffer\n");
1951
1952 memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1953 memset(dst, 0xcc, sizeof(dst));
1954 dst_len = 0x1234;
1955 hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1956 ok(hr == S_OK, "got %08x\n", hr);
1957 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1958 ok(dst_len == 0, "got %ld\n", dst_len);
1959 ok(dst[0] == 0, "not null terminated\n");
1960 ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1961
1962 IDataConvert_Release(convert);
1963 }
1964
1965 static void test_converttobyrefwstr(void)
1966 {
1967 IDataConvert *convert;
1968 HRESULT hr;
1969 WCHAR *dst;
1970 BYTE src[20];
1971 DBSTATUS dst_status;
1972 DBLENGTH dst_len;
1973 static const WCHAR ten[] = {'1','0',0};
1974 static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1975 BSTR b;
1976
1977 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1978 if(FAILED(hr))
1979 {
1980 win_skip("Unable to load oledb conversion library\n");
1981 return;
1982 }
1983
1984 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1985 ok(hr == S_OK, "got %08x\n", hr);
1986 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1987 ok(dst_len == 0, "got %ld\n", dst_len);
1988 ok(dst[0] == 0, "got %04x\n", dst[0]);
1989 CoTaskMemFree(dst);
1990
1991 dst = (void*)0x12345678;
1992 dst_len = 0x1234;
1993 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1994 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1995 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1996 ok(dst_len == 0x1234, "got %ld\n", dst_len);
1997 ok(dst == (void*)0x12345678, "got %p\n", dst);
1998
1999 *(short *)src = 4321;
2000 dst_len = 0x1234;
2001 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2002 ok(hr == S_OK, "got %08x\n", hr);
2003 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2004 ok(dst_len == 8, "got %ld\n", dst_len);
2005 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
2006 CoTaskMemFree(dst);
2007
2008 *(short *)src = 4321;
2009 dst_len = 0x1234;
2010 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, 0, 0, &dst_status, 0, 0, 0);
2011 ok(hr == S_OK, "got %08x\n", hr);
2012 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2013 ok(dst_len == 8, "got %ld\n", dst_len);
2014 ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
2015 CoTaskMemFree(dst);
2016
2017 b = SysAllocString(ten);
2018 *(BSTR *)src = b;
2019 dst_len = 0x1234;
2020 hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2021 ok(hr == S_OK, "got %08x\n", hr);
2022 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2023 ok(dst_len == 4, "got %ld\n", dst_len);
2024 ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
2025 CoTaskMemFree(dst);
2026 SysFreeString(b);
2027
2028 memcpy(src, ten, sizeof(ten));
2029 dst_len = 0x1234;
2030 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2031 ok(hr == S_OK, "got %08x\n", hr);
2032 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2033 ok(dst_len == 2, "got %ld\n", dst_len);
2034 ok(dst[0] == '1', "got %02x\n", dst[0]);
2035 ok(dst[1] == 0, "got %02x\n", dst[1]);
2036 CoTaskMemFree(dst);
2037
2038 memcpy(src, ten, sizeof(ten));
2039 dst_len = 0x1234;
2040 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2041 ok(hr == S_OK, "got %08x\n", hr);
2042 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2043 ok(dst_len == 4, "got %ld\n", dst_len);
2044 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
2045 CoTaskMemFree(dst);
2046
2047 memcpy(src, ten, sizeof(ten));
2048 dst_len = 0x1234;
2049 hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
2050 ok(hr == S_OK, "got %08x\n", hr);
2051 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2052 ok(dst_len == 4, "got %ld\n", dst_len);
2053 ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
2054 CoTaskMemFree(dst);
2055
2056 IDataConvert_Release(convert);
2057 }
2058
2059 static void test_converttoguid(void)
2060 {
2061 IDataConvert *convert;
2062 HRESULT hr;
2063 GUID dst;
2064 BYTE src[20];
2065 DBSTATUS dst_status;
2066 DBLENGTH dst_len;
2067
2068 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2069 if(FAILED(hr))
2070 {
2071 win_skip("Unable to load oledb conversion library\n");
2072 return;
2073 }
2074
2075 dst = IID_IDCInfo;
2076 dst_len = 0x1234;
2077 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2078 ok(hr == S_OK, "got %08x\n", hr);
2079 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2080 ok(dst_len == sizeof(GUID), "got %ld\n", dst_len);
2081 ok(IsEqualGUID(&dst, &GUID_NULL), "didn't get GUID_NULL\n");
2082
2083 dst = IID_IDCInfo;
2084 dst_len = 0x1234;
2085 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2086 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2087 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2088 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2089 ok(IsEqualGUID(&dst, &IID_IDCInfo), "dst has changed\n");
2090
2091 dst = IID_IDCInfo;
2092 memcpy(src, &IID_IDataConvert, sizeof(GUID));
2093 dst_len = 0x1234;
2094 hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2095 ok(hr == S_OK, "got %08x\n", hr);
2096 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2097 ok(dst_len == sizeof(GUID), "got %ld\n", dst_len);
2098 ok(IsEqualGUID(&dst, &IID_IDataConvert), "didn't get IID_IDataConvert\n");
2099
2100 IDataConvert_Release(convert);
2101 }
2102
2103 static void test_converttofiletime(void)
2104 {
2105 IDataConvert *convert;
2106 HRESULT hr;
2107 FILETIME dst;
2108 BYTE src[20];
2109 DBSTATUS dst_status;
2110 DBLENGTH dst_len;
2111
2112 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2113 if(FAILED(hr))
2114 {
2115 win_skip("Unable to load oledb conversion library\n");
2116 return;
2117 }
2118
2119 memset(&dst, 0xcc, sizeof(dst));
2120 ((FILETIME *)src)->dwLowDateTime = 0x12345678;
2121 ((FILETIME *)src)->dwHighDateTime = 0x9abcdef0;
2122 dst_len = 0x1234;
2123 hr = IDataConvert_DataConvert(convert, DBTYPE_FILETIME, DBTYPE_FILETIME, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2124 ok(hr == S_OK ||
2125 broken(hr == DB_E_BADBINDINFO), /* win98 */
2126 "got %08x\n", hr);
2127 if(SUCCEEDED(hr))
2128 {
2129 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2130 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2131 ok(dst.dwLowDateTime == 0x12345678, "got %08x\n", dst.dwLowDateTime);
2132 ok(dst.dwHighDateTime == 0x9abcdef0, "got %08x\n", dst.dwHighDateTime);
2133 }
2134
2135 IDataConvert_Release(convert);
2136 }
2137
2138 static void test_converttoui1(void)
2139 {
2140 IDataConvert *convert;
2141 HRESULT hr;
2142 BYTE dst;
2143 BYTE src[20];
2144 DBSTATUS dst_status;
2145 DBLENGTH dst_len;
2146
2147 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2148 if(FAILED(hr))
2149 {
2150 win_skip("Unable to load oledb conversion library\n");
2151 return;
2152 }
2153
2154 dst = 0x12;
2155 dst_len = 0x1234;
2156 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2157 ok(hr == S_OK, "got %08x\n", hr);
2158 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2159 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2160 ok(dst == 0, "got %08x\n", dst);
2161
2162 dst = 0x12;
2163 dst_len = 0x1234;
2164 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2165 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2166 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2167 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2168 ok(dst == 0x12, "got %08x\n", dst);
2169
2170 dst = 0x12;
2171 src[0] = 0x43;
2172 dst_len = 0x1234;
2173 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2174 ok(hr == S_OK, "got %08x\n", hr);
2175 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2176 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2177 ok(dst == 0x43, "got %08x\n", dst);
2178
2179 dst = 0x12;
2180 src[0] = 0xfe;
2181 dst_len = 0x1234;
2182 hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2183 ok(hr == S_OK, "got %08x\n", hr);
2184 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2185 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2186 ok(dst == 0xfe, "got %08x\n", dst);
2187
2188 IDataConvert_Release(convert);
2189 }
2190
2191 static void test_converttoui4(void)
2192 {
2193 IDataConvert *convert;
2194 HRESULT hr;
2195 DWORD dst;
2196 BYTE src[20];
2197 DBSTATUS dst_status;
2198 DBLENGTH dst_len;
2199
2200 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2201 if(FAILED(hr))
2202 {
2203 win_skip("Unable to load oledb conversion library\n");
2204 return;
2205 }
2206
2207 dst = 0x12345678;
2208 dst_len = 0x1234;
2209 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2210 ok(hr == S_OK, "got %08x\n", hr);
2211 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2212 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2213 ok(dst == 0, "got %08x\n", dst);
2214
2215 dst = 0x12345678;
2216 dst_len = 0x1234;
2217 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2218 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2219 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2220 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2221 ok(dst == 0x12345678, "got %08x\n", dst);
2222
2223 dst = 0x12345678;
2224 *(DWORD*)src = 0x87654321;
2225 dst_len = 0x1234;
2226 hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2227 ok(hr == S_OK, "got %08x\n", hr);
2228 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2229 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2230 ok(dst == 0x87654321, "got %08x\n", dst);
2231
2232 dst = 0x12345678;
2233 *(signed short *)src = 0x4321;
2234 dst_len = 0x1234;
2235 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2236 ok(hr == S_OK, "got %08x\n", hr);
2237 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2238 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2239 ok(dst == 0x4321, "got %08x\n", dst);
2240
2241 dst = 0x12345678;
2242 *(signed short *)src = -1;
2243 dst_len = 0x1234;
2244 hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2245 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2246 todo_wine
2247 ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2248 todo_wine
2249 ok(broken(dst_len == sizeof(dst)) || dst_len == 0x1234 /* W2K+ */, "got %ld\n", dst_len);
2250 ok(dst == 0x12345678, "got %08x\n", dst);
2251
2252 IDataConvert_Release(convert);
2253 }
2254
2255 static void test_converttor4(void)
2256 {
2257 IDataConvert *convert;
2258 HRESULT hr;
2259 FLOAT dst;
2260 BYTE src[20];
2261 DBSTATUS dst_status;
2262 DBLENGTH dst_len;
2263
2264 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2265 if(FAILED(hr))
2266 {
2267 win_skip("Unable to load oledb conversion library\n");
2268 return;
2269 }
2270
2271 dst = 1.0;
2272 dst_len = 0x1234;
2273 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2274 ok(hr == S_OK, "got %08x\n", hr);
2275 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2276 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2277 ok(dst == 0.0, "got %f\n", dst);
2278
2279 dst = 1.0;
2280 dst_len = 0x1234;
2281 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2282 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2283 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2284 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2285 ok(dst == 1.0, "got %f\n", dst);
2286
2287 dst = 1.0;
2288 *(signed int*)src = 12345678;
2289 dst_len = 0x1234;
2290 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2291 ok(hr == S_OK, "got %08x\n", hr);
2292 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2293 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2294 ok(dst == 12345678.0, "got %f\n", dst);
2295
2296 dst = 1.0;
2297 *(FLOAT *)src = 10.0;
2298 dst_len = 0x1234;
2299 hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2300 ok(hr == S_OK, "got %08x\n", hr);
2301 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2302 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2303 ok(dst == 10.0, "got %f\n", dst);
2304
2305 IDataConvert_Release(convert);
2306 }
2307
2308 static void test_converttocy(void)
2309 {
2310 IDataConvert *convert;
2311 HRESULT hr;
2312 CY dst;
2313 BYTE src[20];
2314 DBSTATUS dst_status;
2315 DBLENGTH dst_len;
2316
2317 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2318 if(FAILED(hr))
2319 {
2320 win_skip("Unable to load oledb conversion library\n");
2321 return;
2322 }
2323
2324 dst.int64 = 0xcc;
2325 dst_len = 0x1234;
2326 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2327 ok(hr == S_OK, "got %08x\n", hr);
2328 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2329 ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2330 ok(dst.int64 == 0, "didn't get 0\n");
2331
2332 dst.int64 = 0xcc;
2333 dst_len = 0x1234;
2334 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2335 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2336 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2337 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2338 ok(dst.int64 == 0xcc, "dst changed\n");
2339
2340 dst.int64 = 0xcc;
2341 *(int*)src = 1234;
2342 dst_len = 0x1234;
2343 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2344 ok(hr == S_OK, "got %08x\n", hr);
2345 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2346 ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2347 ok(dst.int64 == 12340000, "got %d\n", dst.s.Lo);
2348
2349 dst.int64 = 0xcc;
2350 ((CY*)src)->int64 = 1234;
2351 dst_len = 0x1234;
2352 hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2353 ok(hr == S_OK, "got %08x\n", hr);
2354 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2355 ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2356 ok(dst.int64 == 1234, "got %d\n", dst.s.Lo);
2357
2358 IDataConvert_Release(convert);
2359 }
2360
2361 static void test_converttoui8(void)
2362 {
2363 IDataConvert *convert;
2364 HRESULT hr;
2365 ULARGE_INTEGER dst;
2366 BYTE src[20];
2367 DBSTATUS dst_status;
2368 DBLENGTH dst_len;
2369
2370 hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2371 if(FAILED(hr))
2372 {
2373 win_skip("Unable to load oledb conversion library\n");
2374 return;
2375 }
2376
2377 dst.QuadPart = 0xcc;
2378 dst_len = 0x1234;
2379 hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2380 ok(hr == S_OK, "got %08x\n", hr);
2381 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2382 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2383 ok(dst.QuadPart == 0, "got %d\n", (int)dst.QuadPart);
2384
2385 dst.QuadPart = 0xcc;
2386 dst_len = 0x1234;
2387 hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2388 ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2389 ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2390 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2391 ok(dst.QuadPart == 0xcc, "dst changed\n");
2392
2393 dst.QuadPart = 0xcc;
2394 *(int*)src = 1234;
2395 dst_len = 0x1234;
2396 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2397 ok(hr == S_OK, "got %08x\n", hr);
2398 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2399 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2400 ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2401
2402 dst.QuadPart = 0xcc;
2403 *(int*)src = -1234;
2404 dst_len = 0x1234;
2405 hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2406 ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2407 todo_wine
2408 ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2409 todo_wine
2410 ok(dst_len == 0x1234, "got %ld\n", dst_len);
2411 ok(dst.QuadPart == 0xcc, "got %d\n", (int)dst.QuadPart);
2412
2413 dst.QuadPart = 0xcc;
2414 ((ULARGE_INTEGER*)src)->QuadPart = 1234;
2415 dst_len = 0x1234;
2416 hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2417 ok(hr == S_OK, "got %08x\n", hr);
2418 ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2419 ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2420 ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2421
2422 IDataConvert_Release(convert);
2423 }
2424
2425 START_TEST(convert)
2426 {
2427 OleInitialize(NULL);
2428 test_dcinfo();
2429 test_canconvert();
2430 test_converttoi2();
2431 test_converttoi4();
2432 test_converttostr();
2433 test_converttobstr();
2434 test_converttowstr();
2435 test_converttobyrefwstr();
2436 test_converttoguid();
2437 test_converttoui1();
2438 test_converttoui4();
2439 test_converttor4();
2440 test_converttofiletime();
2441 test_converttocy();
2442 test_converttoui8();
2443 OleUninitialize();
2444 }
GSOC 2012 project to enhance the control panel