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