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