dlls/oledb32/tests/convert.c

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