git.oblomov.eu Git - wine/blob - dlls/oledb32/tests/convert.c

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