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_converttobstr(void)
 921 {
 922     IDataConvert *convert;
 923     HRESULT hr;
 924     BSTR 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_len = 0x1234;
 939     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 940     ok(hr == S_OK, "got %08x\n", hr);
 941     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 942     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 943     ok(dst != NULL, "got %p\n", dst);
 944     ok(SysStringLen(dst) == 0, "got %d\n", SysStringLen(dst));
 945     SysFreeString(dst);
 946
 947     dst = (void*)0x1234;
 948     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 949     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 950     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 951     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 952     ok(dst == (void*)0x1234, "got %p\n", dst);
 953
 954     *(short *)src = 4321;
 955     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 956     ok(hr == S_OK, "got %08x\n", hr);
 957     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 958     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 959     ok(dst != NULL, "got %p\n", dst);
 960     ok(SysStringLen(dst) == 4, "got %d\n", SysStringLen(dst));
 961     SysFreeString(dst);
 962
 963     b = SysAllocString(ten);
 964     *(BSTR *)src = b;
 965     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 966     ok(hr == S_OK, "got %08x\n", hr);
 967     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 968     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 969     ok(dst != NULL, "got %p\n", dst);
 970     ok(dst != b, "got %p src %p\n", dst, b);
 971     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
 972     SysFreeString(dst);
 973     SysFreeString(b);
 974
 975     IDataConvert_Release(convert);
 976 }
 977
 978 static void test_converttowstr(void)
 979 {
 980     IDataConvert *convert;
 981     HRESULT hr;
 982     WCHAR dst[100];
 983     BYTE src[20];
 984     DBSTATUS dst_status;
 985     DBLENGTH dst_len;
 986     static const WCHAR ten[] = {'1','0',0};
 987     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
 988     static const WCHAR guid_str[] = {
 989         '{','0','C','7','3','3','A','8','D','-','2','A','1','C','-','1','1','C','E','-',
 990         'A','D','E','5','-','0','0','A','A','0','0','4','4','7','7','3','D','}',0};
 991     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 };
 992     static const WCHAR hexpacked_w[] = {'W','i','n','e', 0 };
 993     BSTR b;
 994
 995     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 996     if(FAILED(hr))
 997     {
 998         win_skip("Unable to load oledb conversion library\n");
 999         return;
1000     }
1001
1002
1003     memset(dst, 0xcc, sizeof(dst));
1004     dst_len = 0x1234;
1005     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1006     ok(hr == S_OK, "got %08x\n", hr);
1007     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1008     ok(dst_len == 0, "got %ld\n", dst_len);
1009     ok(dst[0] == 0, "got %02x\n", dst[0]);
1010     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1011
1012     memset(dst, 0xcc, sizeof(dst));
1013     dst_len = 0x1234;
1014     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1015     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1016     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1017     ok(dst_len == 0x1234, "got %ld\n", dst_len);
1018     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1019
1020     *(short *)src = 4321;
1021     dst_len = 0x1234;
1022     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1023     ok(hr == S_OK, "got %08x\n", hr);
1024     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1025     ok(dst_len == 8, "got %ld\n", dst_len);
1026     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1027
1028     *(short *)src = 4321;
1029     memset(dst, 0xcc, sizeof(dst));
1030     dst_len = 0x1234;
1031     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1032     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1033     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1034     ok(dst_len == 8, "got %ld\n", dst_len);
1035     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1036
1037     *(short *)src = 4321;
1038     memset(dst, 0xcc, sizeof(dst));
1039     dst_len = 0x1234;
1040     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1041     ok(hr == S_OK, "got %08x\n", hr);
1042     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1043     ok(dst_len == 8, "got %ld\n", dst_len);
1044     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1045
1046     *(short *)src = 4321;
1047     memset(dst, 0xcc, sizeof(dst));
1048     dst_len = 0x1234;
1049     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1050     ok(hr == S_OK, "got %08x\n", hr);
1051     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1052     ok(dst_len == 8, "got %ld\n", dst_len);
1053     ok(dst[0] == '4', "got %02x\n", dst[0]);
1054     ok(dst[1] == 0, "got %02x\n", dst[1]);
1055     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1056
1057     *(short *)src = 4321;
1058     memset(dst, 0xcc, sizeof(dst));
1059     dst_len = 0x1234;
1060     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1061     ok(hr == S_OK, "got %08x\n", hr);
1062     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1063     ok(dst_len == 8, "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     *(short *)src = 4321;
1068     memset(dst, 0xcc, sizeof(dst));
1069     dst_len = 0x1234;
1070     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1071     ok(hr == S_OK, "got %08x\n", hr);
1072     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1073     ok(dst_len == 8, "got %ld\n", dst_len);
1074     ok(dst[0] == '4', "got %02x\n", dst[0]);
1075     ok(dst[1] == '3', "got %02x\n", dst[1]);
1076     ok(dst[2] == '2', "got %02x\n", dst[2]);
1077     ok(dst[3] == 0, "got %02x\n", dst[3]);
1078     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1079
1080
1081
1082     *(int *)src = 4321;
1083     dst_len = 0x1234;
1084     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1085     ok(hr == S_OK, "got %08x\n", hr);
1086     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1087     ok(dst_len == 8, "got %ld\n", dst_len);
1088     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1089
1090     *(int *)src = 4321;
1091     memset(dst, 0xcc, sizeof(dst));
1092     dst_len = 0x1234;
1093     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1094     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1095     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1096     ok(dst_len == 8, "got %ld\n", dst_len);
1097     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1098
1099     *(int *)src = 4321;
1100     memset(dst, 0xcc, sizeof(dst));
1101     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1102     ok(hr == S_OK, "got %08x\n", hr);
1103     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1104     ok(dst_len == 8, "got %ld\n", dst_len);
1105     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1106
1107     *(int *)src = 4321;
1108     memset(dst, 0xcc, sizeof(dst));
1109     dst_len = 0x1234;
1110     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1111     ok(hr == S_OK, "got %08x\n", hr);
1112     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1113     ok(dst_len == 8, "got %ld\n", dst_len);
1114     ok(dst[0] == '4', "got %02x\n", dst[0]);
1115     ok(dst[1] == 0, "got %02x\n", dst[1]);
1116     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1117
1118     *(int *)src = 4321;
1119     memset(dst, 0xcc, sizeof(dst));
1120     dst_len = 0x1234;
1121     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1122     ok(hr == S_OK, "got %08x\n", hr);
1123     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1124     ok(dst_len == 8, "got %ld\n", dst_len);
1125     ok(dst[0] == 0, "got %02x\n", dst[0]);
1126     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1127
1128     *(int *)src = 4321;
1129     memset(dst, 0xcc, sizeof(dst));
1130     dst_len = 0x1234;
1131     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1132     ok(hr == S_OK, "got %08x\n", hr);
1133     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1134     ok(dst_len == 8, "got %ld\n", dst_len);
1135     ok(dst[0] == '4', "got %02x\n", dst[0]);
1136     ok(dst[1] == '3', "got %02x\n", dst[1]);
1137     ok(dst[2] == '2', "got %02x\n", dst[2]);
1138     ok(dst[3] == 0, "got %02x\n", dst[3]);
1139     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1140
1141
1142
1143     *(float *)src = 4321;
1144     dst_len = 0x1234;
1145     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1146     ok(hr == S_OK, "got %08x\n", hr);
1147     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1148     ok(dst_len == 8, "got %ld\n", dst_len);
1149     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1150
1151     *(float *)src = 4321;
1152     memset(dst, 0xcc, sizeof(dst));
1153     dst_len = 0x1234;
1154     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1155     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1156     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1157     ok(dst_len == 8, "got %ld\n", dst_len);
1158     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1159
1160     *(float *)src = 4321;
1161     memset(dst, 0xcc, sizeof(dst));
1162     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1163     ok(hr == S_OK, "got %08x\n", hr);
1164     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1165     ok(dst_len == 8, "got %ld\n", dst_len);
1166     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1167
1168     *(float *)src = 4321;
1169     memset(dst, 0xcc, sizeof(dst));
1170     dst_len = 0x1234;
1171     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1172     ok(hr == S_OK, "got %08x\n", hr);
1173     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1174     ok(dst_len == 8, "got %ld\n", dst_len);
1175     ok(dst[0] == '4', "got %02x\n", dst[0]);
1176     ok(dst[1] == 0, "got %02x\n", dst[1]);
1177     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1178
1179     *(float *)src = 4321;
1180     memset(dst, 0xcc, sizeof(dst));
1181     dst_len = 0x1234;
1182     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1183     ok(hr == S_OK, "got %08x\n", hr);
1184     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1185     ok(dst_len == 8, "got %ld\n", dst_len);
1186     ok(dst[0] == 0, "got %02x\n", dst[0]);
1187     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1188
1189     *(float *)src = 4321;
1190     memset(dst, 0xcc, sizeof(dst));
1191     dst_len = 0x1234;
1192     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1193     ok(hr == S_OK, "got %08x\n", hr);
1194     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1195     ok(dst_len == 8, "got %ld\n", dst_len);
1196     ok(dst[0] == '4', "got %02x\n", dst[0]);
1197     ok(dst[1] == '3', "got %02x\n", dst[1]);
1198     ok(dst[2] == '2', "got %02x\n", dst[2]);
1199     ok(dst[3] == 0, "got %02x\n", dst[3]);
1200     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1201
1202
1203
1204     *(double *)src = 4321;
1205     dst_len = 0x1234;
1206     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1207     ok(hr == S_OK, "got %08x\n", hr);
1208     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1209     ok(dst_len == 8, "got %ld\n", dst_len);
1210     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1211
1212     *(double *)src = 4321;
1213     memset(dst, 0xcc, sizeof(dst));
1214     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1215     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1216     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1217     ok(dst_len == 8, "got %ld\n", dst_len);
1218     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1219
1220     *(double *)src = 4321;
1221     memset(dst, 0xcc, sizeof(dst));
1222     dst_len = 0x1234;
1223     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1224     ok(hr == S_OK, "got %08x\n", hr);
1225     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1226     ok(dst_len == 8, "got %ld\n", dst_len);
1227     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1228
1229     *(double *)src = 4321;
1230     memset(dst, 0xcc, sizeof(dst));
1231     dst_len = 0x1234;
1232     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1233     ok(hr == S_OK, "got %08x\n", hr);
1234     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1235     ok(dst_len == 8, "got %ld\n", dst_len);
1236     ok(dst[0] == '4', "got %02x\n", dst[0]);
1237     ok(dst[1] == 0, "got %02x\n", dst[1]);
1238     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1239
1240     *(double *)src = 4321;
1241     memset(dst, 0xcc, sizeof(dst));
1242     dst_len = 0x1234;
1243     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1244     ok(hr == S_OK, "got %08x\n", hr);
1245     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1246     ok(dst_len == 8, "got %ld\n", dst_len);
1247     ok(dst[0] == 0, "got %02x\n", dst[0]);
1248     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1249
1250     *(double *)src = 4321;
1251     memset(dst, 0xcc, sizeof(dst));
1252     dst_len = 0x1234;
1253     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1254     ok(hr == S_OK, "got %08x\n", hr);
1255     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1256     ok(dst_len == 8, "got %ld\n", dst_len);
1257     ok(dst[0] == '4', "got %02x\n", dst[0]);
1258     ok(dst[1] == '3', "got %02x\n", dst[1]);
1259     ok(dst[2] == '2', "got %02x\n", dst[2]);
1260     ok(dst[3] == 0, "got %02x\n", dst[3]);
1261     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1262
1263
1264
1265     memset(src, 0, sizeof(src));
1266     ((CY*)src)->int64 = 43210000;
1267     memset(dst, 0xcc, sizeof(dst));
1268     dst_len = 0x1234;
1269     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1270     ok(hr == S_OK, "got %08x\n", hr);
1271     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1272     ok(dst_len == 8, "got %ld\n", dst_len);
1273     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1274
1275
1276
1277     memset(src, 0, sizeof(src));
1278     *(signed char *)src = 10;
1279     dst_len = 0x1234;
1280     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1281     ok(hr == S_OK, "got %08x\n", hr);
1282     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1283     ok(dst_len == 4, "got %ld\n", dst_len);
1284     ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1285
1286     memset(src, 0, sizeof(src));
1287     *(unsigned char *)src = 10;
1288     dst_len = 0x1234;
1289     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1290     ok(hr == S_OK, "got %08x\n", hr);
1291     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1292     ok(dst_len == 4, "got %ld\n", dst_len);
1293     ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1294
1295     memset(src, 0, sizeof(src));
1296     *(unsigned short *)src = 4321;
1297     dst_len = 0x1234;
1298     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1299     ok(hr == S_OK, "got %08x\n", hr);
1300     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1301     ok(dst_len == 8, "got %ld\n", dst_len);
1302     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1303
1304     memset(src, 0, sizeof(src));
1305     *(unsigned int *)src = 4321;
1306     dst_len = 0x1234;
1307     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1308     ok(hr == S_OK, "got %08x\n", hr);
1309     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1310     ok(dst_len == 8, "got %ld\n", dst_len);
1311     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1312
1313     memset(src, 0, sizeof(src));
1314     ((LARGE_INTEGER*)src)->QuadPart = 4321;
1315     dst_len = 0x1234;
1316     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1317     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1318     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1319     ok(broken(dst_len == 0x1234) || dst_len == 8 /* W2K+ */, "got %ld\n", dst_len);
1320     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1321
1322     memset(src, 0, sizeof(src));
1323     ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1324     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1325     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1326     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1327     ok(broken(dst_len == 0x1234) || dst_len == 8 /* W2K+ */, "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     memcpy(src, &IID_IDataConvert, sizeof(GUID));
1334     memset(dst, 0xcc, sizeof(dst));
1335     dst_len = 0x1234;
1336     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1337     ok(hr == S_OK, "got %08x\n", hr);
1338     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1339     ok(dst_len == 76, "got %ld\n", dst_len);
1340     ok(!lstrcmpW(dst, guid_str), "got %s\n", wine_dbgstr_w(dst));
1341
1342
1343
1344     b = SysAllocString(ten);
1345     *(BSTR *)src = b;
1346     dst_len = 0x1234;
1347     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1348     ok(hr == S_OK, "got %08x\n", hr);
1349     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1350     ok(dst_len == 4, "got %ld\n", dst_len);
1351     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1352     SysFreeString(b);
1353
1354     memcpy(src, ten, sizeof(ten));
1355     dst_len = 0x1234;
1356     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1357     ok(hr == S_OK, "got %08x\n", hr);
1358     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1359     ok(dst_len == 2, "got %ld\n", dst_len);
1360     ok(dst[0] == '1', "got %02x\n", dst[0]);
1361     ok(dst[1] == 0, "got %02x\n", dst[1]);
1362
1363     memcpy(src, ten, sizeof(ten));
1364     dst_len = 0x1234;
1365     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1366     ok(hr == S_OK, "got %08x\n", hr);
1367     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1368     ok(dst_len == 4, "got %ld\n", dst_len);
1369     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1370
1371     memcpy(src, ten, sizeof(ten));
1372     dst_len = 0x1234;
1373     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1374     ok(hr == S_OK, "got %08x\n", hr);
1375     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1376     ok(dst_len == 4, "got %ld\n", dst_len);
1377     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1378
1379
1380
1381     /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1382     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1383     memset(dst, 0xcc, sizeof(dst));
1384     dst_len = 0x1234;
1385     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1386     ok(hr == S_OK, "got %08x\n", hr);
1387     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1388     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1389     ok(!lstrcmpW(hexunpacked_w, dst), "got %s\n", wine_dbgstr_w(dst));
1390     ok(dst[sizeof(hexpacked_w)/sizeof(WCHAR) * 4 + 1] == 0xcccc, "clobbered buffer\n");
1391
1392     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1393     memset(dst, 0xcc, sizeof(dst));
1394     dst_len = 0x1234;
1395     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1396     ok(hr == S_OK, "got %08x\n", hr);
1397     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1398     ok(dst_len == 0, "got %ld\n", dst_len);
1399     ok(dst[0] == 0, "not null terminated\n");
1400     ok(dst[1] == 0xcccc, "clobbered buffer\n");
1401
1402     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1403     memset(dst, 0xcc, sizeof(dst));
1404     dst_len = 0x1234;
1405     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1406     ok(hr == S_OK, "got %08x\n", hr);
1407     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1408     ok(dst_len == 2 * sizeof(WCHAR) * 4, "got %ld\n", dst_len);
1409     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1410     ok(dst[2 * 4] == 0, "not null terminated\n");
1411     ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1412
1413     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1414     memset(dst, 0xcc, sizeof(dst));
1415     dst_len = 0x1234;
1416     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);
1417     ok(hr == S_OK, "got %08x\n", hr);
1418     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1419     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1420     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1421     ok(dst[2 * 4] == 0, "not null terminated\n");
1422     ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1423
1424     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1425     memset(dst, 0xcc, sizeof(dst));
1426     dst_len = 0x1234;
1427     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);
1428     ok(hr == S_OK, "got %08x\n", hr);
1429     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1430     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1431     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1432     ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1433     ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1434
1435     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1436     memset(dst, 0xcc, sizeof(dst));
1437     dst_len = 0x1234;
1438     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);
1439     ok(hr == S_OK, "got %08x\n", hr);
1440     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1441     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1442     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1443     ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1444     ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1445
1446     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1447     memset(dst, 0xcc, sizeof(dst));
1448     dst_len = 0x1234;
1449     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1450     ok(hr == S_OK, "got %08x\n", hr);
1451     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1452     ok(dst_len == 0, "got %ld\n", dst_len);
1453     ok(dst[0] == 0, "not null terminated\n");
1454     ok(dst[1] == 0xcccc, "clobbered buffer\n");
1455
1456
1457     IDataConvert_Release(convert);
1458 }
1459
1460 static void test_converttostr(void)
1461 {
1462     IDataConvert *convert;
1463     HRESULT hr;
1464     char dst[100];
1465     BYTE src[64];
1466     DBSTATUS dst_status;
1467     DBLENGTH dst_len;
1468     static const WCHAR ten[] = {'1','0',0};
1469     static const char ten_a[] = "10";
1470     static const char fourthreetwoone[] = "4321";
1471     static const char guid_str[] = "{0C733A8D-2A1C-11CE-ADE5-00AA0044773D}";
1472     static const char hexunpacked_a[] = "57696E6500";
1473     static const char hexpacked_a[] = "Wine";
1474     BSTR b;
1475
1476     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1477     if(FAILED(hr))
1478     {
1479         win_skip("Unable to load oledb conversion library\n");
1480         return;
1481     }
1482
1483
1484     memset(dst, 0xcc, sizeof(dst));
1485     dst_len = 0x1234;
1486     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1487     ok(hr == S_OK, "got %08x\n", hr);
1488     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1489     ok(dst_len == 0, "got %ld\n", dst_len);
1490     ok(dst[0] == 0, "got %02x\n", dst[0]);
1491     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1492
1493     memset(dst, 0xcc, sizeof(dst));
1494     dst_len = 0x1234;
1495     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1496     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1497     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1498     ok(dst_len == 0x1234, "got %ld\n", dst_len);
1499     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1500
1501     *(short *)src = 4321;
1502     dst_len = 0x1234;
1503     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1504     ok(hr == S_OK, "got %08x\n", hr);
1505     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1506     ok(dst_len == 4, "got %ld\n", dst_len);
1507     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1508
1509     *(short *)src = 4321;
1510     memset(dst, 0xcc, sizeof(dst));
1511     dst_len = 0x1234;
1512     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1513     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1514     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1515     ok(dst_len == 4, "got %ld\n", dst_len);
1516     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1517
1518     *(short *)src = 4321;
1519     memset(dst, 0xcc, sizeof(dst));
1520     dst_len = 0x1234;
1521     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1522     ok(hr == S_OK, "got %08x\n", hr);
1523     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1524     ok(dst_len == 4, "got %ld\n", dst_len);
1525     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1526
1527     *(short *)src = 4321;
1528     memset(dst, 0xcc, sizeof(dst));
1529     dst_len = 0x1234;
1530     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1531     ok(hr == S_OK, "got %08x\n", hr);
1532     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1533     ok(dst_len == 4, "got %ld\n", dst_len);
1534     ok(dst[0] == '4', "got %02x\n", dst[0]);
1535     ok(dst[1] == 0, "got %02x\n", dst[1]);
1536     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1537
1538     *(short *)src = 4321;
1539     memset(dst, 0xcc, sizeof(dst));
1540     dst_len = 0x1234;
1541     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1542     ok(hr == S_OK, "got %08x\n", hr);
1543     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1544     ok(dst_len == 4, "got %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     *(short *)src = 4321;
1549     memset(dst, 0xcc, sizeof(dst));
1550     dst_len = 0x1234;
1551     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1552     ok(hr == S_OK, "got %08x\n", hr);
1553     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1554     ok(dst_len == 4, "got %ld\n", dst_len);
1555     ok(dst[0] == '4', "got %02x\n", dst[0]);
1556     ok(dst[1] == '3', "got %02x\n", dst[1]);
1557     ok(dst[2] == '2', "got %02x\n", dst[2]);
1558     ok(dst[3] == 0, "got %02x\n", dst[3]);
1559     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1560
1561
1562     *(int *)src = 4321;
1563     dst_len = 0x1234;
1564     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1565     ok(hr == S_OK, "got %08x\n", hr);
1566     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1567     ok(dst_len == 4, "got %ld\n", dst_len);
1568     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1569
1570     *(int *)src = 4321;
1571     memset(dst, 0xcc, sizeof(dst));
1572     dst_len = 0x1234;
1573     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1574     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1575     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1576     ok(dst_len == 4, "got %ld\n", dst_len);
1577     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1578
1579     *(int *)src = 4321;
1580     memset(dst, 0xcc, sizeof(dst));
1581     dst_len = 0x1234;
1582     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1583     ok(hr == S_OK, "got %08x\n", hr);
1584     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1585     ok(dst_len == 4, "got %ld\n", dst_len);
1586     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1587
1588     *(int *)src = 4321;
1589     memset(dst, 0xcc, sizeof(dst));
1590     dst_len = 0x1234;
1591     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1592     ok(hr == S_OK, "got %08x\n", hr);
1593     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1594     ok(dst_len == 4, "got %ld\n", dst_len);
1595     ok(dst[0] == '4', "got %02x\n", dst[0]);
1596     ok(dst[1] == 0, "got %02x\n", dst[1]);
1597     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1598
1599     *(int *)src = 4321;
1600     memset(dst, 0xcc, sizeof(dst));
1601     dst_len = 0x1234;
1602     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1603     ok(hr == S_OK, "got %08x\n", hr);
1604     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1605     ok(dst_len == 4, "got %ld\n", dst_len);
1606     ok(dst[0] == 0, "got %02x\n", dst[0]);
1607     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1608
1609     *(int *)src = 4321;
1610     memset(dst, 0xcc, sizeof(dst));
1611     dst_len = 0x1234;
1612     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1613     ok(hr == S_OK, "got %08x\n", hr);
1614     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1615     ok(dst_len == 4, "got %ld\n", dst_len);
1616     ok(dst[0] == '4', "got %02x\n", dst[0]);
1617     ok(dst[1] == '3', "got %02x\n", dst[1]);
1618     ok(dst[2] == '2', "got %02x\n", dst[2]);
1619     ok(dst[3] == 0, "got %02x\n", dst[3]);
1620     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1621
1622
1623     *(float *)src = 4321;
1624     dst_len = 0x1234;
1625     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1626     ok(hr == S_OK, "got %08x\n", hr);
1627     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1628     ok(dst_len == 4, "got %ld\n", dst_len);
1629     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1630
1631     *(float *)src = 4321;
1632     memset(dst, 0xcc, sizeof(dst));
1633     dst_len = 0x1234;
1634     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1635     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1636     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1637     ok(dst_len == 4, "got %ld\n", dst_len);
1638     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1639
1640     *(float *)src = 4321;
1641     memset(dst, 0xcc, sizeof(dst));
1642     dst_len = 0x1234;
1643     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1644     ok(hr == S_OK, "got %08x\n", hr);
1645     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1646     ok(dst_len == 4, "got %ld\n", dst_len);
1647     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1648
1649     *(float *)src = 4321;
1650     memset(dst, 0xcc, sizeof(dst));
1651     dst_len = 0x1234;
1652     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1653     ok(hr == S_OK, "got %08x\n", hr);
1654     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1655     ok(dst_len == 4, "got %ld\n", dst_len);
1656     ok(dst[0] == '4', "got %02x\n", dst[0]);
1657     ok(dst[1] == 0, "got %02x\n", dst[1]);
1658     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1659
1660     *(float *)src = 4321;
1661     memset(dst, 0xcc, sizeof(dst));
1662     dst_len = 0x1234;
1663     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1664     ok(hr == S_OK, "got %08x\n", hr);
1665     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1666     ok(dst_len == 4, "got %ld\n", dst_len);
1667     ok(dst[0] == 0, "got %02x\n", dst[0]);
1668     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1669
1670     *(float *)src = 4321;
1671     memset(dst, 0xcc, sizeof(dst));
1672     dst_len = 0x1234;
1673     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1674     ok(hr == S_OK, "got %08x\n", hr);
1675     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1676     ok(dst_len == 4, "got %ld\n", dst_len);
1677     ok(dst[0] == '4', "got %02x\n", dst[0]);
1678     ok(dst[1] == '3', "got %02x\n", dst[1]);
1679     ok(dst[2] == '2', "got %02x\n", dst[2]);
1680     ok(dst[3] == 0, "got %02x\n", dst[3]);
1681     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1682
1683
1684     *(double *)src = 4321;
1685     dst_len = 0x1234;
1686     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1687     ok(hr == S_OK, "got %08x\n", hr);
1688     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1689     ok(dst_len == 4, "got %ld\n", dst_len);
1690     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1691
1692     *(double *)src = 4321;
1693     memset(dst, 0xcc, sizeof(dst));
1694     dst_len = 0x1234;
1695     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1696     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1697     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1698     ok(dst_len == 4, "got %ld\n", dst_len);
1699     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1700
1701     *(double *)src = 4321;
1702     memset(dst, 0xcc, sizeof(dst));
1703     dst_len = 0x1234;
1704     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1705     ok(hr == S_OK, "got %08x\n", hr);
1706     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1707     ok(dst_len == 4, "got %ld\n", dst_len);
1708     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1709
1710     *(double *)src = 4321;
1711     memset(dst, 0xcc, sizeof(dst));
1712     dst_len = 0x1234;
1713     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1714     ok(hr == S_OK, "got %08x\n", hr);
1715     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1716     ok(dst_len == 4, "got %ld\n", dst_len);
1717     ok(dst[0] == '4', "got %02x\n", dst[0]);
1718     ok(dst[1] == 0, "got %02x\n", dst[1]);
1719     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1720
1721     *(double *)src = 4321;
1722     memset(dst, 0xcc, sizeof(dst));
1723     dst_len = 0x1234;
1724     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1725     ok(hr == S_OK, "got %08x\n", hr);
1726     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1727     ok(dst_len == 4, "got %ld\n", dst_len);
1728     ok(dst[0] == 0, "got %02x\n", dst[0]);
1729     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1730
1731     *(double *)src = 4321;
1732     memset(dst, 0xcc, sizeof(dst));
1733     dst_len = 0x1234;
1734     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1735     ok(hr == S_OK, "got %08x\n", hr);
1736     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1737     ok(dst_len == 4, "got %ld\n", dst_len);
1738     ok(dst[0] == '4', "got %02x\n", dst[0]);
1739     ok(dst[1] == '3', "got %02x\n", dst[1]);
1740     ok(dst[2] == '2', "got %02x\n", dst[2]);
1741     ok(dst[3] == 0, "got %02x\n", dst[3]);
1742     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1743
1744
1745
1746     memset(src, 0, sizeof(src));
1747     ((CY*)src)->int64 = 43210000;
1748     memset(dst, 0xcc, sizeof(dst));
1749     dst_len = 0x1234;
1750     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1751     ok(hr == S_OK, "got %08x\n", hr);
1752     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1753     ok(dst_len == 4, "got %ld\n", dst_len);
1754     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1755
1756
1757
1758     memset(src, 0, sizeof(src));
1759     *(signed char *)src = 10;
1760     dst_len = 0x1234;
1761     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1762     ok(hr == S_OK, "got %08x\n", hr);
1763     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1764     ok(dst_len == 2, "got %ld\n", dst_len);
1765     ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1766
1767     memset(src, 0, sizeof(src));
1768     *(unsigned char *)src = 10;
1769     dst_len = 0x1234;
1770     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1771     ok(hr == S_OK, "got %08x\n", hr);
1772     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1773     ok(dst_len == 2, "got %ld\n", dst_len);
1774     ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1775
1776     memset(src, 0, sizeof(src));
1777     *(unsigned short *)src = 4321;
1778     dst_len = 0x1234;
1779     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1780     ok(hr == S_OK, "got %08x\n", hr);
1781     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1782     ok(dst_len == 4, "got %ld\n", dst_len);
1783     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1784
1785     memset(src, 0, sizeof(src));
1786     *(unsigned int *)src = 4321;
1787     dst_len = 0x1234;
1788     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1789     ok(hr == S_OK, "got %08x\n", hr);
1790     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1791     ok(dst_len == 4, "got %ld\n", dst_len);
1792     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1793
1794     memset(src, 0, sizeof(src));
1795     ((LARGE_INTEGER*)src)->QuadPart = 4321;
1796     dst_len = 0x1234;
1797     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1798     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1799     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1800     ok(broken(dst_len == 0x1234) || dst_len == 4 /* W2K+ */, "got %ld\n", dst_len);
1801     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1802
1803     memset(src, 0, sizeof(src));
1804     ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1805     dst_len = 0x1234;
1806     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1807     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1808     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1809     ok(broken(dst_len == 0x1234) || dst_len == 4 /* W2K+ */, "got %ld\n", dst_len);
1810     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1811
1812
1813
1814     memset(src, 0, sizeof(src));
1815     memcpy(src, &IID_IDataConvert, sizeof(GUID));
1816     memset(dst, 0xcc, sizeof(dst));
1817     dst_len = 0x1234;
1818     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_STR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1819     ok(hr == S_OK, "got %08x\n", hr);
1820     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1821     ok(dst_len == 38, "got %ld\n", dst_len);
1822     ok(!lstrcmpA(dst, guid_str), "got %s\n", dst);
1823
1824
1825
1826     b = SysAllocString(ten);
1827     *(BSTR *)src = b;
1828     memset(dst, 0xcc, sizeof(dst));
1829     dst_len = 0x1234;
1830     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1831     ok(hr == S_OK, "got %08x\n", hr);
1832     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1833     ok(dst_len == 2, "got %ld\n", dst_len);
1834     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1835     SysFreeString(b);
1836
1837     memcpy(src, ten, sizeof(ten));
1838     memset(dst, 0xcc, sizeof(dst));
1839     dst_len = 0x1234;
1840     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1841     ok(hr == S_OK, "got %08x\n", hr);
1842     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1843     ok(dst_len == 1, "got %ld\n", dst_len);
1844     ok(dst[0] == '1', "got %02x\n", dst[0]);
1845     ok(dst[1] == 0, "got %02x\n", dst[1]);
1846
1847     memcpy(src, ten, sizeof(ten));
1848     memset(dst, 0xcc, sizeof(dst));
1849     dst_len = 0x1234;
1850     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1851     ok(hr == S_OK, "got %08x\n", hr);
1852     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1853     ok(dst_len == 2, "got %ld\n", dst_len);
1854     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1855
1856     memcpy(src, ten, sizeof(ten));
1857     memset(dst, 0xcc, sizeof(dst));
1858     dst_len = 0x1234;
1859     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1860     ok(hr == S_OK, "got %08x\n", hr);
1861     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1862     ok(dst_len == 2, "got %ld\n", dst_len);
1863     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1864
1865     memcpy(src, ten_a, sizeof(ten_a));
1866     memset(dst, 0xcc, sizeof(dst));
1867     dst_len = 0x1234;
1868     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1869     ok(hr == S_OK, "got %08x\n", hr);
1870     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1871     ok(dst_len == 2, "got %ld\n", dst_len);
1872     ok(dst[0] == '1', "got %02x\n", dst[0]);
1873     ok(dst[1] == '0', "got %02x\n", dst[1]);
1874     ok(dst[2] == 0, "got %02x\n", dst[2]);
1875     ok(dst[3] == (char)0xcc, "got %02x\n", dst[3]);
1876
1877     memcpy(src, ten_a, sizeof(ten_a));
1878     memset(dst, 0xcc, sizeof(dst));
1879     dst_len = 0x1234;
1880     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1881     ok(hr == S_OK, "got %08x\n", hr);
1882     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1883     ok(dst_len == 4, "got %ld\n", dst_len);
1884     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1885
1886     memcpy(src, ten_a, sizeof(ten_a));
1887     memset(dst, 0xcc, sizeof(dst));
1888     dst_len = 0x1234;
1889     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1890     ok(hr == S_OK, "got %08x\n", hr);
1891     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1892     ok(dst_len == 2, "got %ld\n", dst_len);
1893     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1894
1895
1896
1897     /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1898     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1899     memset(dst, 0xcc, sizeof(dst));
1900     dst_len = 0x1234;
1901     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, sizeof(hexpacked_a), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1902     ok(hr == S_OK, "got %08x\n", hr);
1903     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1904     ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1905     ok(!lstrcmpA(hexunpacked_a, dst), "got %s\n", dst);
1906     ok(dst[sizeof(hexpacked_a)/sizeof(char) * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1907
1908     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1909     memset(dst, 0xcc, sizeof(dst));
1910     dst_len = 0x1234;
1911     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1912     ok(hr == S_OK, "got %08x\n", hr);
1913     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1914     ok(dst_len == 0, "got %ld\n", dst_len);
1915     ok(dst[0] == 0, "not null terminated\n");
1916     ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1917
1918     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1919     memset(dst, 0xcc, sizeof(dst));
1920     dst_len = 0x1234;
1921     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1922     ok(hr == S_OK, "got %08x\n", hr);
1923     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1924     ok(dst_len == 2 * sizeof(char) * 4, "got %ld\n", dst_len);
1925     ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1926     ok(dst[2 * 4] == 0, "not null terminated\n");
1927     ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1928
1929     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1930     memset(dst, 0xcc, sizeof(dst));
1931     dst_len = 0x1234;
1932     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);
1933     ok(hr == S_OK, "got %08x\n", hr);
1934     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1935     ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1936     ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1937     ok(dst[2 * 4] == 0, "not null terminated\n");
1938     ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1939
1940     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1941     memset(dst, 0xcc, sizeof(dst));
1942     dst_len = 0x1234;
1943     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);
1944     ok(hr == S_OK, "got %08x\n", hr);
1945     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1946     ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1947     ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 - 2 ), "got %s\n", dst);
1948     ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1949     ok(dst[2 * 4] == (char)0xcc, "clobbered buffer\n");
1950
1951     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1952     memset(dst, 0xcc, sizeof(dst));
1953     dst_len = 0x1234;
1954     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1955     ok(hr == S_OK, "got %08x\n", hr);
1956     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1957     ok(dst_len == 0, "got %ld\n", dst_len);
1958     ok(dst[0] == 0, "not null terminated\n");
1959     ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1960
1961     IDataConvert_Release(convert);
1962 }
1963
1964 static void test_converttobyrefwstr(void)
1965 {
1966     IDataConvert *convert;
1967     HRESULT hr;
1968     WCHAR *dst;
1969     BYTE src[20];
1970     DBSTATUS dst_status;
1971     DBLENGTH dst_len;
1972     static const WCHAR ten[] = {'1','0',0};
1973     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1974     BSTR b;
1975
1976     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1977     if(FAILED(hr))
1978     {
1979         win_skip("Unable to load oledb conversion library\n");
1980         return;
1981     }
1982
1983     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1984     ok(hr == S_OK, "got %08x\n", hr);
1985     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1986     ok(dst_len == 0, "got %ld\n", dst_len);
1987     ok(dst[0] == 0, "got %04x\n", dst[0]);
1988     CoTaskMemFree(dst);
1989
1990     dst = (void*)0x12345678;
1991     dst_len = 0x1234;
1992     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1993     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1994     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1995     ok(dst_len == 0x1234, "got %ld\n", dst_len);
1996     ok(dst == (void*)0x12345678, "got %p\n", dst);
1997
1998     *(short *)src = 4321;
1999     dst_len = 0x1234;
2000     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2001     ok(hr == S_OK, "got %08x\n", hr);
2002     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2003     ok(dst_len == 8, "got %ld\n", dst_len);
2004     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
2005     CoTaskMemFree(dst);
2006
2007     *(short *)src = 4321;
2008     dst_len = 0x1234;
2009     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, 0, 0, &dst_status, 0, 0, 0);
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 == 8, "got %ld\n", dst_len);
2013     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
2014     CoTaskMemFree(dst);
2015
2016     b = SysAllocString(ten);
2017     *(BSTR *)src = b;
2018     dst_len = 0x1234;
2019     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2020     ok(hr == S_OK, "got %08x\n", hr);
2021     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2022     ok(dst_len == 4, "got %ld\n", dst_len);
2023     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
2024     CoTaskMemFree(dst);
2025     SysFreeString(b);
2026
2027     memcpy(src, ten, sizeof(ten));
2028     dst_len = 0x1234;
2029     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2030     ok(hr == S_OK, "got %08x\n", hr);
2031     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2032     ok(dst_len == 2, "got %ld\n", dst_len);
2033     ok(dst[0] == '1', "got %02x\n", dst[0]);
2034     ok(dst[1] == 0, "got %02x\n", dst[1]);
2035     CoTaskMemFree(dst);
2036
2037     memcpy(src, ten, sizeof(ten));
2038     dst_len = 0x1234;
2039     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2040     ok(hr == S_OK, "got %08x\n", hr);
2041     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2042     ok(dst_len == 4, "got %ld\n", dst_len);
2043     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
2044     CoTaskMemFree(dst);
2045
2046     memcpy(src, ten, sizeof(ten));
2047     dst_len = 0x1234;
2048     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
2049     ok(hr == S_OK, "got %08x\n", hr);
2050     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2051     ok(dst_len == 4, "got %ld\n", dst_len);
2052     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
2053     CoTaskMemFree(dst);
2054
2055     IDataConvert_Release(convert);
2056 }
2057
2058 static void test_converttoguid(void)
2059 {
2060     IDataConvert *convert;
2061     HRESULT hr;
2062     GUID dst;
2063     BYTE src[20];
2064     DBSTATUS dst_status;
2065     DBLENGTH dst_len;
2066
2067     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2068     if(FAILED(hr))
2069     {
2070         win_skip("Unable to load oledb conversion library\n");
2071         return;
2072     }
2073
2074     dst = IID_IDCInfo;
2075     dst_len = 0x1234;
2076     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2077     ok(hr == S_OK, "got %08x\n", hr);
2078     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2079     ok(dst_len == sizeof(GUID), "got %ld\n", dst_len);
2080     ok(IsEqualGUID(&dst, &GUID_NULL), "didn't get GUID_NULL\n");
2081
2082     dst = IID_IDCInfo;
2083     dst_len = 0x1234;
2084     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2085     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2086     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2087     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2088     ok(IsEqualGUID(&dst, &IID_IDCInfo), "dst has changed\n");
2089
2090     dst = IID_IDCInfo;
2091     memcpy(src, &IID_IDataConvert, sizeof(GUID));
2092     dst_len = 0x1234;
2093     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2094     ok(hr == S_OK, "got %08x\n", hr);
2095     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2096     ok(dst_len == sizeof(GUID), "got %ld\n", dst_len);
2097     ok(IsEqualGUID(&dst, &IID_IDataConvert), "didn't get IID_IDataConvert\n");
2098
2099     IDataConvert_Release(convert);
2100 }
2101
2102 static void test_converttofiletime(void)
2103 {
2104     IDataConvert *convert;
2105     HRESULT hr;
2106     FILETIME dst;
2107     BYTE src[20];
2108     DBSTATUS dst_status;
2109     DBLENGTH dst_len;
2110
2111     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2112     if(FAILED(hr))
2113     {
2114         win_skip("Unable to load oledb conversion library\n");
2115         return;
2116     }
2117
2118     memset(&dst, 0xcc, sizeof(dst));
2119     ((FILETIME *)src)->dwLowDateTime = 0x12345678;
2120     ((FILETIME *)src)->dwHighDateTime = 0x9abcdef0;
2121     dst_len = 0x1234;
2122     hr = IDataConvert_DataConvert(convert, DBTYPE_FILETIME, DBTYPE_FILETIME, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2123     ok(hr == S_OK ||
2124        broken(hr == DB_E_BADBINDINFO), /* win98 */
2125        "got %08x\n", hr);
2126     if(SUCCEEDED(hr))
2127     {
2128         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2129         ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2130         ok(dst.dwLowDateTime == 0x12345678, "got %08x\n", dst.dwLowDateTime);
2131         ok(dst.dwHighDateTime == 0x9abcdef0, "got %08x\n", dst.dwHighDateTime);
2132     }
2133
2134     IDataConvert_Release(convert);
2135 }
2136
2137 static void test_converttoui1(void)
2138 {
2139     IDataConvert *convert;
2140     HRESULT hr;
2141     BYTE dst;
2142     BYTE src[20];
2143     DBSTATUS dst_status;
2144     DBLENGTH dst_len;
2145
2146     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2147     if(FAILED(hr))
2148     {
2149         win_skip("Unable to load oledb conversion library\n");
2150         return;
2151     }
2152
2153     dst = 0x12;
2154     dst_len = 0x1234;
2155     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2156     ok(hr == S_OK, "got %08x\n", hr);
2157     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2158     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2159     ok(dst == 0, "got %08x\n", dst);
2160
2161     dst = 0x12;
2162     dst_len = 0x1234;
2163     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2164     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2165     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2166     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2167     ok(dst == 0x12, "got %08x\n", dst);
2168
2169     dst = 0x12;
2170     src[0] = 0x43;
2171     dst_len = 0x1234;
2172     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2173     ok(hr == S_OK, "got %08x\n", hr);
2174     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2175     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2176     ok(dst == 0x43, "got %08x\n", dst);
2177
2178     dst = 0x12;
2179     src[0] = 0xfe;
2180     dst_len = 0x1234;
2181     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2182     ok(hr == S_OK, "got %08x\n", hr);
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 == 0xfe, "got %08x\n", dst);
2186
2187     IDataConvert_Release(convert);
2188 }
2189
2190 static void test_converttoui4(void)
2191 {
2192     IDataConvert *convert;
2193     HRESULT hr;
2194     DWORD dst;
2195     BYTE src[20];
2196     DBSTATUS dst_status;
2197     DBLENGTH dst_len;
2198
2199     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2200     if(FAILED(hr))
2201     {
2202         win_skip("Unable to load oledb conversion library\n");
2203         return;
2204     }
2205
2206     dst = 0x12345678;
2207     dst_len = 0x1234;
2208     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2209     ok(hr == S_OK, "got %08x\n", hr);
2210     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2211     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2212     ok(dst == 0, "got %08x\n", dst);
2213
2214     dst = 0x12345678;
2215     dst_len = 0x1234;
2216     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2217     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2218     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2219     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2220     ok(dst == 0x12345678, "got %08x\n", dst);
2221
2222     dst = 0x12345678;
2223     *(DWORD*)src = 0x87654321;
2224     dst_len = 0x1234;
2225     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2226     ok(hr == S_OK, "got %08x\n", hr);
2227     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2228     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2229     ok(dst == 0x87654321, "got %08x\n", dst);
2230
2231     dst = 0x12345678;
2232     *(signed short *)src = 0x4321;
2233     dst_len = 0x1234;
2234     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2235     ok(hr == S_OK, "got %08x\n", hr);
2236     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2237     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2238     ok(dst == 0x4321, "got %08x\n", dst);
2239
2240     dst = 0x12345678;
2241     *(signed short *)src = -1;
2242     dst_len = 0x1234;
2243     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2244     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2245 todo_wine
2246     ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2247 todo_wine
2248     ok(broken(dst_len == sizeof(dst)) || dst_len == 0x1234 /* W2K+ */, "got %ld\n", dst_len);
2249     ok(dst == 0x12345678, "got %08x\n", dst);
2250
2251     IDataConvert_Release(convert);
2252 }
2253
2254 static void test_converttor4(void)
2255 {
2256     IDataConvert *convert;
2257     HRESULT hr;
2258     FLOAT dst;
2259     BYTE src[20];
2260     DBSTATUS dst_status;
2261     DBLENGTH dst_len;
2262
2263     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2264     if(FAILED(hr))
2265     {
2266         win_skip("Unable to load oledb conversion library\n");
2267         return;
2268     }
2269
2270     dst = 1.0;
2271     dst_len = 0x1234;
2272     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2273     ok(hr == S_OK, "got %08x\n", hr);
2274     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2275     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2276     ok(dst == 0.0, "got %f\n", dst);
2277
2278     dst = 1.0;
2279     dst_len = 0x1234;
2280     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2281     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2282     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2283     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2284     ok(dst == 1.0, "got %f\n", dst);
2285
2286     dst = 1.0;
2287     *(signed int*)src = 12345678;
2288     dst_len = 0x1234;
2289     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_R4, 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 == 12345678.0, "got %f\n", dst);
2294
2295     dst = 1.0;
2296     *(FLOAT *)src = 10.0;
2297     dst_len = 0x1234;
2298     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2299     ok(hr == S_OK, "got %08x\n", hr);
2300     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2301     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2302     ok(dst == 10.0, "got %f\n", dst);
2303
2304     IDataConvert_Release(convert);
2305 }
2306
2307 static void test_converttocy(void)
2308 {
2309     IDataConvert *convert;
2310     HRESULT hr;
2311     CY dst;
2312     BYTE src[20];
2313     DBSTATUS dst_status;
2314     DBLENGTH dst_len;
2315
2316     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2317     if(FAILED(hr))
2318     {
2319         win_skip("Unable to load oledb conversion library\n");
2320         return;
2321     }
2322
2323     dst.int64 = 0xcc;
2324     dst_len = 0x1234;
2325     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2326     ok(hr == S_OK, "got %08x\n", hr);
2327     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2328     ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2329     ok(dst.int64 == 0, "didn't get 0\n");
2330
2331     dst.int64 = 0xcc;
2332     dst_len = 0x1234;
2333     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2334     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2335     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2336     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2337     ok(dst.int64 == 0xcc, "dst changed\n");
2338
2339     dst.int64 = 0xcc;
2340     *(int*)src = 1234;
2341     dst_len = 0x1234;
2342     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2343     ok(hr == S_OK, "got %08x\n", hr);
2344     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2345     ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2346     ok(dst.int64 == 12340000, "got %d\n", dst.s.Lo);
2347
2348     dst.int64 = 0xcc;
2349     ((CY*)src)->int64 = 1234;
2350     dst_len = 0x1234;
2351     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2352     ok(hr == S_OK, "got %08x\n", hr);
2353     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2354     ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2355     ok(dst.int64 == 1234, "got %d\n", dst.s.Lo);
2356
2357     IDataConvert_Release(convert);
2358 }
2359
2360 static void test_converttoui8(void)
2361 {
2362     IDataConvert *convert;
2363     HRESULT hr;
2364     ULARGE_INTEGER dst;
2365     BYTE src[20];
2366     DBSTATUS dst_status;
2367     DBLENGTH dst_len;
2368
2369     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2370     if(FAILED(hr))
2371     {
2372         win_skip("Unable to load oledb conversion library\n");
2373         return;
2374     }
2375
2376     dst.QuadPart = 0xcc;
2377     dst_len = 0x1234;
2378     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2379     ok(hr == S_OK, "got %08x\n", hr);
2380     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2381     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2382     ok(dst.QuadPart == 0, "got %d\n", (int)dst.QuadPart);
2383
2384     dst.QuadPart = 0xcc;
2385     dst_len = 0x1234;
2386     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2387     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2388     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2389     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2390     ok(dst.QuadPart == 0xcc, "dst changed\n");
2391
2392     dst.QuadPart = 0xcc;
2393     *(int*)src = 1234;
2394     dst_len = 0x1234;
2395     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2396     ok(hr == S_OK, "got %08x\n", hr);
2397     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2398     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2399     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2400
2401     dst.QuadPart = 0xcc;
2402     *(int*)src = -1234;
2403     dst_len = 0x1234;
2404     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2405     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2406 todo_wine
2407     ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2408 todo_wine
2409     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2410     ok(dst.QuadPart == 0xcc, "got %d\n", (int)dst.QuadPart);
2411
2412     dst.QuadPart = 0xcc;
2413     ((ULARGE_INTEGER*)src)->QuadPart = 1234;
2414     dst_len = 0x1234;
2415     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2416     ok(hr == S_OK, "got %08x\n", hr);
2417     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2418     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2419     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2420
2421     IDataConvert_Release(convert);
2422 }
2423
2424 START_TEST(convert)
2425 {
2426     OleInitialize(NULL);
2427     test_dcinfo();
2428     test_canconvert();
2429     test_converttoi2();
2430     test_converttoi4();
2431     test_converttostr();
2432     test_converttobstr();
2433     test_converttowstr();
2434     test_converttobyrefwstr();
2435     test_converttoguid();
2436     test_converttoui1();
2437     test_converttoui4();
2438     test_converttor4();
2439     test_converttofiletime();
2440     test_converttocy();
2441     test_converttoui8();
2442     OleUninitialize();
2443 }