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