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