dlls/oledb32/tests/convert.c

   1 /* OLE DB Conversion library tests
   2  *
   3  * Copyright 2009 Huw Davies
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24 #define NONAMELESSSTRUCT
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "msdadc.h"
  30
  31 #include "oledberr.h"
  32
  33 #include "initguid.h"
  34 #include "msdaguid.h"
  35
  36 #include "wine/test.h"
  37
  38 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  39
  40 static void test_dcinfo(void)
  41 {
  42     IDCInfo *info;
  43     HRESULT hr;
  44     DCINFOTYPE types[2];
  45     DCINFO *inf;
  46
  47     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDCInfo, (void**)&info);
  48     if(FAILED(hr))
  49     {
  50         win_skip("Unable to load oledb conversion library\n");
  51         return;
  52     }
  53
  54     types[0] = DCINFOTYPE_VERSION;
  55     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  56     ok(hr == S_OK, "got %08x\n", hr);
  57
  58     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  59     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  60     ok(V_UI4(&inf->vData) == 0x110, "got %08x\n", V_UI4(&inf->vData));
  61
  62     V_UI4(&inf->vData) = 0x200;
  63     hr = IDCInfo_SetInfo(info, 1, inf);
  64     ok(hr == S_OK, "got %08x\n", hr);
  65     CoTaskMemFree(inf);
  66
  67     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  68     ok(hr == S_OK, "got %08x\n", hr);
  69     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  70     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  71     ok(V_UI4(&inf->vData) == 0x200, "got %08x\n", V_UI4(&inf->vData));
  72
  73     V_UI4(&inf->vData) = 0x100;
  74     hr = IDCInfo_SetInfo(info, 1, inf);
  75     ok(hr == S_OK, "got %08x\n", hr);
  76     CoTaskMemFree(inf);
  77
  78     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  79     ok(hr == S_OK, "got %08x\n", hr);
  80     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  81     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  82     ok(V_UI4(&inf->vData) == 0x100, "got %08x\n", V_UI4(&inf->vData));
  83
  84     V_UI4(&inf->vData) = 0x500;
  85     hr = IDCInfo_SetInfo(info, 1, inf);
  86     ok(hr == S_OK, "got %08x\n", hr);
  87     CoTaskMemFree(inf);
  88
  89     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  90     ok(hr == S_OK, "got %08x\n", hr);
  91     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  92     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  93     ok(V_UI4(&inf->vData) == 0x500, "got %08x\n", V_UI4(&inf->vData));
  94
  95     V_UI4(&inf->vData) = 0xffff;
  96     hr = IDCInfo_SetInfo(info, 1, inf);
  97     ok(hr == S_OK, "got %08x\n", hr);
  98     CoTaskMemFree(inf);
  99
 100     hr = IDCInfo_GetInfo(info, 1, types, &inf);
 101     ok(hr == S_OK, "got %08x\n", hr);
 102     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
 103     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
 104     ok(V_UI4(&inf->vData) == 0xffff, "got %08x\n", V_UI4(&inf->vData));
 105
 106     V_UI4(&inf->vData) = 0x12345678;
 107     hr = IDCInfo_SetInfo(info, 1, inf);
 108     ok(hr == S_OK, "got %08x\n", hr);
 109     CoTaskMemFree(inf);
 110
 111     hr = IDCInfo_GetInfo(info, 1, types, &inf);
 112     ok(hr == S_OK, "got %08x\n", hr);
 113     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
 114     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
 115     ok(V_UI4(&inf->vData) == 0x12345678, "got %08x\n", V_UI4(&inf->vData));
 116
 117     /* Try setting a version variant of something other than VT_UI4 */
 118     V_VT(&inf->vData) = VT_I4;
 119     V_I4(&inf->vData) = 0x200;
 120     hr = IDCInfo_SetInfo(info, 1, inf);
 121     ok(hr == DB_S_ERRORSOCCURRED, "got %08x\n", hr);
 122     CoTaskMemFree(inf);
 123
 124     hr = IDCInfo_GetInfo(info, 1, types, &inf);
 125     ok(hr == S_OK, "got %08x\n", hr);
 126     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
 127     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
 128     ok(V_UI4(&inf->vData) == 0x12345678, "got %08x\n", V_UI4(&inf->vData));
 129     CoTaskMemFree(inf);
 130
 131     /* More than one type */
 132     types[1] = 2;
 133     hr = IDCInfo_GetInfo(info, 2, types, &inf);
 134     ok(hr == S_OK, "got %08x\n", hr);
 135     ok(inf[0].eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf[0].eInfoType);
 136     ok(V_VT(&inf[0].vData) == VT_UI4, "got %08x\n", V_VT(&inf[0].vData));
 137     ok(V_UI4(&inf[0].vData) == 0x12345678, "got %08x\n", V_UI4(&inf[0].vData));
 138     ok(inf[1].eInfoType == 2, "got %08x\n", inf[1].eInfoType);
 139     ok(V_VT(&inf[1].vData) == VT_EMPTY, "got %08x\n", V_VT(&inf[1].vData));
 140
 141     hr = IDCInfo_SetInfo(info, 2, inf);
 142     ok(hr == S_OK, "got %08x\n", hr);
 143     CoTaskMemFree(inf);
 144
 145
 146     IDCInfo_Release(info);
 147 }
 148
 149 struct can_convert
 150 {
 151     DBTYPE type;
 152     DWORD can_convert_to;
 153 } simple_convert[] =
 154 {
 155     {DBTYPE_EMPTY,       0x63bfd9ff},
 156     {DBTYPE_NULL,        0x40001002},
 157     {DBTYPE_I2,          0x3b9fd9ff},
 158     {DBTYPE_I4,          0x3bdfd9ff},
 159
 160     {DBTYPE_R4,          0x3b9fd9ff},
 161     {DBTYPE_R8,          0x3b9fd9ff},
 162     {DBTYPE_CY,          0x039fd97f},
 163     {DBTYPE_DATE,        0x799f99bf},
 164
 165     {DBTYPE_BSTR,        0x7bffd9ff},
 166     {DBTYPE_IDISPATCH,   0x7bffffff},
 167     {DBTYPE_ERROR,       0x01001500},
 168     {DBTYPE_BOOL,        0x039fd9ff},
 169
 170     {DBTYPE_VARIANT,     0x7bffffff},
 171     {DBTYPE_IUNKNOWN,    0x00003203},
 172     {DBTYPE_DECIMAL,     0x3b9fd97f},
 173     {DBTYPE_I1,          0x3b9fd9ff},
 174
 175     {DBTYPE_UI1,         0x3b9fd9ff},
 176     {DBTYPE_UI2,         0x3b9fd9ff},
 177     {DBTYPE_UI4,         0x3bdfd9ff},
 178     {DBTYPE_I8,          0x43dfd97f},
 179
 180     {DBTYPE_UI8,         0x43dfd97f},
 181     {DBTYPE_GUID,        0x01e01103},
 182     {DBTYPE_BYTES,       0x01fc110b},
 183     {DBTYPE_STR,         0x7bffd9ff},
 184
 185     {DBTYPE_WSTR,        0x7bffd9ff},
 186     {DBTYPE_NUMERIC,     0x039fd97f},
 187     {DBTYPE_UDT,         0x00000000},
 188     {DBTYPE_DBDATE,      0x79801183},
 189
 190     {DBTYPE_DBTIME,      0x79801183},
 191     {DBTYPE_DBTIMESTAMP, 0x79801183},
 192     {DBTYPE_FILETIME,    0x79981183}
 193 };
 194
 195
 196 static inline BOOL array_type(DBTYPE type)
 197 {
 198     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 199 }
 200
 201 static void test_canconvert(void)
 202 {
 203     IDataConvert *convert;
 204     HRESULT hr;
 205     int src_idx, dst_idx;
 206
 207     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 208     if(FAILED(hr))
 209     {
 210         win_skip("Unable to load oledb conversion library\n");
 211         return;
 212     }
 213
 214     /* Some older versions of the library don't support several conversions, we'll skip
 215        if we have such a library */
 216     hr = IDataConvert_CanConvert(convert, DBTYPE_EMPTY, DBTYPE_DBTIMESTAMP);
 217     if(hr == S_FALSE)
 218     {
 219         win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
 220         IDataConvert_Release(convert);
 221         return;
 222     }
 223
 224     /* Some older versions of the library don't support several conversions, we'll skip
 225        if we have such a library */
 226     hr = IDataConvert_CanConvert(convert, DBTYPE_EMPTY, DBTYPE_DBTIMESTAMP);
 227     if(hr == S_FALSE)
 228     {
 229         win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
 230         IDataConvert_Release(convert);
 231         return;
 232     }
 233
 234     for(src_idx = 0; src_idx < sizeof(simple_convert) / sizeof(simple_convert[0]); src_idx++)
 235         for(dst_idx = 0; dst_idx < sizeof(simple_convert) / sizeof(simple_convert[0]); dst_idx++)
 236         {
 237             BOOL expect, simple_expect;
 238             simple_expect = (simple_convert[src_idx].can_convert_to >> dst_idx) & 1;
 239
 240             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type);
 241             expect = simple_expect;
 242             ok((hr == S_OK && expect == TRUE) ||
 243                (hr == S_FALSE && expect == FALSE),
 244                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 245                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 246
 247             /* src DBTYPE_BYREF */
 248             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_BYREF, simple_convert[dst_idx].type);
 249             expect = simple_expect;
 250             ok((hr == S_OK && expect == TRUE) ||
 251                (hr == S_FALSE && expect == FALSE),
 252                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_BYREF,
 253                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 254
 255             /* dst DBTYPE_BYREF */
 256             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_BYREF);
 257             expect = FALSE;
 258             if(simple_expect &&
 259                (simple_convert[dst_idx].type == DBTYPE_BYTES ||
 260                 simple_convert[dst_idx].type == DBTYPE_STR ||
 261                 simple_convert[dst_idx].type == DBTYPE_WSTR))
 262                 expect = TRUE;
 263             ok((hr == S_OK && expect == TRUE) ||
 264                (hr == S_FALSE && expect == FALSE),
 265                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 266                simple_convert[dst_idx].type | DBTYPE_BYREF, hr, expect ? "" : "not ");
 267
 268             /* src & dst DBTYPE_BYREF */
 269             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_BYREF, simple_convert[dst_idx].type | DBTYPE_BYREF);
 270             expect = FALSE;
 271             if(simple_expect &&
 272                (simple_convert[dst_idx].type == DBTYPE_BYTES ||
 273                 simple_convert[dst_idx].type == DBTYPE_STR ||
 274                 simple_convert[dst_idx].type == DBTYPE_WSTR))
 275                 expect = TRUE;
 276             ok((hr == S_OK && expect == TRUE) ||
 277                (hr == S_FALSE && expect == FALSE),
 278                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_BYREF,
 279                simple_convert[dst_idx].type | DBTYPE_BYREF, hr, expect ? "" : "not ");
 280
 281             /* src DBTYPE_ARRAY */
 282             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_ARRAY, simple_convert[dst_idx].type);
 283             expect = FALSE;
 284             if(array_type(simple_convert[src_idx].type) && simple_convert[dst_idx].type == DBTYPE_VARIANT)
 285                 expect = TRUE;
 286             ok((hr == S_OK && expect == TRUE) ||
 287                (hr == S_FALSE && expect == FALSE),
 288                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_ARRAY,
 289                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 290
 291             /* dst DBTYPE_ARRAY */
 292             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_ARRAY);
 293             expect = FALSE;
 294             if(array_type(simple_convert[dst_idx].type) &&
 295                (simple_convert[src_idx].type == DBTYPE_IDISPATCH ||
 296                 simple_convert[src_idx].type == DBTYPE_VARIANT))
 297                 expect = TRUE;
 298             ok((hr == S_OK && expect == TRUE) ||
 299                (hr == S_FALSE && expect == FALSE),
 300                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 301                simple_convert[dst_idx].type | DBTYPE_ARRAY, hr, expect ? "" : "not ");
 302
 303             /* src & dst DBTYPE_ARRAY */
 304             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_ARRAY, simple_convert[dst_idx].type | DBTYPE_ARRAY);
 305             expect = FALSE;
 306             if(array_type(simple_convert[src_idx].type) &&
 307                simple_convert[src_idx].type == simple_convert[dst_idx].type)
 308                 expect = TRUE;
 309             ok((hr == S_OK && expect == TRUE) ||
 310                (hr == S_FALSE && expect == FALSE),
 311                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_ARRAY,
 312                simple_convert[dst_idx].type | DBTYPE_ARRAY, hr, expect ? "" : "not ");
 313
 314             /* src DBTYPE_VECTOR */
 315             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_VECTOR, simple_convert[dst_idx].type);
 316             expect = FALSE;
 317             ok((hr == S_OK && expect == TRUE) ||
 318                (hr == S_FALSE && expect == FALSE),
 319                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_VECTOR,
 320                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 321
 322             /* dst DBTYPE_VECTOR */
 323             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_VECTOR);
 324             expect = FALSE;
 325             ok((hr == S_OK && expect == TRUE) ||
 326                (hr == S_FALSE && expect == FALSE),
 327                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 328                simple_convert[dst_idx].type | DBTYPE_VECTOR, hr, expect ? "" : "not ");
 329
 330             /* src & dst DBTYPE_VECTOR */
 331             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_VECTOR, simple_convert[dst_idx].type | DBTYPE_VECTOR);
 332             expect = FALSE;
 333             ok((hr == S_OK && expect == TRUE) ||
 334                (hr == S_FALSE && expect == FALSE),
 335                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_VECTOR,
 336                simple_convert[dst_idx].type | DBTYPE_VECTOR, hr, expect ? "" : "not ");
 337
 338
 339         }
 340
 341     IDataConvert_Release(convert);
 342 }
 343
 344 static void test_converttoi2(void)
 345 {
 346     IDataConvert *convert;
 347     HRESULT hr;
 348     signed short dst;
 349     BYTE src[20];
 350     DBSTATUS dst_status;
 351     DBLENGTH dst_len;
 352     static const WCHAR ten[] = {'1','0',0};
 353     BSTR b;
 354
 355     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 356     if(FAILED(hr))
 357     {
 358         win_skip("Unable to load oledb conversion library\n");
 359         return;
 360     }
 361
 362     dst = 0x1234;
 363     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 364     ok(hr == S_OK, "got %08x\n", hr);
 365     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 366     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 367     ok(dst == 0, "got %08x\n", dst);
 368
 369     dst = 0x1234;
 370     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 371     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 372     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 373     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 374     ok(dst == 0x1234, "got %08x\n", dst);
 375
 376     dst = 0x1234;
 377     *(short *)src = 0x4321;
 378     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 379     ok(hr == S_OK, "got %08x\n", hr);
 380     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 381     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 382     ok(dst == 0x4321, "got %08x\n", dst);
 383
 384     dst = 0x1234;
 385     *(int *)src = 0x4321cafe;
 386     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 387 todo_wine
 388     ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
 389     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 390     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 391     ok(dst == 0x1234, "got %08x\n", dst);
 392
 393     dst = 0x1234;
 394     *(int *)src = 0x4321;
 395     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 396     ok(hr == S_OK, "got %08x\n", hr);
 397     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 398     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 399     ok(dst == 0x4321, "got %08x\n", dst);
 400
 401     dst = 0x1234;
 402     *(FLOAT *)src = 10.75;
 403     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 404     ok(hr == S_OK, "got %08x\n", hr);
 405     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 406     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 407     ok(dst == 11, "got %08x\n", dst);
 408
 409     dst = 0x1234;
 410     *(FLOAT *)src = -10.75;
 411     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 412     ok(hr == S_OK, "got %08x\n", hr);
 413     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 414     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 415     ok(dst == -11, "got %08x\n", dst);
 416
 417     dst = 0x1234;
 418     *(double *)src = 10.75;
 419     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 420     ok(hr == S_OK, "got %08x\n", hr);
 421     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 422     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 423     ok(dst == 11, "got %08x\n", dst);
 424
 425     dst = 0x1234;
 426     ((LARGE_INTEGER *)src)->QuadPart = 107500;
 427     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 428     ok(hr == S_OK, "got %08x\n", hr);
 429     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 430     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 431     ok(dst == 11, "got %08x\n", dst);
 432
 433     dst = 0x1234;
 434     *(DATE *)src = 10.7500;
 435     hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 436     ok(hr == S_OK, "got %08x\n", hr);
 437     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 438     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 439     ok(dst == 11, "got %08x\n", dst);
 440
 441     dst = 0x1234;
 442     b = SysAllocString(ten);
 443     *(BSTR *)src = b;
 444     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 445     ok(hr == S_OK, "got %08x\n", hr);
 446     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 447     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 448     ok(dst == 10, "got %08x\n", dst);
 449     SysFreeString(b);
 450
 451     dst = 0x1234;
 452     *(SCODE *)src = 0x4321cafe;
 453     hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 454     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 455     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 456     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 457     ok(dst == 0x1234, "got %08x\n", dst);
 458
 459     dst = 0x1234;
 460     *(VARIANT_BOOL *)src = VARIANT_TRUE;
 461     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 462     ok(hr == S_OK, "got %08x\n", hr);
 463     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 464     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 465     ok(dst == -1, "got %08x\n", dst);
 466
 467     dst = 0x1234;
 468     *(VARIANT_BOOL *)src = VARIANT_FALSE;
 469     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 470     ok(hr == S_OK, "got %08x\n", hr);
 471     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 472     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 473     ok(dst == 0, "got %08x\n", dst);
 474
 475     dst = 0x1234;
 476     V_VT((VARIANT*)src) = VT_I2;
 477     V_I2((VARIANT*)src) = 0x4321;
 478     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 479 todo_wine
 480 {
 481     ok(hr == S_OK, "got %08x\n", hr);
 482     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 483 }
 484     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 485 todo_wine
 486     ok(dst == 0x4321, "got %08x\n", dst);
 487
 488     dst = 0x1234;
 489     memset(src, 0, sizeof(DECIMAL));
 490     ((DECIMAL*)src)->u1.Lo64 = 0x4321;
 491     hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, 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 %d\n", dst_len);
 495     ok(dst == 0x4321, "got %08x\n", dst);
 496
 497     dst = 0x1234;
 498     *(signed char*)src = 0xab;
 499     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 500     ok(hr == S_OK, "got %08x\n", hr);
 501     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 502     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 503     ok(dst == (signed short)0xffab, "got %08x\n", dst);
 504
 505     dst = 0x1234;
 506     *(BYTE*)src = 0xab;
 507     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 508     ok(hr == S_OK, "got %08x\n", hr);
 509     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 510     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 511     ok(dst == 0xab, "got %08x\n", dst);
 512
 513     dst = 0x1234;
 514     *(WORD*)src = 0x4321;
 515     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 516     ok(hr == S_OK, "got %08x\n", hr);
 517     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 518     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 519     ok(dst == 0x4321, "got %08x\n", dst);
 520
 521     dst = 0x1234;
 522     *(WORD*)src = 0xabcd;
 523     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 524     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 525     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 526     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 527     ok(dst == 0x1234, "got %08x\n", dst);
 528
 529     dst = 0x1234;
 530     *(DWORD*)src = 0xabcd1234;
 531     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 532 todo_wine
 533     ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
 534     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 535     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 536     ok(dst == 0x1234, "got %08x\n", dst);
 537
 538     dst = 0x1234;
 539     *(DWORD*)src = 0x1234abcd;
 540     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 541 todo_wine
 542     ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
 543     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 544     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 545     ok(dst == 0x1234, "got %08x\n", dst);
 546
 547     dst = 0x1234;
 548     *(DWORD*)src = 0x4321;
 549     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 550     ok(hr == S_OK, "got %08x\n", hr);
 551     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 552     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 553     ok(dst == 0x4321, "got %08x\n", dst);
 554
 555     dst = 0x1234;
 556     ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
 557     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 558     ok(hr == DB_E_ERRORSOCCURRED ||
 559        broken(hr == DB_E_UNSUPPORTEDCONVERSION), /* win98 */
 560        "got %08x\n", hr);
 561     if(hr != DB_E_UNSUPPORTEDCONVERSION) /* win98 doesn't support I8/UI8 */
 562     {
 563         ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 564         ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 565         ok(dst == 0x1234, "got %08x\n", dst);
 566
 567         dst = 0x1234;
 568         ((LARGE_INTEGER*)src)->QuadPart = 0x4321;
 569         hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 570         ok(hr == S_OK, "got %08x\n", hr);
 571         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 572         ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 573         ok(dst == 0x4321, "got %08x\n", dst);
 574
 575         dst = 0x1234;
 576         ((ULARGE_INTEGER*)src)->QuadPart = 0x4321;
 577         hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 578         ok(hr == S_OK, "got %08x\n", hr);
 579         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 580         ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 581         ok(dst == 0x4321, "got %08x\n", dst);
 582     }
 583
 584     dst = 0x1234;
 585     strcpy((char *)src, "10");
 586     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 587     ok(hr == S_OK, "got %08x\n", hr);
 588     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 589     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 590     ok(dst == 10, "got %08x\n", dst);
 591
 592     dst = 0x1234;
 593     strcpy((char *)src, "10");
 594     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 595     ok(hr == S_OK, "got %08x\n", hr);
 596     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 597     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 598     ok(dst == 10, "got %08x\n", dst);
 599
 600     dst = 0x1234;
 601     memcpy(src, ten, sizeof(ten));
 602     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 603     ok(hr == S_OK, "got %08x\n", hr);
 604     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 605     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 606     ok(dst == 10, "got %08x\n", dst);
 607
 608     dst = 0x1234;
 609     memcpy(src, ten, sizeof(ten));
 610     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 611     ok(hr == S_OK, "got %08x\n", hr);
 612     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 613     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 614     ok(dst == 10, "got %08x\n", dst);
 615
 616     IDataConvert_Release(convert);
 617 }
 618
 619 static void test_converttoi4(void)
 620 {
 621     IDataConvert *convert;
 622     HRESULT hr;
 623     INT i4;
 624     BYTE src[20];
 625     DBSTATUS dst_status;
 626     DBLENGTH dst_len;
 627     static const WCHAR ten[] = {'1','0',0};
 628     BSTR b;
 629
 630     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 631     if(FAILED(hr))
 632     {
 633         win_skip("Unable to load oledb conversion library\n");
 634         return;
 635     }
 636
 637     i4 = 0x12345678;
 638     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 639     ok(hr == S_OK, "got %08x\n", hr);
 640     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 641     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 642     ok(i4 == 0, "got %08x\n", i4);
 643
 644     i4 = 0x12345678;
 645     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 646     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 647     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 648     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 649     ok(i4 == 0x12345678, "got %08x\n", i4);
 650
 651     i4 = 0x12345678;
 652     *(short *)src = 0x4321;
 653     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 654     ok(hr == S_OK, "got %08x\n", hr);
 655     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 656     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 657     ok(i4 == 0x4321, "got %08x\n", i4);
 658
 659     i4 = 0x12345678;
 660     *(int *)src = 0x4321cafe;
 661     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 662     ok(hr == S_OK, "got %08x\n", hr);
 663     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 664     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 665     ok(i4 == 0x4321cafe, "got %08x\n", i4);
 666
 667     i4 = 0x12345678;
 668     *(FLOAT *)src = 10.75;
 669     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 670     ok(hr == S_OK, "got %08x\n", hr);
 671     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 672     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 673     ok(i4 == 11, "got %08x\n", i4);
 674
 675     i4 = 0x12345678;
 676     *(FLOAT *)src = -10.75;
 677     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 678     ok(hr == S_OK, "got %08x\n", hr);
 679     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 680     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 681     ok(i4 == -11, "got %08x\n", i4);
 682
 683     i4 = 0x12345678;
 684     *(double *)src = 10.75;
 685     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 686     ok(hr == S_OK, "got %08x\n", hr);
 687     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 688     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 689     ok(i4 == 11, "got %08x\n", i4);
 690
 691     i4 = 0x12345678;
 692     ((LARGE_INTEGER *)src)->QuadPart = 107500;
 693     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 694     ok(hr == S_OK, "got %08x\n", hr);
 695     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 696     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 697     ok(i4 == 11, "got %08x\n", i4);
 698
 699     i4 = 0x12345678;
 700     *(DATE *)src = 10.7500;
 701     hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, 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 %d\n", dst_len);
 705     ok(i4 == 11, "got %08x\n", i4);
 706
 707     i4 = 0x12345678;
 708     b = SysAllocString(ten);
 709     *(BSTR *)src = b;
 710     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, 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 %d\n", dst_len);
 714     ok(i4 == 10, "got %08x\n", i4);
 715     SysFreeString(b);
 716
 717     i4 = 0x12345678;
 718     *(SCODE *)src = 0x4321cafe;
 719     hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 720     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 721     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 722     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 723     ok(i4 == 0x12345678, "got %08x\n", i4);
 724
 725     i4 = 0x12345678;
 726     *(VARIANT_BOOL *)src = VARIANT_TRUE;
 727     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 728     ok(hr == S_OK, "got %08x\n", hr);
 729     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 730     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 731     ok(i4 == 0xffffffff, "got %08x\n", i4);
 732
 733     i4 = 0x12345678;
 734     *(VARIANT_BOOL *)src = VARIANT_FALSE;
 735     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 736     ok(hr == S_OK, "got %08x\n", hr);
 737     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 738     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 739     ok(i4 == 0, "got %08x\n", i4);
 740
 741     i4 = 0x12345678;
 742     V_VT((VARIANT*)src) = VT_I2;
 743     V_I2((VARIANT*)src) = 0x1234;
 744     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 745 todo_wine
 746 {
 747     ok(hr == S_OK, "got %08x\n", hr);
 748     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 749 }
 750     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 751 todo_wine
 752     ok(i4 == 0x1234, "got %08x\n", i4);
 753
 754     i4 = 0x12345678;
 755     memset(src, 0, sizeof(DECIMAL));
 756     ((DECIMAL*)src)->u1.Lo64 = 0x1234;
 757     hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, 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 %d\n", dst_len);
 761     ok(i4 == 0x1234, "got %08x\n", i4);
 762
 763     i4 = 0x12345678;
 764     *(signed char*)src = 0xab;
 765     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 766     ok(hr == S_OK, "got %08x\n", hr);
 767     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 768     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 769     ok(i4 == 0xffffffab, "got %08x\n", i4);
 770
 771     i4 = 0x12345678;
 772     *(BYTE*)src = 0xab;
 773     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 774     ok(hr == S_OK, "got %08x\n", hr);
 775     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 776     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 777     ok(i4 == 0xab, "got %08x\n", i4);
 778
 779     i4 = 0x12345678;
 780     *(WORD*)src = 0xabcd;
 781     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 782     ok(hr == S_OK, "got %08x\n", hr);
 783     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 784     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 785     ok(i4 == 0xabcd, "got %08x\n", i4);
 786
 787     i4 = 0x12345678;
 788     *(DWORD*)src = 0xabcd1234;
 789     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 790     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 791     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 792     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 793     ok(i4 == 0x12345678, "got %08x\n", i4);
 794
 795     i4 = 0x12345678;
 796     *(DWORD*)src = 0x1234abcd;
 797     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 798     ok(hr == S_OK, "got %08x\n", hr);
 799     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 800     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 801     ok(i4 == 0x1234abcd, "got %08x\n", i4);
 802
 803     i4 = 0x12345678;
 804     ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
 805     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 806     ok(hr == S_OK ||
 807        broken(hr == DB_E_UNSUPPORTEDCONVERSION), /* win98 */
 808        "got %08x\n", hr);
 809     if(hr != DB_E_UNSUPPORTEDCONVERSION) /* win98 doesn't support I8/UI8 */
 810     {
 811         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 812         ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 813         ok(i4 == 0x1234abcd, "got %08x\n", i4);
 814
 815         i4 = 0x12345678;
 816         ((ULARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
 817         hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 818         ok(hr == S_OK, "got %08x\n", hr);
 819         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 820         ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 821         ok(i4 == 0x1234abcd, "got %08x\n", i4);
 822     }
 823
 824     i4 = 0x12345678;
 825     strcpy((char *)src, "10");
 826     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 2, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 827     ok(hr == S_OK, "got %08x\n", hr);
 828     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 829     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 830     ok(i4 == 10, "got %08x\n", i4);
 831
 832     i4 = 0x12345678;
 833     strcpy((char *)src, "10");
 834     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 835     ok(hr == S_OK, "got %08x\n", hr);
 836     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 837     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 838     ok(i4 == 10, "got %08x\n", i4);
 839
 840     i4 = 0x12345678;
 841     memcpy(src, ten, sizeof(ten));
 842     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 4, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 843     ok(hr == S_OK, "got %08x\n", hr);
 844     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 845     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 846     ok(i4 == 10, "got %08x\n", i4);
 847
 848     i4 = 0x12345678;
 849     memcpy(src, ten, sizeof(ten));
 850     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 851     ok(hr == S_OK, "got %08x\n", hr);
 852     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 853     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 854     ok(i4 == 10, "got %08x\n", i4);
 855
 856     IDataConvert_Release(convert);
 857 }
 858
 859 static void test_converttobstr(void)
 860 {
 861     IDataConvert *convert;
 862     HRESULT hr;
 863     BSTR dst;
 864     BYTE src[20];
 865     DBSTATUS dst_status;
 866     DBLENGTH dst_len;
 867     static const WCHAR ten[] = {'1','0',0};
 868     BSTR b;
 869
 870     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 871     if(FAILED(hr))
 872     {
 873         win_skip("Unable to load oledb conversion library\n");
 874         return;
 875     }
 876
 877     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 878     ok(hr == S_OK, "got %08x\n", hr);
 879     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 880     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 881     ok(dst != NULL, "got %p\n", dst);
 882     ok(SysStringLen(dst) == 0, "got %d\n", SysStringLen(dst));
 883     SysFreeString(dst);
 884
 885     dst = (void*)0x1234;
 886     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 887     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 888     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 889     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 890     ok(dst == (void*)0x1234, "got %p\n", dst);
 891
 892     *(short *)src = 4321;
 893     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 894     ok(hr == S_OK, "got %08x\n", hr);
 895     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 896     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 897     ok(dst != NULL, "got %p\n", dst);
 898     ok(SysStringLen(dst) == 4, "got %d\n", SysStringLen(dst));
 899     SysFreeString(dst);
 900
 901     b = SysAllocString(ten);
 902     *(BSTR *)src = b;
 903     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 904     ok(hr == S_OK, "got %08x\n", hr);
 905     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 906     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 907     ok(dst != NULL, "got %p\n", dst);
 908     ok(dst != b, "got %p src %p\n", dst, b);
 909     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
 910     SysFreeString(dst);
 911     SysFreeString(b);
 912
 913     IDataConvert_Release(convert);
 914 }
 915
 916 static void test_converttowstr(void)
 917 {
 918     IDataConvert *convert;
 919     HRESULT hr;
 920     WCHAR dst[100];
 921     BYTE src[20];
 922     DBSTATUS dst_status;
 923     DBLENGTH dst_len;
 924     static const WCHAR ten[] = {'1','0',0};
 925     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
 926     BSTR b;
 927
 928     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 929     if(FAILED(hr))
 930     {
 931         win_skip("Unable to load oledb conversion library\n");
 932         return;
 933     }
 934
 935
 936     memset(dst, 0xcc, sizeof(dst));
 937     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 938     ok(hr == S_OK, "got %08x\n", hr);
 939     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 940     ok(dst_len == 0, "got %d\n", dst_len);
 941     ok(dst[0] == 0, "got %02x\n", dst[0]);
 942     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
 943
 944     memset(dst, 0xcc, sizeof(dst));
 945     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 946     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 947     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 948     ok(dst_len == 0, "got %d\n", dst_len);
 949     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
 950
 951     *(short *)src = 4321;
 952     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 953     ok(hr == S_OK, "got %08x\n", hr);
 954     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 955     ok(dst_len == 8, "got %d\n", dst_len);
 956     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
 957
 958     *(short *)src = 4321;
 959     memset(dst, 0xcc, sizeof(dst));
 960     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
 961     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 962     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 963     ok(dst_len == 8, "got %d\n", dst_len);
 964     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
 965
 966     *(short *)src = 4321;
 967     memset(dst, 0xcc, sizeof(dst));
 968     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
 969     ok(hr == S_OK, "got %08x\n", hr);
 970     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 971     ok(dst_len == 8, "got %d\n", dst_len);
 972     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
 973
 974     *(short *)src = 4321;
 975     memset(dst, 0xcc, sizeof(dst));
 976     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
 977     ok(hr == S_OK, "got %08x\n", hr);
 978     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
 979     ok(dst_len == 8, "got %d\n", dst_len);
 980     ok(dst[0] == '4', "got %02x\n", dst[0]);
 981     ok(dst[1] == 0, "got %02x\n", dst[1]);
 982     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
 983
 984     *(short *)src = 4321;
 985     memset(dst, 0xcc, sizeof(dst));
 986     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
 987     ok(hr == S_OK, "got %08x\n", hr);
 988     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
 989     ok(dst_len == 8, "got %d\n", dst_len);
 990     ok(dst[0] == 0, "got %02x\n", dst[0]);
 991     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
 992
 993     *(short *)src = 4321;
 994     memset(dst, 0xcc, sizeof(dst));
 995     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
 996     ok(hr == S_OK, "got %08x\n", hr);
 997     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
 998     ok(dst_len == 8, "got %d\n", dst_len);
 999     ok(dst[0] == '4', "got %02x\n", dst[0]);
1000     ok(dst[1] == '3', "got %02x\n", dst[1]);
1001     ok(dst[2] == '2', "got %02x\n", dst[2]);
1002     ok(dst[3] == 0, "got %02x\n", dst[3]);
1003     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
1004
1005     b = SysAllocString(ten);
1006     *(BSTR *)src = b;
1007     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1008     ok(hr == S_OK, "got %08x\n", hr);
1009     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1010     ok(dst_len == 4, "got %d\n", dst_len);
1011     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1012     SysFreeString(b);
1013
1014     memcpy(src, ten, sizeof(ten));
1015     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1016     ok(hr == S_OK, "got %08x\n", hr);
1017     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1018     ok(dst_len == 2, "got %d\n", dst_len);
1019     ok(dst[0] == '1', "got %02x\n", dst[0]);
1020     ok(dst[1] == 0, "got %02x\n", dst[1]);
1021
1022     memcpy(src, ten, sizeof(ten));
1023     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1024     ok(hr == S_OK, "got %08x\n", hr);
1025     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1026     ok(dst_len == 4, "got %d\n", dst_len);
1027     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1028
1029     memcpy(src, ten, sizeof(ten));
1030     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1031     ok(hr == S_OK, "got %08x\n", hr);
1032     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1033     ok(dst_len == 4, "got %d\n", dst_len);
1034     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1035
1036     IDataConvert_Release(convert);
1037 }
1038
1039 static void test_converttobyrefwstr(void)
1040 {
1041     IDataConvert *convert;
1042     HRESULT hr;
1043     WCHAR *dst;
1044     BYTE src[20];
1045     DBSTATUS dst_status;
1046     DBLENGTH dst_len;
1047     static const WCHAR ten[] = {'1','0',0};
1048     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1049     BSTR b;
1050
1051     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1052     if(FAILED(hr))
1053     {
1054         win_skip("Unable to load oledb conversion library\n");
1055         return;
1056     }
1057
1058     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1059     ok(hr == S_OK, "got %08x\n", hr);
1060     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1061     ok(dst_len == 0, "got %d\n", dst_len);
1062     ok(dst[0] == 0, "got %04x\n", dst[0]);
1063     CoTaskMemFree(dst);
1064
1065     dst = (void*)0x12345678;
1066     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1067     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1068     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1069     ok(dst_len == 0, "got %d\n", dst_len);
1070     ok(dst == (void*)0x12345678, "got %p\n", dst);
1071
1072     *(short *)src = 4321;
1073     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1074     ok(hr == S_OK, "got %08x\n", hr);
1075     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1076     ok(dst_len == 8, "got %d\n", dst_len);
1077     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1078     CoTaskMemFree(dst);
1079
1080     *(short *)src = 4321;
1081     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, 0, 0, &dst_status, 0, 0, 0);
1082     ok(hr == S_OK, "got %08x\n", hr);
1083     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1084     ok(dst_len == 8, "got %d\n", dst_len);
1085     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1086     CoTaskMemFree(dst);
1087
1088     b = SysAllocString(ten);
1089     *(BSTR *)src = b;
1090     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1091     ok(hr == S_OK, "got %08x\n", hr);
1092     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1093     ok(dst_len == 4, "got %d\n", dst_len);
1094     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1095     CoTaskMemFree(dst);
1096     SysFreeString(b);
1097
1098     memcpy(src, ten, sizeof(ten));
1099     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1100     ok(hr == S_OK, "got %08x\n", hr);
1101     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1102     ok(dst_len == 2, "got %d\n", dst_len);
1103     ok(dst[0] == '1', "got %02x\n", dst[0]);
1104     ok(dst[1] == 0, "got %02x\n", dst[1]);
1105     CoTaskMemFree(dst);
1106
1107     memcpy(src, ten, sizeof(ten));
1108     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1109     ok(hr == S_OK, "got %08x\n", hr);
1110     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1111     ok(dst_len == 4, "got %d\n", dst_len);
1112     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1113     CoTaskMemFree(dst);
1114
1115     memcpy(src, ten, sizeof(ten));
1116     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1117     ok(hr == S_OK, "got %08x\n", hr);
1118     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1119     ok(dst_len == 4, "got %d\n", dst_len);
1120     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1121     CoTaskMemFree(dst);
1122
1123     IDataConvert_Release(convert);
1124 }
1125
1126 static void test_converttoguid(void)
1127 {
1128     IDataConvert *convert;
1129     HRESULT hr;
1130     GUID dst;
1131     BYTE src[20];
1132     DBSTATUS dst_status;
1133     DBLENGTH dst_len;
1134
1135     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1136     if(FAILED(hr))
1137     {
1138         win_skip("Unable to load oledb conversion library\n");
1139         return;
1140     }
1141
1142     dst = IID_IDCInfo;
1143     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1144     ok(hr == S_OK, "got %08x\n", hr);
1145     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1146     ok(dst_len == sizeof(GUID), "got %d\n", dst_len);
1147     ok(IsEqualGUID(&dst, &GUID_NULL), "didn't get GUID_NULL\n");
1148
1149     dst = IID_IDCInfo;
1150     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1151     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1152     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1153     ok(dst_len == sizeof(GUID), "got %d\n", dst_len);
1154     ok(IsEqualGUID(&dst, &IID_IDCInfo), "dst has changed\n");
1155
1156     dst = IID_IDCInfo;
1157     memcpy(src, &IID_IDataConvert, sizeof(GUID));
1158     hr = IDataConvert_DataConvert(convert, DBTYPE_GUID, DBTYPE_GUID, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1159     ok(hr == S_OK, "got %08x\n", hr);
1160     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1161     ok(dst_len == sizeof(GUID), "got %d\n", dst_len);
1162     ok(IsEqualGUID(&dst, &IID_IDataConvert), "didn't get IID_IDataConvert\n");
1163
1164     IDataConvert_Release(convert);
1165 }
1166
1167 static void test_converttofiletime(void)
1168 {
1169     IDataConvert *convert;
1170     HRESULT hr;
1171     FILETIME dst;
1172     BYTE src[20];
1173     DBSTATUS dst_status;
1174     DBLENGTH dst_len;
1175
1176     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1177     if(FAILED(hr))
1178     {
1179         win_skip("Unable to load oledb conversion library\n");
1180         return;
1181     }
1182
1183     memset(&dst, 0xcc, sizeof(dst));
1184     ((FILETIME *)src)->dwLowDateTime = 0x12345678;
1185     ((FILETIME *)src)->dwHighDateTime = 0x9abcdef0;
1186     hr = IDataConvert_DataConvert(convert, DBTYPE_FILETIME, DBTYPE_FILETIME, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1187     ok(hr == S_OK ||
1188        broken(hr == DB_E_BADBINDINFO), /* win98 */
1189        "got %08x\n", hr);
1190     if(SUCCEEDED(hr))
1191     {
1192         ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1193         ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1194         ok(dst.dwLowDateTime == 0x12345678, "got %08x\n", dst.dwLowDateTime);
1195         ok(dst.dwHighDateTime == 0x9abcdef0, "got %08x\n", dst.dwHighDateTime);
1196     }
1197
1198     IDataConvert_Release(convert);
1199 }
1200
1201 static void test_converttoui1(void)
1202 {
1203     IDataConvert *convert;
1204     HRESULT hr;
1205     BYTE dst;
1206     BYTE src[20];
1207     DBSTATUS dst_status;
1208     DBLENGTH dst_len;
1209
1210     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1211     if(FAILED(hr))
1212     {
1213         win_skip("Unable to load oledb conversion library\n");
1214         return;
1215     }
1216
1217     dst = 0x12;
1218     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 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 == sizeof(dst), "got %d\n", dst_len);
1222     ok(dst == 0, "got %08x\n", dst);
1223
1224     dst = 0x12;
1225     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1226     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1227     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1228     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1229     ok(dst == 0x12, "got %08x\n", dst);
1230
1231     dst = 0x12;
1232     src[0] = 0x43;
1233     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1234     ok(hr == S_OK, "got %08x\n", hr);
1235     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1236     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1237     ok(dst == 0x43, "got %08x\n", dst);
1238
1239     dst = 0x12;
1240     src[0] = 0xfe;
1241     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_UI1, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1242     ok(hr == S_OK, "got %08x\n", hr);
1243     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1244     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1245     ok(dst == 0xfe, "got %08x\n", dst);
1246
1247     IDataConvert_Release(convert);
1248 }
1249
1250 static void test_converttoui4(void)
1251 {
1252     IDataConvert *convert;
1253     HRESULT hr;
1254     DWORD dst;
1255     BYTE src[20];
1256     DBSTATUS dst_status;
1257     DBLENGTH dst_len;
1258
1259     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1260     if(FAILED(hr))
1261     {
1262         win_skip("Unable to load oledb conversion library\n");
1263         return;
1264     }
1265
1266     dst = 0x12345678;
1267     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1268     ok(hr == S_OK, "got %08x\n", hr);
1269     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1270     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1271     ok(dst == 0, "got %08x\n", dst);
1272
1273     dst = 0x12345678;
1274     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1275     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1276     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1277     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1278     ok(dst == 0x12345678, "got %08x\n", dst);
1279
1280     dst = 0x12345678;
1281     *(DWORD*)src = 0x87654321;
1282     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1283     ok(hr == S_OK, "got %08x\n", hr);
1284     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1285     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1286     ok(dst == 0x87654321, "got %08x\n", dst);
1287
1288     dst = 0x12345678;
1289     *(signed short *)src = 0x4321;
1290     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1291     ok(hr == S_OK, "got %08x\n", hr);
1292     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1293     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1294     ok(dst == 0x4321, "got %08x\n", dst);
1295
1296     dst = 0x12345678;
1297     *(signed short *)src = -1;
1298     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_UI4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1299     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1300 todo_wine
1301     ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
1302     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1303     ok(dst == 0x12345678, "got %08x\n", dst);
1304
1305     IDataConvert_Release(convert);
1306 }
1307
1308 static void test_converttor4(void)
1309 {
1310     IDataConvert *convert;
1311     HRESULT hr;
1312     FLOAT dst;
1313     BYTE src[20];
1314     DBSTATUS dst_status;
1315     DBLENGTH dst_len;
1316
1317     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1318     if(FAILED(hr))
1319     {
1320         win_skip("Unable to load oledb conversion library\n");
1321         return;
1322     }
1323
1324     dst = 1.0;
1325     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1326     ok(hr == S_OK, "got %08x\n", hr);
1327     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1328     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1329     ok(dst == 0.0, "got %f\n", dst);
1330
1331     dst = 1.0;
1332     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1333     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1334     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1335     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1336     ok(dst == 1.0, "got %f\n", dst);
1337
1338     dst = 1.0;
1339     *(signed int*)src = 12345678;
1340     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1341     ok(hr == S_OK, "got %08x\n", hr);
1342     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1343     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1344     ok(dst == 12345678.0, "got %f\n", dst);
1345
1346     dst = 1.0;
1347     *(FLOAT *)src = 10.0;
1348     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_R4, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1349     ok(hr == S_OK, "got %08x\n", hr);
1350     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1351     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1352     ok(dst == 10.0, "got %f\n", dst);
1353
1354     IDataConvert_Release(convert);
1355 }
1356
1357 static void test_converttocy(void)
1358 {
1359     IDataConvert *convert;
1360     HRESULT hr;
1361     CY dst;
1362     BYTE src[20];
1363     DBSTATUS dst_status;
1364     DBLENGTH dst_len;
1365
1366     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1367     if(FAILED(hr))
1368     {
1369         win_skip("Unable to load oledb conversion library\n");
1370         return;
1371     }
1372
1373     dst.int64 = 0xcc;
1374     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1375     ok(hr == S_OK, "got %08x\n", hr);
1376     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1377     ok(dst_len == sizeof(CY), "got %d\n", dst_len);
1378     ok(dst.int64 == 0, "didn't get 0\n");
1379
1380     dst.int64 = 0xcc;
1381     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1382     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1383     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1384     ok(dst_len == sizeof(CY), "got %d\n", dst_len);
1385     ok(dst.int64 == 0xcc, "dst changed\n");
1386
1387     dst.int64 = 0xcc;
1388     *(int*)src = 1234;
1389     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1390     ok(hr == S_OK, "got %08x\n", hr);
1391     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1392     ok(dst_len == sizeof(CY), "got %d\n", dst_len);
1393     ok(dst.int64 == 12340000, "got %d\n", dst.s.Lo);
1394
1395     dst.int64 = 0xcc;
1396     ((CY*)src)->int64 = 1234;
1397     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, DBTYPE_CY, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1398     ok(hr == S_OK, "got %08x\n", hr);
1399     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1400     ok(dst_len == sizeof(CY), "got %d\n", dst_len);
1401     ok(dst.int64 == 1234, "got %d\n", dst.s.Lo);
1402
1403     IDataConvert_Release(convert);
1404 }
1405
1406 static void test_converttoui8(void)
1407 {
1408     IDataConvert *convert;
1409     HRESULT hr;
1410     ULARGE_INTEGER dst;
1411     BYTE src[20];
1412     DBSTATUS dst_status;
1413     DBLENGTH dst_len;
1414
1415     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1416     if(FAILED(hr))
1417     {
1418         win_skip("Unable to load oledb conversion library\n");
1419         return;
1420     }
1421
1422     dst.QuadPart = 0xcc;
1423     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1424     ok(hr == S_OK, "got %08x\n", hr);
1425     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1426     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1427     ok(dst.QuadPart == 0, "got %d\n", (int)dst.QuadPart);
1428
1429     dst.QuadPart = 0xcc;
1430     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1431     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1432     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1433     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1434     ok(dst.QuadPart == 0xcc, "dst changed\n");
1435
1436     dst.QuadPart = 0xcc;
1437     *(int*)src = 1234;
1438     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1439     ok(hr == S_OK, "got %08x\n", hr);
1440     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1441     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1442     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
1443
1444     dst.QuadPart = 0xcc;
1445     *(int*)src = -1234;
1446     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1447     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
1448 todo_wine
1449     ok(dst_status == DBSTATUS_E_SIGNMISMATCH, "got %08x\n", dst_status);
1450     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1451     ok(dst.QuadPart == 0xcc, "got %d\n", (int)dst.QuadPart);
1452
1453     dst.QuadPart = 0xcc;
1454     ((ULARGE_INTEGER*)src)->QuadPart = 1234;
1455     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_UI8, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1456     ok(hr == S_OK, "got %08x\n", hr);
1457     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1458     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
1459     ok(dst.QuadPart == 1234, "got %d\n", (int)dst.QuadPart);
1460
1461     IDataConvert_Release(convert);
1462 }
1463
1464 START_TEST(convert)
1465 {
1466     OleInitialize(NULL);
1467     test_dcinfo();
1468     test_canconvert();
1469     test_converttoi2();
1470     test_converttoi4();
1471     test_converttobstr();
1472     test_converttowstr();
1473     test_converttobyrefwstr();
1474     test_converttoguid();
1475     test_converttoui1();
1476     test_converttoui4();
1477     test_converttor4();
1478     test_converttofiletime();
1479     test_converttocy();
1480     test_converttoui8();
1481     OleUninitialize();
1482 }