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