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     /* src_status = DBSTATUS_S_ISNULL */
 889     i4 = 0x12345678;
 890     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), DBSTATUS_S_ISNULL, &dst_status, 0, 0, 0);
 891     ok(hr == S_OK, "got %08x\n", hr);
 892     ok(dst_status == DBSTATUS_S_ISNULL, "got %08x\n", dst_status);
 893     ok(dst_len == 0, "got %ld\n", dst_len);
 894
 895 }
 896
 897 static void test_converttoi8(void)
 898 {
 899     HRESULT hr;
 900     LARGE_INTEGER dst;
 901     BYTE src[20];
 902     DBSTATUS dst_status;
 903     DBLENGTH dst_len;
 904     static const WCHAR ten[] = {'1','0',0};
 905     BSTR b;
 906
 907     dst.QuadPart = 0xcc;
 908     ((ULARGE_INTEGER*)src)->QuadPart = 1234;
 909     dst_len = 0x1234;
 910     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 911     ok(hr == S_OK, "got %08x\n", hr);
 912     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 913     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 914     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
 915
 916     dst.QuadPart = 0xcc;
 917     ((ULARGE_INTEGER*)src)->QuadPart = 1234;
 918     b = SysAllocString(ten);
 919     *(BSTR *)src = b;
 920     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_I8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 921     ok(hr == S_OK, "got %08x\n", hr);
 922     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 923     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 924     ok(dst.QuadPart == 10, "got %d\n", (int)dst.QuadPart);
 925     SysFreeString(b);
 926 }
 927
 928 static void test_converttobstr(void)
 929 {
 930     HRESULT hr;
 931     BSTR dst;
 932     BYTE src[20];
 933     DBSTATUS dst_status;
 934     DBLENGTH dst_len;
 935     static const WCHAR ten[] = {'1','0',0};
 936     VARIANT v;
 937     BSTR b;
 938
 939     dst_len = 0x1234;
 940     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 941     ok(hr == S_OK, "got %08x\n", hr);
 942     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 943     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 944     ok(dst != NULL, "got %p\n", dst);
 945     ok(SysStringLen(dst) == 0, "got %d\n", SysStringLen(dst));
 946     SysFreeString(dst);
 947
 948     dst = (void*)0x1234;
 949     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 950     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 951     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 952     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 953     ok(dst == (void*)0x1234, "got %p\n", dst);
 954
 955     *(short *)src = 4321;
 956     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 957     ok(hr == S_OK, "got %08x\n", hr);
 958     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 959     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 960     ok(dst != NULL, "got %p\n", dst);
 961     ok(SysStringLen(dst) == 4, "got %d\n", SysStringLen(dst));
 962     SysFreeString(dst);
 963
 964     b = SysAllocString(ten);
 965     *(BSTR *)src = b;
 966     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 967     ok(hr == S_OK, "got %08x\n", hr);
 968     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 969     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 970     ok(dst != NULL, "got %p\n", dst);
 971     ok(dst != b, "got %p src %p\n", dst, b);
 972     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
 973     SysFreeString(dst);
 974     SysFreeString(b);
 975
 976     b = SysAllocString(ten);
 977     V_VT(&v) = VT_BSTR;
 978     V_BSTR(&v) = b;
 979     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_BSTR, 0, &dst_len, &v, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 980     ok(hr == S_OK, "got %08x\n", hr);
 981     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 982     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
 983     ok(dst != NULL, "got %p\n", dst);
 984     ok(dst != b, "got %p src %p\n", dst, b);
 985     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
 986     SysFreeString(dst);
 987     SysFreeString(b);
 988
 989     V_VT(&v) = VT_NULL;
 990     dst = (void*)0x1234;
 991     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_BSTR, 0, &dst_len, &v, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 992     ok(hr == S_OK, "got %08x\n", hr);
 993     ok(dst_status == DBSTATUS_S_ISNULL, "got %08x\n", dst_status);
 994     ok(dst_len == sizeof(BSTR), "got %ld\n", dst_len);
 995     ok(dst == (void*)0x1234, "got %p\n", dst);
 996 }
 997
 998 static void test_converttowstr(void)
 999 {
1000     HRESULT hr;
1001     WCHAR dst[100];
1002     BYTE src[20];
1003     DBSTATUS dst_status;
1004     DBLENGTH dst_len;
1005     static const WCHAR ten[] = {'1','0',0};
1006     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1007     static const WCHAR guid_str[] = {
1008         '{','0','C','7','3','3','A','8','D','-','2','A','1','C','-','1','1','C','E','-',
1009         'A','D','E','5','-','0','0','A','A','0','0','4','4','7','7','3','D','}',0};
1010     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 };
1011     static const WCHAR hexpacked_w[] = {'W','i','n','e', 0 };
1012     BSTR b;
1013
1014     memset(dst, 0xcc, sizeof(dst));
1015     dst_len = 0x1234;
1016     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1017     ok(hr == S_OK, "got %08x\n", hr);
1018     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1019     ok(dst_len == 0, "got %ld\n", dst_len);
1020     ok(dst[0] == 0, "got %02x\n", dst[0]);
1021     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1022
1023     memset(dst, 0xcc, sizeof(dst));
1024     dst_len = 0x1234;
1025     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1026     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1027     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1028     ok(dst_len == 0x1234, "got %ld\n", dst_len);
1029     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1030
1031     *(short *)src = 4321;
1032     dst_len = 0x1234;
1033     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1034     ok(hr == S_OK, "got %08x\n", hr);
1035     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1036     ok(dst_len == 8, "got %ld\n", dst_len);
1037     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1038
1039     *(short *)src = 4321;
1040     memset(dst, 0xcc, sizeof(dst));
1041     dst_len = 0x1234;
1042     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1043     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1044     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1045     ok(dst_len == 8, "got %ld\n", dst_len);
1046     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1047
1048     *(short *)src = 4321;
1049     memset(dst, 0xcc, sizeof(dst));
1050     dst_len = 0x1234;
1051     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1052     ok(hr == S_OK, "got %08x\n", hr);
1053     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1054     ok(dst_len == 8, "got %ld\n", dst_len);
1055     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1056
1057     *(short *)src = 4321;
1058     memset(dst, 0xcc, sizeof(dst));
1059     dst_len = 0x1234;
1060     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1061     ok(hr == S_OK, "got %08x\n", hr);
1062     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1063     ok(dst_len == 8, "got %ld\n", dst_len);
1064     ok(dst[0] == '4', "got %02x\n", dst[0]);
1065     ok(dst[1] == 0, "got %02x\n", dst[1]);
1066     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1067
1068     *(short *)src = 4321;
1069     memset(dst, 0xcc, sizeof(dst));
1070     dst_len = 0x1234;
1071     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1072     ok(hr == S_OK, "got %08x\n", hr);
1073     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1074     ok(dst_len == 8, "got %ld\n", dst_len);
1075     ok(dst[0] == 0, "got %02x\n", dst[0]);
1076     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1077
1078     *(short *)src = 4321;
1079     memset(dst, 0xcc, sizeof(dst));
1080     dst_len = 0x1234;
1081     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1082     ok(hr == S_OK, "got %08x\n", hr);
1083     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1084     ok(dst_len == 8, "got %ld\n", dst_len);
1085     ok(dst[0] == '4', "got %02x\n", dst[0]);
1086     ok(dst[1] == '3', "got %02x\n", dst[1]);
1087     ok(dst[2] == '2', "got %02x\n", dst[2]);
1088     ok(dst[3] == 0, "got %02x\n", dst[3]);
1089     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1090
1091
1092
1093     *(int *)src = 4321;
1094     dst_len = 0x1234;
1095     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1096     ok(hr == S_OK, "got %08x\n", hr);
1097     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1098     ok(dst_len == 8, "got %ld\n", dst_len);
1099     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1100
1101     *(int *)src = 4321;
1102     memset(dst, 0xcc, sizeof(dst));
1103     dst_len = 0x1234;
1104     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1105     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1106     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "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     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1113     ok(hr == S_OK, "got %08x\n", hr);
1114     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1115     ok(dst_len == 8, "got %ld\n", dst_len);
1116     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1117
1118     *(int *)src = 4321;
1119     memset(dst, 0xcc, sizeof(dst));
1120     dst_len = 0x1234;
1121     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1122     ok(hr == S_OK, "got %08x\n", hr);
1123     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1124     ok(dst_len == 8, "got %ld\n", dst_len);
1125     ok(dst[0] == '4', "got %02x\n", dst[0]);
1126     ok(dst[1] == 0, "got %02x\n", dst[1]);
1127     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1128
1129     *(int *)src = 4321;
1130     memset(dst, 0xcc, sizeof(dst));
1131     dst_len = 0x1234;
1132     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1133     ok(hr == S_OK, "got %08x\n", hr);
1134     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1135     ok(dst_len == 8, "got %ld\n", dst_len);
1136     ok(dst[0] == 0, "got %02x\n", dst[0]);
1137     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1138
1139     *(int *)src = 4321;
1140     memset(dst, 0xcc, sizeof(dst));
1141     dst_len = 0x1234;
1142     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1143     ok(hr == S_OK, "got %08x\n", hr);
1144     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1145     ok(dst_len == 8, "got %ld\n", dst_len);
1146     ok(dst[0] == '4', "got %02x\n", dst[0]);
1147     ok(dst[1] == '3', "got %02x\n", dst[1]);
1148     ok(dst[2] == '2', "got %02x\n", dst[2]);
1149     ok(dst[3] == 0, "got %02x\n", dst[3]);
1150     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1151
1152
1153
1154     *(float *)src = 4321;
1155     dst_len = 0x1234;
1156     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1157     ok(hr == S_OK, "got %08x\n", hr);
1158     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1159     ok(dst_len == 8, "got %ld\n", dst_len);
1160     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1161
1162     *(float *)src = 4321;
1163     memset(dst, 0xcc, sizeof(dst));
1164     dst_len = 0x1234;
1165     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1166     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1167     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "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     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1174     ok(hr == S_OK, "got %08x\n", hr);
1175     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1176     ok(dst_len == 8, "got %ld\n", dst_len);
1177     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1178
1179     *(float *)src = 4321;
1180     memset(dst, 0xcc, sizeof(dst));
1181     dst_len = 0x1234;
1182     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1183     ok(hr == S_OK, "got %08x\n", hr);
1184     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1185     ok(dst_len == 8, "got %ld\n", dst_len);
1186     ok(dst[0] == '4', "got %02x\n", dst[0]);
1187     ok(dst[1] == 0, "got %02x\n", dst[1]);
1188     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1189
1190     *(float *)src = 4321;
1191     memset(dst, 0xcc, sizeof(dst));
1192     dst_len = 0x1234;
1193     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1194     ok(hr == S_OK, "got %08x\n", hr);
1195     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1196     ok(dst_len == 8, "got %ld\n", dst_len);
1197     ok(dst[0] == 0, "got %02x\n", dst[0]);
1198     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1199
1200     *(float *)src = 4321;
1201     memset(dst, 0xcc, sizeof(dst));
1202     dst_len = 0x1234;
1203     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1204     ok(hr == S_OK, "got %08x\n", hr);
1205     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1206     ok(dst_len == 8, "got %ld\n", dst_len);
1207     ok(dst[0] == '4', "got %02x\n", dst[0]);
1208     ok(dst[1] == '3', "got %02x\n", dst[1]);
1209     ok(dst[2] == '2', "got %02x\n", dst[2]);
1210     ok(dst[3] == 0, "got %02x\n", dst[3]);
1211     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1212
1213
1214
1215     *(double *)src = 4321;
1216     dst_len = 0x1234;
1217     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1218     ok(hr == S_OK, "got %08x\n", hr);
1219     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1220     ok(dst_len == 8, "got %ld\n", dst_len);
1221     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1222
1223     *(double *)src = 4321;
1224     memset(dst, 0xcc, sizeof(dst));
1225     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1226     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1227     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1228     ok(dst_len == 8, "got %ld\n", dst_len);
1229     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1230
1231     *(double *)src = 4321;
1232     memset(dst, 0xcc, sizeof(dst));
1233     dst_len = 0x1234;
1234     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1235     ok(hr == S_OK, "got %08x\n", hr);
1236     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1237     ok(dst_len == 8, "got %ld\n", dst_len);
1238     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
1239
1240     *(double *)src = 4321;
1241     memset(dst, 0xcc, sizeof(dst));
1242     dst_len = 0x1234;
1243     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1244     ok(hr == S_OK, "got %08x\n", hr);
1245     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1246     ok(dst_len == 8, "got %ld\n", dst_len);
1247     ok(dst[0] == '4', "got %02x\n", dst[0]);
1248     ok(dst[1] == 0, "got %02x\n", dst[1]);
1249     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
1250
1251     *(double *)src = 4321;
1252     memset(dst, 0xcc, sizeof(dst));
1253     dst_len = 0x1234;
1254     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1255     ok(hr == S_OK, "got %08x\n", hr);
1256     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1257     ok(dst_len == 8, "got %ld\n", dst_len);
1258     ok(dst[0] == 0, "got %02x\n", dst[0]);
1259     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
1260
1261     *(double *)src = 4321;
1262     memset(dst, 0xcc, sizeof(dst));
1263     dst_len = 0x1234;
1264     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
1265     ok(hr == S_OK, "got %08x\n", hr);
1266     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1267     ok(dst_len == 8, "got %ld\n", dst_len);
1268     ok(dst[0] == '4', "got %02x\n", dst[0]);
1269     ok(dst[1] == '3', "got %02x\n", dst[1]);
1270     ok(dst[2] == '2', "got %02x\n", dst[2]);
1271     ok(dst[3] == 0, "got %02x\n", dst[3]);
1272     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1273
1274
1275
1276     memset(src, 0, sizeof(src));
1277     ((CY*)src)->int64 = 43210000;
1278     memset(dst, 0xcc, sizeof(dst));
1279     dst_len = 0x1234;
1280     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1281     ok(hr == S_OK, "got %08x\n", hr);
1282     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1283     ok(dst_len == 8, "got %ld\n", dst_len);
1284     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1285
1286
1287
1288     memset(src, 0, sizeof(src));
1289     *(signed char *)src = 10;
1290     dst_len = 0x1234;
1291     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1292     ok(hr == S_OK, "got %08x\n", hr);
1293     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1294     ok(dst_len == 4, "got %ld\n", dst_len);
1295     ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1296
1297     memset(src, 0, sizeof(src));
1298     *(unsigned char *)src = 10;
1299     dst_len = 0x1234;
1300     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1301     ok(hr == S_OK, "got %08x\n", hr);
1302     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1303     ok(dst_len == 4, "got %ld\n", dst_len);
1304     ok(!lstrcmpW(dst, ten), "got %s\n", wine_dbgstr_w(dst));
1305
1306     memset(src, 0, sizeof(src));
1307     *(unsigned short *)src = 4321;
1308     dst_len = 0x1234;
1309     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1310     ok(hr == S_OK, "got %08x\n", hr);
1311     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1312     ok(dst_len == 8, "got %ld\n", dst_len);
1313     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1314
1315     memset(src, 0, sizeof(src));
1316     *(unsigned int *)src = 4321;
1317     dst_len = 0x1234;
1318     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1319     ok(hr == S_OK, "got %08x\n", hr);
1320     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1321     ok(dst_len == 8, "got %ld\n", dst_len);
1322     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1323
1324     memset(src, 0, sizeof(src));
1325     ((LARGE_INTEGER*)src)->QuadPart = 4321;
1326     dst_len = 0x1234;
1327     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, 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     memset(src, 0, sizeof(src));
1334     ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1335     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1336     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1337     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1338     ok(broken(dst_len == 0x1234) || dst_len == 8 /* W2K+ */, "got %ld\n", dst_len);
1339     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1340
1341
1342
1343     memset(src, 0, sizeof(src));
1344     memcpy(src, &IID_IDataConvert, sizeof(GUID));
1345     memset(dst, 0xcc, sizeof(dst));
1346     dst_len = 0x1234;
1347     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1348     ok(hr == S_OK, "got %08x\n", hr);
1349     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1350     ok(dst_len == 76, "got %ld\n", dst_len);
1351     ok(!lstrcmpW(dst, guid_str), "got %s\n", wine_dbgstr_w(dst));
1352
1353
1354
1355     b = SysAllocString(ten);
1356     *(BSTR *)src = b;
1357     dst_len = 0x1234;
1358     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1359     ok(hr == S_OK, "got %08x\n", hr);
1360     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1361     ok(dst_len == 4, "got %ld\n", dst_len);
1362     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1363     SysFreeString(b);
1364
1365     memcpy(src, ten, sizeof(ten));
1366     dst_len = 0x1234;
1367     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1368     ok(hr == S_OK, "got %08x\n", hr);
1369     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1370     ok(dst_len == 2, "got %ld\n", dst_len);
1371     ok(dst[0] == '1', "got %02x\n", dst[0]);
1372     ok(dst[1] == 0, "got %02x\n", dst[1]);
1373
1374     memcpy(src, ten, sizeof(ten));
1375     dst_len = 0x1234;
1376     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
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     memcpy(src, ten, sizeof(ten));
1383     dst_len = 0x1234;
1384     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1385     ok(hr == S_OK, "got %08x\n", hr);
1386     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1387     ok(dst_len == 4, "got %ld\n", dst_len);
1388     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1389
1390
1391
1392     /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1393     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1394     memset(dst, 0xcc, sizeof(dst));
1395     dst_len = 0x1234;
1396     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1397     ok(hr == S_OK, "got %08x\n", hr);
1398     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1399     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1400     ok(!lstrcmpW(hexunpacked_w, dst), "got %s\n", wine_dbgstr_w(dst));
1401     ok(dst[sizeof(hexpacked_w)/sizeof(WCHAR) * 4 + 1] == 0xcccc, "clobbered buffer\n");
1402
1403     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1404     memset(dst, 0xcc, sizeof(dst));
1405     dst_len = 0x1234;
1406     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1407     ok(hr == S_OK, "got %08x\n", hr);
1408     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1409     ok(dst_len == 0, "got %ld\n", dst_len);
1410     ok(dst[0] == 0, "not null terminated\n");
1411     ok(dst[1] == 0xcccc, "clobbered buffer\n");
1412
1413     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1414     memset(dst, 0xcc, sizeof(dst));
1415     dst_len = 0x1234;
1416     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1417     ok(hr == S_OK, "got %08x\n", hr);
1418     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1419     ok(dst_len == 2 * sizeof(WCHAR) * 4, "got %ld\n", dst_len);
1420     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1421     ok(dst[2 * 4] == 0, "not null terminated\n");
1422     ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1423
1424     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1425     memset(dst, 0xcc, sizeof(dst));
1426     dst_len = 0x1234;
1427     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, 2 * sizeof(WCHAR) * 4 + sizeof(WCHAR), 0, &dst_status, 0, 0, 0);
1428     ok(hr == S_OK, "got %08x\n", hr);
1429     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1430     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1431     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 ), "got %s\n", wine_dbgstr_w(dst));
1432     ok(dst[2 * 4] == 0, "not null terminated\n");
1433     ok(dst[2 * 4 + 1] == 0xcccc, "clobbered buffer\n");
1434
1435     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1436     memset(dst, 0xcc, sizeof(dst));
1437     dst_len = 0x1234;
1438     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, 2 * sizeof(WCHAR) * 4 +1, 0, &dst_status, 0, 0, 0);
1439     ok(hr == S_OK, "got %08x\n", hr);
1440     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1441     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1442     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1443     ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1444     ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1445
1446     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1447     memset(dst, 0xcc, sizeof(dst));
1448     dst_len = 0x1234;
1449     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, sizeof(hexpacked_w), &dst_len, src, dst, 2 * sizeof(WCHAR) * 4, 0, &dst_status, 0, 0, 0);
1450     ok(hr == S_OK, "got %08x\n", hr);
1451     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1452     ok(dst_len == sizeof(hexpacked_w) * 4, "got %ld\n", dst_len);
1453     ok(!memcmp(hexunpacked_w, dst, 2 * sizeof(WCHAR) * 4 - 2 ), "got %s\n", wine_dbgstr_w(dst));
1454     ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1455     ok(dst[2 * 4] == 0xcccc, "clobbered buffer\n");
1456
1457     memcpy(src, hexpacked_w, sizeof(hexpacked_w));
1458     memset(dst, 0xcc, sizeof(dst));
1459     dst_len = 0x1234;
1460     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1461     ok(hr == S_OK, "got %08x\n", hr);
1462     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1463     ok(dst_len == 0, "got %ld\n", dst_len);
1464     ok(dst[0] == 0, "not null terminated\n");
1465     ok(dst[1] == 0xcccc, "clobbered buffer\n");
1466 }
1467
1468 static void test_converttostr(void)
1469 {
1470     HRESULT hr;
1471     char dst[100];
1472     BYTE src[64];
1473     DBSTATUS dst_status;
1474     DBLENGTH dst_len;
1475     static const WCHAR ten[] = {'1','0',0};
1476     static const char ten_a[] = "10";
1477     static const char fourthreetwoone[] = "4321";
1478     static const char guid_str[] = "{0C733A8D-2A1C-11CE-ADE5-00AA0044773D}";
1479     static const char hexunpacked_a[] = "57696E6500";
1480     static const char hexpacked_a[] = "Wine";
1481     BSTR b;
1482
1483     memset(dst, 0xcc, sizeof(dst));
1484     dst_len = 0x1234;
1485     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1486     ok(hr == S_OK, "got %08x\n", hr);
1487     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1488     ok(dst_len == 0, "got %ld\n", dst_len);
1489     ok(dst[0] == 0, "got %02x\n", dst[0]);
1490     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1491
1492     memset(dst, 0xcc, sizeof(dst));
1493     dst_len = 0x1234;
1494     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1495     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1496     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1497     ok(dst_len == 0x1234, "got %ld\n", dst_len);
1498     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1499
1500     *(short *)src = 4321;
1501     dst_len = 0x1234;
1502     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1503     ok(hr == S_OK, "got %08x\n", hr);
1504     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1505     ok(dst_len == 4, "got %ld\n", dst_len);
1506     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1507
1508     *(short *)src = 4321;
1509     memset(dst, 0xcc, sizeof(dst));
1510     dst_len = 0x1234;
1511     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1512     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1513     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1514     ok(dst_len == 4, "got %ld\n", dst_len);
1515     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1516
1517     *(short *)src = 4321;
1518     memset(dst, 0xcc, sizeof(dst));
1519     dst_len = 0x1234;
1520     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1521     ok(hr == S_OK, "got %08x\n", hr);
1522     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1523     ok(dst_len == 4, "got %ld\n", dst_len);
1524     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1525
1526     *(short *)src = 4321;
1527     memset(dst, 0xcc, sizeof(dst));
1528     dst_len = 0x1234;
1529     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1530     ok(hr == S_OK, "got %08x\n", hr);
1531     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1532     ok(dst_len == 4, "got %ld\n", dst_len);
1533     ok(dst[0] == '4', "got %02x\n", dst[0]);
1534     ok(dst[1] == 0, "got %02x\n", dst[1]);
1535     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1536
1537     *(short *)src = 4321;
1538     memset(dst, 0xcc, sizeof(dst));
1539     dst_len = 0x1234;
1540     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1541     ok(hr == S_OK, "got %08x\n", hr);
1542     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1543     ok(dst_len == 4, "got %ld\n", dst_len);
1544     ok(dst[0] == 0, "got %02x\n", dst[0]);
1545     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1546
1547     *(short *)src = 4321;
1548     memset(dst, 0xcc, sizeof(dst));
1549     dst_len = 0x1234;
1550     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1551     ok(hr == S_OK, "got %08x\n", hr);
1552     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1553     ok(dst_len == 4, "got %ld\n", dst_len);
1554     ok(dst[0] == '4', "got %02x\n", dst[0]);
1555     ok(dst[1] == '3', "got %02x\n", dst[1]);
1556     ok(dst[2] == '2', "got %02x\n", dst[2]);
1557     ok(dst[3] == 0, "got %02x\n", dst[3]);
1558     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1559
1560
1561     *(int *)src = 4321;
1562     dst_len = 0x1234;
1563     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1564     ok(hr == S_OK, "got %08x\n", hr);
1565     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1566     ok(dst_len == 4, "got %ld\n", dst_len);
1567     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1568
1569     *(int *)src = 4321;
1570     memset(dst, 0xcc, sizeof(dst));
1571     dst_len = 0x1234;
1572     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1573     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1574     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1575     ok(dst_len == 4, "got %ld\n", dst_len);
1576     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1577
1578     *(int *)src = 4321;
1579     memset(dst, 0xcc, sizeof(dst));
1580     dst_len = 0x1234;
1581     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1582     ok(hr == S_OK, "got %08x\n", hr);
1583     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1584     ok(dst_len == 4, "got %ld\n", dst_len);
1585     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1586
1587     *(int *)src = 4321;
1588     memset(dst, 0xcc, sizeof(dst));
1589     dst_len = 0x1234;
1590     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1591     ok(hr == S_OK, "got %08x\n", hr);
1592     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1593     ok(dst_len == 4, "got %ld\n", dst_len);
1594     ok(dst[0] == '4', "got %02x\n", dst[0]);
1595     ok(dst[1] == 0, "got %02x\n", dst[1]);
1596     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1597
1598     *(int *)src = 4321;
1599     memset(dst, 0xcc, sizeof(dst));
1600     dst_len = 0x1234;
1601     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1602     ok(hr == S_OK, "got %08x\n", hr);
1603     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1604     ok(dst_len == 4, "got %ld\n", dst_len);
1605     ok(dst[0] == 0, "got %02x\n", dst[0]);
1606     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1607
1608     *(int *)src = 4321;
1609     memset(dst, 0xcc, sizeof(dst));
1610     dst_len = 0x1234;
1611     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1612     ok(hr == S_OK, "got %08x\n", hr);
1613     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1614     ok(dst_len == 4, "got %ld\n", dst_len);
1615     ok(dst[0] == '4', "got %02x\n", dst[0]);
1616     ok(dst[1] == '3', "got %02x\n", dst[1]);
1617     ok(dst[2] == '2', "got %02x\n", dst[2]);
1618     ok(dst[3] == 0, "got %02x\n", dst[3]);
1619     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1620
1621
1622     *(float *)src = 4321;
1623     dst_len = 0x1234;
1624     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1625     ok(hr == S_OK, "got %08x\n", hr);
1626     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1627     ok(dst_len == 4, "got %ld\n", dst_len);
1628     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1629
1630     *(float *)src = 4321;
1631     memset(dst, 0xcc, sizeof(dst));
1632     dst_len = 0x1234;
1633     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1634     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1635     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1636     ok(dst_len == 4, "got %ld\n", dst_len);
1637     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1638
1639     *(float *)src = 4321;
1640     memset(dst, 0xcc, sizeof(dst));
1641     dst_len = 0x1234;
1642     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1643     ok(hr == S_OK, "got %08x\n", hr);
1644     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1645     ok(dst_len == 4, "got %ld\n", dst_len);
1646     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1647
1648     *(float *)src = 4321;
1649     memset(dst, 0xcc, sizeof(dst));
1650     dst_len = 0x1234;
1651     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1652     ok(hr == S_OK, "got %08x\n", hr);
1653     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1654     ok(dst_len == 4, "got %ld\n", dst_len);
1655     ok(dst[0] == '4', "got %02x\n", dst[0]);
1656     ok(dst[1] == 0, "got %02x\n", dst[1]);
1657     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1658
1659     *(float *)src = 4321;
1660     memset(dst, 0xcc, sizeof(dst));
1661     dst_len = 0x1234;
1662     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1663     ok(hr == S_OK, "got %08x\n", hr);
1664     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1665     ok(dst_len == 4, "got %ld\n", dst_len);
1666     ok(dst[0] == 0, "got %02x\n", dst[0]);
1667     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1668
1669     *(float *)src = 4321;
1670     memset(dst, 0xcc, sizeof(dst));
1671     dst_len = 0x1234;
1672     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1673     ok(hr == S_OK, "got %08x\n", hr);
1674     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1675     ok(dst_len == 4, "got %ld\n", dst_len);
1676     ok(dst[0] == '4', "got %02x\n", dst[0]);
1677     ok(dst[1] == '3', "got %02x\n", dst[1]);
1678     ok(dst[2] == '2', "got %02x\n", dst[2]);
1679     ok(dst[3] == 0, "got %02x\n", dst[3]);
1680     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1681
1682
1683     *(double *)src = 4321;
1684     dst_len = 0x1234;
1685     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1686     ok(hr == S_OK, "got %08x\n", hr);
1687     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1688     ok(dst_len == 4, "got %ld\n", dst_len);
1689     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1690
1691     *(double *)src = 4321;
1692     memset(dst, 0xcc, sizeof(dst));
1693     dst_len = 0x1234;
1694     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
1695     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1696     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
1697     ok(dst_len == 4, "got %ld\n", dst_len);
1698     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1699
1700     *(double *)src = 4321;
1701     memset(dst, 0xcc, sizeof(dst));
1702     dst_len = 0x1234;
1703     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
1704     ok(hr == S_OK, "got %08x\n", hr);
1705     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1706     ok(dst_len == 4, "got %ld\n", dst_len);
1707     ok(dst[0] == (char)0xcc, "got %02x\n", dst[0]);
1708
1709     *(double *)src = 4321;
1710     memset(dst, 0xcc, sizeof(dst));
1711     dst_len = 0x1234;
1712     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
1713     ok(hr == S_OK, "got %08x\n", hr);
1714     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1715     ok(dst_len == 4, "got %ld\n", dst_len);
1716     ok(dst[0] == '4', "got %02x\n", dst[0]);
1717     ok(dst[1] == 0, "got %02x\n", dst[1]);
1718     ok(dst[2] == (char)0xcc, "got %02x\n", dst[2]);
1719
1720     *(double *)src = 4321;
1721     memset(dst, 0xcc, sizeof(dst));
1722     dst_len = 0x1234;
1723     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 1, 0, &dst_status, 0, 0, 0);
1724     ok(hr == S_OK, "got %08x\n", hr);
1725     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1726     ok(dst_len == 4, "got %ld\n", dst_len);
1727     ok(dst[0] == 0, "got %02x\n", dst[0]);
1728     ok(dst[1] == (char)0xcc, "got %02x\n", dst[1]);
1729
1730     *(double *)src = 4321;
1731     memset(dst, 0xcc, sizeof(dst));
1732     dst_len = 0x1234;
1733     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_STR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
1734     ok(hr == S_OK, "got %08x\n", hr);
1735     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1736     ok(dst_len == 4, "got %ld\n", dst_len);
1737     ok(dst[0] == '4', "got %02x\n", dst[0]);
1738     ok(dst[1] == '3', "got %02x\n", dst[1]);
1739     ok(dst[2] == '2', "got %02x\n", dst[2]);
1740     ok(dst[3] == 0, "got %02x\n", dst[3]);
1741     ok(dst[4] == (char)0xcc, "got %02x\n", dst[4]);
1742
1743
1744
1745     memset(src, 0, sizeof(src));
1746     ((CY*)src)->int64 = 43210000;
1747     memset(dst, 0xcc, sizeof(dst));
1748     dst_len = 0x1234;
1749     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1750     ok(hr == S_OK, "got %08x\n", hr);
1751     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1752     ok(dst_len == 4, "got %ld\n", dst_len);
1753     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1754
1755
1756
1757     memset(src, 0, sizeof(src));
1758     *(signed char *)src = 10;
1759     dst_len = 0x1234;
1760     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1761     ok(hr == S_OK, "got %08x\n", hr);
1762     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1763     ok(dst_len == 2, "got %ld\n", dst_len);
1764     ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1765
1766     memset(src, 0, sizeof(src));
1767     *(unsigned char *)src = 10;
1768     dst_len = 0x1234;
1769     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1770     ok(hr == S_OK, "got %08x\n", hr);
1771     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1772     ok(dst_len == 2, "got %ld\n", dst_len);
1773     ok(!lstrcmpA(dst, ten_a), "got %s\n", dst);
1774
1775     memset(src, 0, sizeof(src));
1776     *(unsigned short *)src = 4321;
1777     dst_len = 0x1234;
1778     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1779     ok(hr == S_OK, "got %08x\n", hr);
1780     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1781     ok(dst_len == 4, "got %ld\n", dst_len);
1782     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1783
1784     memset(src, 0, sizeof(src));
1785     *(unsigned int *)src = 4321;
1786     dst_len = 0x1234;
1787     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1788     ok(hr == S_OK, "got %08x\n", hr);
1789     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1790     ok(dst_len == 4, "got %ld\n", dst_len);
1791     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1792
1793     memset(src, 0, sizeof(src));
1794     ((LARGE_INTEGER*)src)->QuadPart = 4321;
1795     dst_len = 0x1234;
1796     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1797     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1798     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1799     ok(broken(dst_len == 0x1234) || dst_len == 4 /* W2K+ */, "got %ld\n", dst_len);
1800     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1801
1802     memset(src, 0, sizeof(src));
1803     ((ULARGE_INTEGER*)src)->QuadPart = 4321;
1804     dst_len = 0x1234;
1805     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1806     ok(broken(DB_E_UNSUPPORTEDCONVERSION) || hr == S_OK /* W2K+ */, "got %08x\n", hr);
1807     ok(broken(dst_status == DBSTATUS_E_BADACCESSOR) || dst_status == DBSTATUS_S_OK /* W2K+ */, "got %08x\n", dst_status);
1808     ok(broken(dst_len == 0x1234) || dst_len == 4 /* W2K+ */, "got %ld\n", dst_len);
1809     ok(!lstrcmpA(dst, fourthreetwoone), "got %s\n", dst);
1810
1811
1812
1813     memset(src, 0, sizeof(src));
1814     memcpy(src, &IID_IDataConvert, sizeof(GUID));
1815     memset(dst, 0xcc, sizeof(dst));
1816     dst_len = 0x1234;
1817     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_STR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1818     ok(hr == S_OK, "got %08x\n", hr);
1819     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1820     ok(dst_len == 38, "got %ld\n", dst_len);
1821     ok(!lstrcmpA(dst, guid_str), "got %s\n", dst);
1822
1823
1824
1825     b = SysAllocString(ten);
1826     *(BSTR *)src = b;
1827     memset(dst, 0xcc, sizeof(dst));
1828     dst_len = 0x1234;
1829     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1830     ok(hr == S_OK, "got %08x\n", hr);
1831     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1832     ok(dst_len == 2, "got %ld\n", dst_len);
1833     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1834     SysFreeString(b);
1835
1836     memcpy(src, ten, sizeof(ten));
1837     memset(dst, 0xcc, sizeof(dst));
1838     dst_len = 0x1234;
1839     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1840     ok(hr == S_OK, "got %08x\n", hr);
1841     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1842     ok(dst_len == 1, "got %ld\n", dst_len);
1843     ok(dst[0] == '1', "got %02x\n", dst[0]);
1844     ok(dst[1] == 0, "got %02x\n", dst[1]);
1845
1846     memcpy(src, ten, sizeof(ten));
1847     memset(dst, 0xcc, sizeof(dst));
1848     dst_len = 0x1234;
1849     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1850     ok(hr == S_OK, "got %08x\n", hr);
1851     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1852     ok(dst_len == 2, "got %ld\n", dst_len);
1853     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1854
1855     memcpy(src, ten, sizeof(ten));
1856     memset(dst, 0xcc, sizeof(dst));
1857     dst_len = 0x1234;
1858     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1859     ok(hr == S_OK, "got %08x\n", hr);
1860     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1861     ok(dst_len == 2, "got %ld\n", dst_len);
1862     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1863
1864     memcpy(src, ten_a, sizeof(ten_a));
1865     memset(dst, 0xcc, sizeof(dst));
1866     dst_len = 0x1234;
1867     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1868     ok(hr == S_OK, "got %08x\n", hr);
1869     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1870     ok(dst_len == 2, "got %ld\n", dst_len);
1871     ok(dst[0] == '1', "got %02x\n", dst[0]);
1872     ok(dst[1] == '0', "got %02x\n", dst[1]);
1873     ok(dst[2] == 0, "got %02x\n", dst[2]);
1874     ok(dst[3] == (char)0xcc, "got %02x\n", dst[3]);
1875
1876     memcpy(src, ten_a, sizeof(ten_a));
1877     memset(dst, 0xcc, sizeof(dst));
1878     dst_len = 0x1234;
1879     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1880     ok(hr == S_OK, "got %08x\n", hr);
1881     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1882     ok(dst_len == 4, "got %ld\n", dst_len);
1883     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1884
1885     memcpy(src, ten_a, sizeof(ten_a));
1886     memset(dst, 0xcc, sizeof(dst));
1887     dst_len = 0x1234;
1888     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1889     ok(hr == S_OK, "got %08x\n", hr);
1890     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1891     ok(dst_len == 2, "got %ld\n", dst_len);
1892     ok(!lstrcmpA(ten_a, dst), "got %s\n", dst);
1893
1894
1895
1896     /* DBTYPE_BYTES to DBTYPE_*STR unpacks binary data into a hex string */
1897     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1898     memset(dst, 0xcc, sizeof(dst));
1899     dst_len = 0x1234;
1900     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, sizeof(hexpacked_a), &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1901     ok(hr == S_OK, "got %08x\n", hr);
1902     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1903     ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1904     ok(!lstrcmpA(hexunpacked_a, dst), "got %s\n", dst);
1905     ok(dst[sizeof(hexpacked_a)/sizeof(char) * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1906
1907     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1908     memset(dst, 0xcc, sizeof(dst));
1909     dst_len = 0x1234;
1910     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1911     ok(hr == S_OK, "got %08x\n", hr);
1912     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1913     ok(dst_len == 0, "got %ld\n", dst_len);
1914     ok(dst[0] == 0, "not null terminated\n");
1915     ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1916
1917     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1918     memset(dst, 0xcc, sizeof(dst));
1919     dst_len = 0x1234;
1920     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1921     ok(hr == S_OK, "got %08x\n", hr);
1922     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1923     ok(dst_len == 2 * sizeof(char) * 4, "got %ld\n", dst_len);
1924     ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1925     ok(dst[2 * 4] == 0, "not null terminated\n");
1926     ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1927
1928     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1929     memset(dst, 0xcc, sizeof(dst));
1930     dst_len = 0x1234;
1931     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);
1932     ok(hr == S_OK, "got %08x\n", hr);
1933     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1934     ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1935     ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 ), "got %s\n", dst);
1936     ok(dst[2 * 4] == 0, "not null terminated\n");
1937     ok(dst[2 * 4 + 1] == (char)0xcc, "clobbered buffer\n");
1938
1939     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1940     memset(dst, 0xcc, sizeof(dst));
1941     dst_len = 0x1234;
1942     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);
1943     ok(hr == S_OK, "got %08x\n", hr);
1944     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
1945     ok(dst_len == sizeof(hexpacked_a) * 2, "got %ld\n", dst_len);
1946     ok(!memcmp(hexunpacked_a, dst, 2 * sizeof(char) * 4 - 2 ), "got %s\n", dst);
1947     ok(dst[2 * 4 - 1] == 0, "not null terminated\n");
1948     ok(dst[2 * 4] == (char)0xcc, "clobbered buffer\n");
1949
1950     memcpy(src, hexpacked_a, sizeof(hexpacked_a));
1951     memset(dst, 0xcc, sizeof(dst));
1952     dst_len = 0x1234;
1953     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_STR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1954     ok(hr == S_OK, "got %08x\n", hr);
1955     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1956     ok(dst_len == 0, "got %ld\n", dst_len);
1957     ok(dst[0] == 0, "not null terminated\n");
1958     ok(dst[1] == (char)0xcc, "clobbered buffer\n");
1959 }
1960
1961 static void test_converttobyrefwstr(void)
1962 {
1963     HRESULT hr;
1964     WCHAR *dst;
1965     BYTE src[20];
1966     DBSTATUS dst_status;
1967     DBLENGTH dst_len;
1968     static const WCHAR ten[] = {'1','0',0};
1969     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1970     BSTR b;
1971
1972     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1973     ok(hr == S_OK, "got %08x\n", hr);
1974     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1975     ok(dst_len == 0, "got %ld\n", dst_len);
1976     ok(dst[0] == 0, "got %04x\n", dst[0]);
1977     CoTaskMemFree(dst);
1978
1979     dst = (void*)0x12345678;
1980     dst_len = 0x1234;
1981     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1982     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1983     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1984     ok(dst_len == 0x1234, "got %ld\n", dst_len);
1985     ok(dst == (void*)0x12345678, "got %p\n", dst);
1986
1987     *(short *)src = 4321;
1988     dst_len = 0x1234;
1989     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1990     ok(hr == S_OK, "got %08x\n", hr);
1991     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1992     ok(dst_len == 8, "got %ld\n", dst_len);
1993     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1994     CoTaskMemFree(dst);
1995
1996     *(short *)src = 4321;
1997     dst_len = 0x1234;
1998     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, 0, 0, &dst_status, 0, 0, 0);
1999     ok(hr == S_OK, "got %08x\n", hr);
2000     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2001     ok(dst_len == 8, "got %ld\n", dst_len);
2002     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
2003     CoTaskMemFree(dst);
2004
2005     b = SysAllocString(ten);
2006     *(BSTR *)src = b;
2007     dst_len = 0x1234;
2008     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2009     ok(hr == S_OK, "got %08x\n", hr);
2010     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2011     ok(dst_len == 4, "got %ld\n", dst_len);
2012     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
2013     CoTaskMemFree(dst);
2014     SysFreeString(b);
2015
2016     memcpy(src, ten, sizeof(ten));
2017     dst_len = 0x1234;
2018     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2019     ok(hr == S_OK, "got %08x\n", hr);
2020     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2021     ok(dst_len == 2, "got %ld\n", dst_len);
2022     ok(dst[0] == '1', "got %02x\n", dst[0]);
2023     ok(dst[1] == 0, "got %02x\n", dst[1]);
2024     CoTaskMemFree(dst);
2025
2026     memcpy(src, ten, sizeof(ten));
2027     dst_len = 0x1234;
2028     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2029     ok(hr == S_OK, "got %08x\n", hr);
2030     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2031     ok(dst_len == 4, "got %ld\n", dst_len);
2032     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
2033     CoTaskMemFree(dst);
2034
2035     memcpy(src, ten, sizeof(ten));
2036     dst_len = 0x1234;
2037     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
2038     ok(hr == S_OK, "got %08x\n", hr);
2039     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2040     ok(dst_len == 4, "got %ld\n", dst_len);
2041     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
2042     CoTaskMemFree(dst);
2043 }
2044
2045 static void test_converttoguid(void)
2046 {
2047     HRESULT hr;
2048     GUID dst;
2049     BYTE src[20];
2050     DBSTATUS dst_status;
2051     DBLENGTH dst_len;
2052
2053     dst = IID_IDCInfo;
2054     dst_len = 0x1234;
2055     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2056     ok(hr == S_OK, "got %08x\n", hr);
2057     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2058     ok(dst_len == sizeof(GUID), "got %ld\n", dst_len);
2059     ok(IsEqualGUID(&dst, &GUID_NULL), "didn't get GUID_NULL\n");
2060
2061     dst = IID_IDCInfo;
2062     dst_len = 0x1234;
2063     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2064     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2065     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2066     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2067     ok(IsEqualGUID(&dst, &IID_IDCInfo), "dst has changed\n");
2068
2069     dst = IID_IDCInfo;
2070     memcpy(src, &IID_IDataConvert, sizeof(GUID));
2071     dst_len = 0x1234;
2072     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2073     ok(hr == S_OK, "got %08x\n", hr);
2074     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2075     ok(dst_len == sizeof(GUID), "got %ld\n", dst_len);
2076     ok(IsEqualGUID(&dst, &IID_IDataConvert), "didn't get IID_IDataConvert\n");
2077 }
2078
2079 static void test_converttofiletime(void)
2080 {
2081     HRESULT hr;
2082     FILETIME dst;
2083     BYTE src[20];
2084     DBSTATUS dst_status;
2085     DBLENGTH dst_len;
2086
2087     memset(&dst, 0xcc, sizeof(dst));
2088     ((FILETIME *)src)->dwLowDateTime = 0x12345678;
2089     ((FILETIME *)src)->dwHighDateTime = 0x9abcdef0;
2090     dst_len = 0x1234;
2091     hr = IDataConvert_DataConvert(convert, DBTYPE_FILETIME, DBTYPE_FILETIME, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2092     ok(hr == S_OK ||
2093        broken(hr == DB_E_BADBINDINFO), /* win98 */
2094        "got %08x\n", hr);
2095     if(SUCCEEDED(hr))
2096     {
2097         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2098         ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2099         ok(dst.dwLowDateTime == 0x12345678, "got %08x\n", dst.dwLowDateTime);
2100         ok(dst.dwHighDateTime == 0x9abcdef0, "got %08x\n", dst.dwHighDateTime);
2101     }
2102 }
2103
2104 static void test_converttoui1(void)
2105 {
2106     HRESULT hr;
2107     BYTE dst;
2108     BYTE src[20];
2109     DBSTATUS dst_status;
2110     DBLENGTH dst_len;
2111
2112     dst = 0x12;
2113     dst_len = 0x1234;
2114     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2115     ok(hr == S_OK, "got %08x\n", hr);
2116     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2117     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2118     ok(dst == 0, "got %08x\n", dst);
2119
2120     dst = 0x12;
2121     dst_len = 0x1234;
2122     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2123     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2124     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2125     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2126     ok(dst == 0x12, "got %08x\n", dst);
2127
2128     dst = 0x12;
2129     src[0] = 0x43;
2130     dst_len = 0x1234;
2131     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2132     ok(hr == S_OK, "got %08x\n", hr);
2133     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2134     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2135     ok(dst == 0x43, "got %08x\n", dst);
2136
2137     dst = 0x12;
2138     src[0] = 0xfe;
2139     dst_len = 0x1234;
2140     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2141     ok(hr == S_OK, "got %08x\n", hr);
2142     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2143     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2144     ok(dst == 0xfe, "got %08x\n", dst);
2145 }
2146
2147 static void test_converttoui4(void)
2148 {
2149     HRESULT hr;
2150     DWORD dst;
2151     BYTE src[20];
2152     DBSTATUS dst_status;
2153     DBLENGTH dst_len;
2154
2155     dst = 0x12345678;
2156     dst_len = 0x1234;
2157     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2158     ok(hr == S_OK, "got %08x\n", hr);
2159     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2160     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2161     ok(dst == 0, "got %08x\n", dst);
2162
2163     dst = 0x12345678;
2164     dst_len = 0x1234;
2165     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2166     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2167     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2168     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2169     ok(dst == 0x12345678, "got %08x\n", dst);
2170
2171     dst = 0x12345678;
2172     *(DWORD*)src = 0x87654321;
2173     dst_len = 0x1234;
2174     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2175     ok(hr == S_OK, "got %08x\n", hr);
2176     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2177     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2178     ok(dst == 0x87654321, "got %08x\n", dst);
2179
2180     dst = 0x12345678;
2181     *(signed short *)src = 0x4321;
2182     dst_len = 0x1234;
2183     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2184     ok(hr == S_OK, "got %08x\n", hr);
2185     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2186     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2187     ok(dst == 0x4321, "got %08x\n", dst);
2188
2189     dst = 0x12345678;
2190     *(signed short *)src = -1;
2191     dst_len = 0x1234;
2192     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2193     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2194 todo_wine
2195     ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2196 todo_wine
2197     ok(broken(dst_len == sizeof(dst)) || dst_len == 0x1234 /* W2K+ */, "got %ld\n", dst_len);
2198     ok(dst == 0x12345678, "got %08x\n", dst);
2199
2200     dst_len = dst = 0x1234;
2201     V_VT((VARIANT*)src) = VT_I2;
2202     V_I2((VARIANT*)src) = 0x4321;
2203     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2204     ok(hr == S_OK, "got %08x\n", hr);
2205     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2206     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2207     ok(dst == 0x4321, "got %08x\n", dst);
2208 }
2209
2210 static void test_converttor4(void)
2211 {
2212     HRESULT hr;
2213     FLOAT dst;
2214     BYTE src[20];
2215     DBSTATUS dst_status;
2216     DBLENGTH dst_len;
2217
2218     dst = 1.0;
2219     dst_len = 0x1234;
2220     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2221     ok(hr == S_OK, "got %08x\n", hr);
2222     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2223     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2224     ok(dst == 0.0, "got %f\n", dst);
2225
2226     dst = 1.0;
2227     dst_len = 0x1234;
2228     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2229     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2230     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2231     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2232     ok(dst == 1.0, "got %f\n", dst);
2233
2234     dst = 1.0;
2235     *(signed int*)src = 12345678;
2236     dst_len = 0x1234;
2237     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2238     ok(hr == S_OK, "got %08x\n", hr);
2239     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2240     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2241     ok(dst == 12345678.0, "got %f\n", dst);
2242
2243     dst = 1.0;
2244     *(FLOAT *)src = 10.0;
2245     dst_len = 0x1234;
2246     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2247     ok(hr == S_OK, "got %08x\n", hr);
2248     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2249     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2250     ok(dst == 10.0, "got %f\n", dst);
2251 }
2252
2253 static void test_converttocy(void)
2254 {
2255     HRESULT hr;
2256     CY dst;
2257     BYTE src[20];
2258     DBSTATUS dst_status;
2259     DBLENGTH dst_len;
2260
2261     dst.int64 = 0xcc;
2262     dst_len = 0x1234;
2263     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2264     ok(hr == S_OK, "got %08x\n", hr);
2265     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2266     ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2267     ok(dst.int64 == 0, "didn't get 0\n");
2268
2269     dst.int64 = 0xcc;
2270     dst_len = 0x1234;
2271     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2272     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2273     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2274     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2275     ok(dst.int64 == 0xcc, "dst changed\n");
2276
2277     dst.int64 = 0xcc;
2278     *(int*)src = 1234;
2279     dst_len = 0x1234;
2280     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2281     ok(hr == S_OK, "got %08x\n", hr);
2282     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2283     ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2284     ok(dst.int64 == 12340000, "got %d\n", dst.s.Lo);
2285
2286     dst.int64 = 0xcc;
2287     ((CY*)src)->int64 = 1234;
2288     dst_len = 0x1234;
2289     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2290     ok(hr == S_OK, "got %08x\n", hr);
2291     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2292     ok(dst_len == sizeof(CY), "got %ld\n", dst_len);
2293     ok(dst.int64 == 1234, "got %d\n", dst.s.Lo);
2294 }
2295
2296 static void test_converttoui8(void)
2297 {
2298     HRESULT hr;
2299     ULARGE_INTEGER dst;
2300     BYTE src[20];
2301     DBSTATUS dst_status;
2302     DBLENGTH dst_len;
2303
2304     dst.QuadPart = 0xcc;
2305     dst_len = 0x1234;
2306     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2307     ok(hr == S_OK, "got %08x\n", hr);
2308     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2309     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2310     ok(dst.QuadPart == 0, "got %d\n", (int)dst.QuadPart);
2311
2312     dst.QuadPart = 0xcc;
2313     dst_len = 0x1234;
2314     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2315     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
2316     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
2317     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2318     ok(dst.QuadPart == 0xcc, "dst changed\n");
2319
2320     dst.QuadPart = 0xcc;
2321     *(int*)src = 1234;
2322     dst_len = 0x1234;
2323     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2324     ok(hr == S_OK, "got %08x\n", hr);
2325     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2326     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2327     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2328
2329     dst.QuadPart = 0xcc;
2330     *(int*)src = -1234;
2331     dst_len = 0x1234;
2332     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2333     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
2334 todo_wine
2335     ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
2336 todo_wine
2337     ok(dst_len == 0x1234, "got %ld\n", dst_len);
2338     ok(dst.QuadPart == 0xcc, "got %d\n", (int)dst.QuadPart);
2339
2340     dst.QuadPart = 0xcc;
2341     ((ULARGE_INTEGER*)src)->QuadPart = 1234;
2342     dst_len = 0x1234;
2343     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2344     ok(hr == S_OK, "got %08x\n", hr);
2345     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2346     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2347     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
2348 }
2349
2350 static void test_getconversionsize(void)
2351 {
2352     DBLENGTH dst_len;
2353     DBLENGTH src_len;
2354     HRESULT hr;
2355     BSTR str;
2356     static WCHAR strW[] = {'t','e','s','t',0};
2357     static char strTest[] = "test";
2358     VARIANT var;
2359
2360     /* same way as CanConvert fails here */
2361     dst_len = 0;
2362     hr = IDataConvert_GetConversionSize(convert, DBTYPE_NULL, DBTYPE_BSTR, NULL, &dst_len, NULL);
2363     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got 0x%08x\n", hr);
2364
2365     dst_len = 0;
2366     hr = IDataConvert_GetConversionSize(convert, DBTYPE_I2, DBTYPE_I4, NULL, &dst_len, NULL);
2367     ok(hr == S_OK, "got 0x%08x\n", hr);
2368     ok(dst_len == 4, "got %ld\n", dst_len);
2369
2370     hr = IDataConvert_GetConversionSize(convert, DBTYPE_I2, DBTYPE_I4, NULL, NULL, NULL);
2371     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
2372
2373     /* size doesn't include string size */
2374     str = SysAllocStringLen(NULL, 10);
2375     dst_len = 0;
2376     hr = IDataConvert_GetConversionSize(convert, DBTYPE_BSTR, DBTYPE_VARIANT, NULL, &dst_len, str);
2377     ok(hr == S_OK, "got 0x%08x\n", hr);
2378     ok(dst_len == sizeof(VARIANT), "%ld\n", dst_len);
2379     SysFreeString(str);
2380
2381     dst_len = 0;
2382     hr = IDataConvert_GetConversionSize(convert, DBTYPE_WSTR, DBTYPE_WSTR, NULL, &dst_len, strW);
2383     ok(hr == S_OK, "got 0x%08x\n", hr);
2384     ok(dst_len == 10, "%ld\n", dst_len);
2385
2386     dst_len = 0;
2387     src_len = 2;
2388     hr = IDataConvert_GetConversionSize(convert, DBTYPE_WSTR, DBTYPE_WSTR, &src_len, &dst_len, strW);
2389     ok(hr == S_OK, "got 0x%08x\n", hr);
2390     ok(dst_len == 4, "%ld\n", dst_len);
2391
2392     dst_len = 0;
2393     src_len = 20;
2394     hr = IDataConvert_GetConversionSize(convert, DBTYPE_WSTR, DBTYPE_WSTR, &src_len, &dst_len, strW);
2395     ok(hr == S_OK, "got 0x%08x\n", hr);
2396     ok(dst_len == 22, "%ld\n", dst_len);
2397
2398     dst_len = 0;
2399     hr = IDataConvert_GetConversionSize(convert, DBTYPE_STR, DBTYPE_WSTR, NULL, &dst_len, strTest);
2400     ok(hr == S_OK, "got 0x%08x\n", hr);
2401     ok(dst_len == 10 || broken(dst_len == 12), "%ld\n", dst_len);
2402
2403     dst_len = 0;
2404     src_len = 2;
2405     hr = IDataConvert_GetConversionSize(convert, DBTYPE_STR, DBTYPE_WSTR, &src_len, &dst_len, strTest);
2406     ok(hr == S_OK, "got 0x%08x\n", hr);
2407     ok(dst_len == 6, "%ld\n", dst_len);
2408
2409     dst_len = 0;
2410     src_len = 20;
2411     hr = IDataConvert_GetConversionSize(convert, DBTYPE_STR, DBTYPE_WSTR, &src_len, &dst_len, strTest);
2412     ok(hr == S_OK, "got 0x%08x\n", hr);
2413     ok(dst_len == 42, "%ld\n", dst_len);
2414
2415     dst_len = 0;
2416     V_VT(&var) = VT_BSTR;
2417     V_BSTR(&var) = SysAllocString(strW);
2418     hr = IDataConvert_GetConversionSize(convert, DBTYPE_VARIANT, DBTYPE_WSTR, NULL, &dst_len, &var);
2419     ok(hr == S_OK, "got 0x%08x\n", hr);
2420     ok(dst_len == 10, "%ld\n", dst_len);
2421     VariantClear(&var);
2422
2423     dst_len = 0;
2424     src_len = 20;
2425     V_VT(&var) = VT_BSTR;
2426     V_BSTR(&var) = SysAllocString(strW);
2427     hr = IDataConvert_GetConversionSize(convert, DBTYPE_VARIANT, DBTYPE_WSTR, &src_len, &dst_len, &var);
2428     ok(hr == S_OK, "got 0x%08x\n", hr);
2429     ok(dst_len == 10, "%ld\n", dst_len);
2430     VariantClear(&var);
2431
2432     dst_len = 0;
2433     src_len = 20;
2434     V_VT(&var) = VT_I4;
2435     V_I4(&var) = 4;
2436     hr = IDataConvert_GetConversionSize(convert, DBTYPE_VARIANT, DBTYPE_WSTR, &src_len, &dst_len, &var);
2437     ok(hr == S_OK, "got 0x%08x\n", hr);
2438     todo_wine ok(dst_len == 110, "%ld\n", dst_len);
2439     VariantClear(&var);
2440
2441 }
2442
2443 static void test_converttobytes(void)
2444 {
2445     DBLENGTH dst_len;
2446     HRESULT hr;
2447     BYTE byte_src[] = {0, 1, 2, 4, 5};
2448     BYTE dst[10] = {0};
2449     DBSTATUS dst_status;
2450
2451     dst_len = 0;
2452     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_BYTES, sizeof(byte_src), &dst_len, byte_src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2453     ok(hr == S_OK, "got %08x\n", hr);
2454     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2455     ok(dst_len == sizeof(byte_src), "got %ld\n", dst_len);
2456     ok(!memcmp(byte_src, dst, dst_len ), "bytes differ\n");
2457
2458     dst_len = 0;
2459     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_BYTES, sizeof(byte_src), &dst_len, byte_src, &dst, 2, 0, &dst_status, 0, 0, 0);
2460     ok(hr == S_OK, "got %08x\n", hr);
2461     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
2462     ok(dst_len == sizeof(byte_src), "got %ld\n", dst_len);
2463     ok(!memcmp(byte_src, dst, 2 ), "bytes differ\n");
2464 }
2465
2466 static void test_converttodbdate(void)
2467 {
2468     DBLENGTH dst_len;
2469     HRESULT hr;
2470     DBDATE ts = {2013, 5, 14};
2471     DBDATE dst;
2472     DBSTATUS dst_status;
2473     VARIANT var;
2474
2475     dst_len = 0;
2476     hr = IDataConvert_DataConvert(convert, DBTYPE_DBDATE, DBTYPE_DBDATE, sizeof(ts), &dst_len, &ts, &dst, 2, 0, &dst_status, 0, 0, 0);
2477     ok(hr == S_OK, "got %08x\n", hr);
2478     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2479     ok(dst_len == sizeof(DBDATE), "got %ld\n", dst_len);
2480     ok(!memcmp(&ts, &dst, sizeof(DBDATE) ), "bytes differ\n");
2481
2482     VariantInit(&var);
2483     V_VT(&var) = VT_DATE;
2484     V_DATE(&var) = 41408.086250;
2485     dst_len = 0;
2486     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_DBDATE, sizeof(var), &dst_len, &var, &dst, 2, 0, &dst_status, 0, 0, 0);
2487     ok(hr == S_OK, "got %08x\n", hr);
2488     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2489     ok(dst_len == sizeof(DBDATE), "got %ld\n", dst_len);
2490     ok(!memcmp(&ts, &dst, sizeof(DBDATE) ), "bytes differ\n");
2491 }
2492
2493
2494 static void test_converttovar(void)
2495 {
2496     static WCHAR strW[] = {'t','e','s','t',0};
2497     BYTE byte_src[5] = {1, 2, 3, 4, 5};
2498     DBTIMESTAMP ts = {2013, 5, 14, 2, 4, 12, 0};
2499     DBDATE dbdate = {2013, 5, 15};
2500     double dvalue = 123.56;
2501     DBSTATUS dst_status;
2502     DBLENGTH dst_len;
2503     VARIANT dst;
2504     HRESULT hr;
2505     CY cy, cy2;
2506     DATE date;
2507     INT i4;
2508     LARGE_INTEGER i8;
2509     VARIANT_BOOL boolean = VARIANT_TRUE;
2510
2511     V_VT(&dst) = VT_EMPTY;
2512     dst_len = 0;
2513     dst_status = DBSTATUS_S_DEFAULT;
2514     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_VARIANT, sizeof(strW), &dst_len, strW, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2515     ok(hr == S_OK, "got %08x\n", hr);
2516     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2517     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2518     ok(V_VT(&dst) == VT_BSTR, "got %d\n", V_VT(&dst));
2519     ok(!lstrcmpW(V_BSTR(&dst), strW), "got %s\n", wine_dbgstr_w(V_BSTR(&dst)));
2520     VariantClear(&dst);
2521
2522     /* with null dest length and status */
2523     V_VT(&dst) = VT_EMPTY;
2524     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_VARIANT, sizeof(strW), NULL, strW, &dst, sizeof(dst), 0, NULL, 0, 0, 0);
2525     ok(hr == S_OK, "got %08x\n", hr);
2526     ok(V_VT(&dst) == VT_BSTR, "got %d\n", V_VT(&dst));
2527     ok(!lstrcmpW(V_BSTR(&dst), strW), "got %s\n", wine_dbgstr_w(V_BSTR(&dst)));
2528     VariantClear(&dst);
2529
2530     V_VT(&dst) = VT_EMPTY;
2531     dst_len = 0;
2532     dst_status = DBSTATUS_S_DEFAULT;
2533     i8.QuadPart = 12345;
2534     dst_len = 0x1234;
2535     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_VARIANT, sizeof(i8), &dst_len, &i8, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2536     ok(hr == S_OK, "got %08x\n", hr);
2537     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2538     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2539     ok(V_VT(&dst) == VT_DECIMAL, "got %d\n", V_VT(&dst));
2540     ok(S(U(V_DECIMAL(&dst))).scale == 0 && S(U(V_DECIMAL(&dst))).sign == 0 &&
2541        V_DECIMAL(&dst).Hi32 == 0 && U1(V_DECIMAL(&dst)).Lo64 == 12345, "Not Equal\n");
2542
2543     V_VT(&dst) = VT_EMPTY;
2544     dst_len = 0;
2545     dst_status = DBSTATUS_S_DEFAULT;
2546     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_VARIANT, sizeof(dvalue), &dst_len, &dvalue, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2547     ok(hr == S_OK, "got %08x\n", hr);
2548     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2549     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2550     ok(V_VT(&dst) == VT_R8, "got %d\n", V_VT(&dst));
2551     ok(V_R8(&dst) == 123.56, "got %f\n", V_R8(&dst));
2552
2553     V_VT(&dst) = VT_EMPTY;
2554     dst_len = 0;
2555     dst_status = DBSTATUS_S_DEFAULT;
2556     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_VARIANT, sizeof(boolean), &dst_len, &boolean, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2557     ok(hr == S_OK, "got %08x\n", hr);
2558     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2559     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2560     ok(V_VT(&dst) == VT_BOOL, "got %d\n", V_VT(&dst));
2561     ok(V_BOOL(&dst) == VARIANT_TRUE, "got %d\n", V_BOOL(&dst));
2562
2563     V_VT(&dst) = VT_EMPTY;
2564     dst_len = 0;
2565     dst_status = DBSTATUS_S_DEFAULT;
2566     i4 = 123;
2567     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_VARIANT, sizeof(i4), &dst_len, &i4, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2568     ok(hr == S_OK, "got %08x\n", hr);
2569     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2570     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2571     ok(V_VT(&dst) == VT_I4, "got %d\n", V_VT(&dst));
2572     ok(V_I4(&dst) == 123, "got %d\n", V_I4(&dst));
2573
2574     V_VT(&dst) = VT_EMPTY;
2575     dst_len = 0;
2576     dst_status = DBSTATUS_S_DEFAULT;
2577     date = 123.123;
2578     hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, DBTYPE_VARIANT, sizeof(date), &dst_len, &date, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2579     ok(hr == S_OK, "got %08x\n", hr);
2580     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2581     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2582     ok(V_VT(&dst) == VT_DATE, "got %d\n", V_VT(&dst));
2583     ok(V_DATE(&dst) == 123.123, "got %f\n", V_DATE(&dst));
2584
2585     V_VT(&dst) = VT_EMPTY;
2586     dst_len = 0;
2587     dst_status = DBSTATUS_S_DEFAULT;
2588     S(cy).Lo = 1;
2589     S(cy).Hi = 2;
2590     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_VARIANT, sizeof(cy), &dst_len, &cy, &dst, sizeof(dst), 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_CY, "got %d\n", V_VT(&dst));
2595
2596     cy2 = V_CY(&dst);
2597     ok(S(cy2).Lo == S(cy).Lo && S(cy2).Hi == S(cy).Hi, "got %d,%d\n", S(cy2).Lo, S(cy2).Hi);
2598
2599     dst_len = 0x1234;
2600     hr = IDataConvert_DataConvert(convert, DBTYPE_BYTES, DBTYPE_VARIANT, 0, &dst_len, &byte_src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2601     ok(hr == S_OK, "got %08x\n", hr);
2602     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2603     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2604     ok(V_VT(&dst) == (VT_ARRAY|VT_UI1), "got %d\n", V_VT(&dst));
2605     VariantClear(&dst);
2606
2607     dst_len = 0x1234;
2608     hr = IDataConvert_DataConvert(convert, DBTYPE_DBTIMESTAMP, DBTYPE_VARIANT, 0, &dst_len, &ts, &dst, sizeof(ts), 0, &dst_status, 0, 0, 0);
2609     ok(hr == S_OK, "got %08x\n", hr);
2610     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2611     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2612     ok(V_VT(&dst) == VT_DATE, "got %d\n", V_VT(&dst));
2613     ok( (float)V_DATE(&dst) == 41408.086250f, "got %f\n", V_DATE(&dst));
2614
2615     dst_len = 0x1234;
2616     hr = IDataConvert_DataConvert(convert, DBTYPE_DBDATE, DBTYPE_VARIANT, 0, &dst_len, &dbdate, &dst, sizeof(dbdate), 0, &dst_status, 0, 0, 0);
2617     ok(hr == S_OK, "got %08x\n", hr);
2618     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2619     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2620     ok(V_VT(&dst) == VT_DATE, "got %d\n", V_VT(&dst));
2621     ok( (float)V_DATE(&dst) == 41409.0, "got %f\n", V_DATE(&dst));
2622
2623     /* src_status = DBSTATUS_S_ISNULL */
2624     i4 = 123;
2625     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_VARIANT, sizeof(i4), &dst_len, &i4, &dst, sizeof(dst), DBSTATUS_S_ISNULL, &dst_status, 0, 0, 0);
2626     ok(hr == S_OK, "got %08x\n", hr);
2627     ok(dst_status == DBSTATUS_S_ISNULL, "got %08x\n", dst_status);
2628     ok(dst_len == 0, "got %ld\n", dst_len);
2629
2630 }
2631
2632 static void test_converttotimestamp(void)
2633 {
2634     DBTIMESTAMP ts = {2013, 5, 14, 2, 4, 12, 0};
2635     DBTIMESTAMP dst;
2636     DBSTATUS dst_status;
2637     DBLENGTH dst_len;
2638     VARIANT var;
2639     HRESULT hr;
2640
2641     VariantInit(&var);
2642     V_VT(&var) = VT_DATE;
2643     V_DATE(&var) = 41408.086250;
2644     dst_len = 0x1234;
2645     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_DBTIMESTAMP, 0, &dst_len, &var, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
2646     ok(hr == S_OK, "got %08x\n", hr);
2647     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
2648     ok(dst_len == sizeof(dst), "got %ld\n", dst_len);
2649     ok(!memcmp(&ts, &dst, sizeof(ts)), "Wrong timestamp\n");
2650 }
2651
2652 START_TEST(convert)
2653 {
2654     HRESULT hr;
2655
2656     OleInitialize(NULL);
2657
2658     test_dcinfo();
2659
2660     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
2661     if(FAILED(hr))
2662     {
2663         win_skip("Unable to create IDataConvert instance, 0x%08x\n", hr);
2664         OleUninitialize();
2665         return;
2666     }
2667
2668     test_canconvert();
2669     test_converttoi2();
2670     test_converttoi4();
2671     test_converttoi8();
2672     test_converttostr();
2673     test_converttobstr();
2674     test_converttowstr();
2675     test_converttobyrefwstr();
2676     test_converttoguid();
2677     test_converttoui1();
2678     test_converttoui4();
2679     test_converttor4();
2680     test_converttofiletime();
2681     test_converttocy();
2682     test_converttoui8();
2683     test_converttovar();
2684     test_converttobytes();
2685     test_converttodbdate();
2686     test_getconversionsize();
2687     test_converttotimestamp();
2688
2689     IDataConvert_Release(convert);
2690
2691     OleUninitialize();
2692 }