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