git.oblomov.eu Git - wine/blob - dlls/oledb32/tests/convert.c

   1 /* OLE DB Conversion library tests
   2  *
   3  * Copyright 2009 Huw Davies
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24 #define NONAMELESSSTRUCT
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "ole2.h"
  29 #include "msdadc.h"
  30
  31 #include "oledberr.h"
  32
  33 #include "initguid.h"
  34 #include "msdaguid.h"
  35
  36 #include "wine/test.h"
  37
  38 static void test_dcinfo(void)
  39 {
  40     IDCInfo *info;
  41     HRESULT hr;
  42     DCINFOTYPE types[2];
  43     DCINFO *inf;
  44
  45     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDCInfo, (void**)&info);
  46     if(FAILED(hr))
  47     {
  48         win_skip("Unable to load oledb conversion library\n");
  49         return;
  50     }
  51
  52     types[0] = DCINFOTYPE_VERSION;
  53     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  54     ok(hr == S_OK, "got %08x\n", hr);
  55
  56     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  57     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  58     ok(V_UI4(&inf->vData) == 0x110, "got %08x\n", V_UI4(&inf->vData));
  59
  60     V_UI4(&inf->vData) = 0x200;
  61     hr = IDCInfo_SetInfo(info, 1, inf);
  62     ok(hr == S_OK, "got %08x\n", hr);
  63     CoTaskMemFree(inf);
  64
  65     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  66     ok(hr == S_OK, "got %08x\n", hr);
  67     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  68     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  69     ok(V_UI4(&inf->vData) == 0x200, "got %08x\n", V_UI4(&inf->vData));
  70
  71     V_UI4(&inf->vData) = 0x100;
  72     hr = IDCInfo_SetInfo(info, 1, inf);
  73     ok(hr == S_OK, "got %08x\n", hr);
  74     CoTaskMemFree(inf);
  75
  76     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  77     ok(hr == S_OK, "got %08x\n", hr);
  78     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  79     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  80     ok(V_UI4(&inf->vData) == 0x100, "got %08x\n", V_UI4(&inf->vData));
  81
  82     V_UI4(&inf->vData) = 0x500;
  83     hr = IDCInfo_SetInfo(info, 1, inf);
  84     ok(hr == S_OK, "got %08x\n", hr);
  85     CoTaskMemFree(inf);
  86
  87     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  88     ok(hr == S_OK, "got %08x\n", hr);
  89     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
  90     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
  91     ok(V_UI4(&inf->vData) == 0x500, "got %08x\n", V_UI4(&inf->vData));
  92
  93     V_UI4(&inf->vData) = 0xffff;
  94     hr = IDCInfo_SetInfo(info, 1, inf);
  95     ok(hr == S_OK, "got %08x\n", hr);
  96     CoTaskMemFree(inf);
  97
  98     hr = IDCInfo_GetInfo(info, 1, types, &inf);
  99     ok(hr == S_OK, "got %08x\n", hr);
 100     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
 101     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
 102     ok(V_UI4(&inf->vData) == 0xffff, "got %08x\n", V_UI4(&inf->vData));
 103
 104     V_UI4(&inf->vData) = 0x12345678;
 105     hr = IDCInfo_SetInfo(info, 1, inf);
 106     ok(hr == S_OK, "got %08x\n", hr);
 107     CoTaskMemFree(inf);
 108
 109     hr = IDCInfo_GetInfo(info, 1, types, &inf);
 110     ok(hr == S_OK, "got %08x\n", hr);
 111     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
 112     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
 113     ok(V_UI4(&inf->vData) == 0x12345678, "got %08x\n", V_UI4(&inf->vData));
 114
 115     /* Try setting a version variant of something other than VT_UI4 */
 116     V_VT(&inf->vData) = VT_I4;
 117     V_I4(&inf->vData) = 0x200;
 118     hr = IDCInfo_SetInfo(info, 1, inf);
 119     ok(hr == DB_S_ERRORSOCCURRED, "got %08x\n", hr);
 120     CoTaskMemFree(inf);
 121
 122     hr = IDCInfo_GetInfo(info, 1, types, &inf);
 123     ok(hr == S_OK, "got %08x\n", hr);
 124     ok(inf->eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf->eInfoType);
 125     ok(V_VT(&inf->vData) == VT_UI4, "got %08x\n", V_VT(&inf->vData));
 126     ok(V_UI4(&inf->vData) == 0x12345678, "got %08x\n", V_UI4(&inf->vData));
 127     CoTaskMemFree(inf);
 128
 129     /* More than one type */
 130     types[1] = 2;
 131     hr = IDCInfo_GetInfo(info, 2, types, &inf);
 132     ok(hr == S_OK, "got %08x\n", hr);
 133     ok(inf[0].eInfoType == DCINFOTYPE_VERSION, "got %08x\n", inf[0].eInfoType);
 134     ok(V_VT(&inf[0].vData) == VT_UI4, "got %08x\n", V_VT(&inf[0].vData));
 135     ok(V_UI4(&inf[0].vData) == 0x12345678, "got %08x\n", V_UI4(&inf[0].vData));
 136     ok(inf[1].eInfoType == 2, "got %08x\n", inf[1].eInfoType);
 137     ok(V_VT(&inf[1].vData) == VT_EMPTY, "got %08x\n", V_VT(&inf[1].vData));
 138
 139     hr = IDCInfo_SetInfo(info, 2, inf);
 140     ok(hr == S_OK, "got %08x\n", hr);
 141     CoTaskMemFree(inf);
 142
 143
 144     IDCInfo_Release(info);
 145 }
 146
 147 struct can_convert
 148 {
 149     DBTYPE type;
 150     DWORD can_convert_to;
 151 } simple_convert[] =
 152 {
 153     {DBTYPE_EMPTY,       0x23bfd9ff},
 154     {DBTYPE_NULL,        0x00001002},
 155     {DBTYPE_I2,          0x3b9fd9ff},
 156     {DBTYPE_I4,          0x3bdfd9ff},
 157
 158     {DBTYPE_R4,          0x3b9fd9ff},
 159     {DBTYPE_R8,          0x3b9fd9ff},
 160     {DBTYPE_CY,          0x039fd97f},
 161     {DBTYPE_DATE,        0x399f99bf},
 162
 163     {DBTYPE_BSTR,        0x3bffd9ff},
 164     {DBTYPE_IDISPATCH,   0x3bffffff},
 165     {DBTYPE_ERROR,       0x01001500},
 166     {DBTYPE_BOOL,        0x039fd9ff},
 167
 168     {DBTYPE_VARIANT,     0x3bffffff},
 169     {DBTYPE_IUNKNOWN,    0x00003203},
 170     {DBTYPE_DECIMAL,     0x3b9fd97f},
 171     {DBTYPE_I1,          0x3b9fd9ff},
 172
 173     {DBTYPE_UI1,         0x3b9fd9ff},
 174     {DBTYPE_UI2,         0x3b9fd9ff},
 175     {DBTYPE_UI4,         0x3bdfd9ff},
 176     {DBTYPE_I8,          0x03dfd97f},
 177
 178     {DBTYPE_UI8,         0x03dfd97f},
 179     {DBTYPE_GUID,        0x01e01103},
 180     {DBTYPE_BYTES,       0x01fc110b},
 181     {DBTYPE_STR,         0x3bffd9ff},
 182
 183     {DBTYPE_WSTR,        0x3bffd9ff},
 184     {DBTYPE_NUMERIC,     0x039fd97f},
 185     {DBTYPE_UDT,         0x00000000},
 186     {DBTYPE_DBDATE,      0x39801183},
 187
 188     {DBTYPE_DBTIME,      0x39801183},
 189     {DBTYPE_DBTIMESTAMP, 0x39801183}
 190 };
 191
 192
 193 static inline BOOL array_type(DBTYPE type)
 194 {
 195     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 196 }
 197
 198 static void test_canconvert(void)
 199 {
 200     IDataConvert *convert;
 201     HRESULT hr;
 202     int src_idx, dst_idx;
 203
 204     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 205     if(FAILED(hr))
 206     {
 207         win_skip("Unable to load oledb conversion library\n");
 208         return;
 209     }
 210
 211     /* Some older versions of the library don't support several conversions, we'll skip
 212        if we have such a library */
 213     hr = IDataConvert_CanConvert(convert, DBTYPE_EMPTY, DBTYPE_DBTIMESTAMP);
 214     if(hr == S_FALSE)
 215     {
 216         win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
 217         IDataConvert_Release(convert);
 218         return;
 219     }
 220
 221     /* Some older versions of the library don't support several conversions, we'll skip
 222        if we have such a library */
 223     hr = IDataConvert_CanConvert(convert, DBTYPE_EMPTY, DBTYPE_DBTIMESTAMP);
 224     if(hr == S_FALSE)
 225     {
 226         win_skip("Doesn't handle DBTYPE_EMPTY -> DBTYPE_DBTIMESTAMP conversion so skipping\n");
 227         IDataConvert_Release(convert);
 228         return;
 229     }
 230
 231     for(src_idx = 0; src_idx < sizeof(simple_convert) / sizeof(simple_convert[0]); src_idx++)
 232         for(dst_idx = 0; dst_idx < sizeof(simple_convert) / sizeof(simple_convert[0]); dst_idx++)
 233         {
 234             BOOL expect, simple_expect;
 235             simple_expect = (simple_convert[src_idx].can_convert_to >> dst_idx) & 1;
 236
 237             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type);
 238             expect = simple_expect;
 239             ok((hr == S_OK && expect == TRUE) ||
 240                (hr == S_FALSE && expect == FALSE),
 241                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 242                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 243
 244             /* src DBTYPE_BYREF */
 245             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_BYREF, simple_convert[dst_idx].type);
 246             expect = simple_expect;
 247             ok((hr == S_OK && expect == TRUE) ||
 248                (hr == S_FALSE && expect == FALSE),
 249                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_BYREF,
 250                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 251
 252             /* dst DBTYPE_BYREF */
 253             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_BYREF);
 254             expect = FALSE;
 255             if(simple_expect &&
 256                (simple_convert[dst_idx].type == DBTYPE_BYTES ||
 257                 simple_convert[dst_idx].type == DBTYPE_STR ||
 258                 simple_convert[dst_idx].type == DBTYPE_WSTR))
 259                 expect = TRUE;
 260             ok((hr == S_OK && expect == TRUE) ||
 261                (hr == S_FALSE && expect == FALSE),
 262                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 263                simple_convert[dst_idx].type | DBTYPE_BYREF, hr, expect ? "" : "not ");
 264
 265             /* src & dst DBTYPE_BYREF */
 266             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_BYREF, simple_convert[dst_idx].type | DBTYPE_BYREF);
 267             expect = FALSE;
 268             if(simple_expect &&
 269                (simple_convert[dst_idx].type == DBTYPE_BYTES ||
 270                 simple_convert[dst_idx].type == DBTYPE_STR ||
 271                 simple_convert[dst_idx].type == DBTYPE_WSTR))
 272                 expect = TRUE;
 273             ok((hr == S_OK && expect == TRUE) ||
 274                (hr == S_FALSE && expect == FALSE),
 275                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_BYREF,
 276                simple_convert[dst_idx].type | DBTYPE_BYREF, hr, expect ? "" : "not ");
 277
 278             /* src DBTYPE_ARRAY */
 279             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_ARRAY, simple_convert[dst_idx].type);
 280             expect = FALSE;
 281             if(array_type(simple_convert[src_idx].type) && simple_convert[dst_idx].type == DBTYPE_VARIANT)
 282                 expect = TRUE;
 283             ok((hr == S_OK && expect == TRUE) ||
 284                (hr == S_FALSE && expect == FALSE),
 285                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_ARRAY,
 286                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 287
 288             /* dst DBTYPE_ARRAY */
 289             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_ARRAY);
 290             expect = FALSE;
 291             if(array_type(simple_convert[dst_idx].type) &&
 292                (simple_convert[src_idx].type == DBTYPE_IDISPATCH ||
 293                 simple_convert[src_idx].type == DBTYPE_VARIANT))
 294                 expect = TRUE;
 295             ok((hr == S_OK && expect == TRUE) ||
 296                (hr == S_FALSE && expect == FALSE),
 297                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 298                simple_convert[dst_idx].type | DBTYPE_ARRAY, hr, expect ? "" : "not ");
 299
 300             /* src & dst DBTYPE_ARRAY */
 301             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_ARRAY, simple_convert[dst_idx].type | DBTYPE_ARRAY);
 302             expect = FALSE;
 303             if(array_type(simple_convert[src_idx].type) &&
 304                simple_convert[src_idx].type == simple_convert[dst_idx].type)
 305                 expect = TRUE;
 306             ok((hr == S_OK && expect == TRUE) ||
 307                (hr == S_FALSE && expect == FALSE),
 308                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_ARRAY,
 309                simple_convert[dst_idx].type | DBTYPE_ARRAY, hr, expect ? "" : "not ");
 310
 311             /* src DBTYPE_VECTOR */
 312             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_VECTOR, simple_convert[dst_idx].type);
 313             expect = FALSE;
 314             ok((hr == S_OK && expect == TRUE) ||
 315                (hr == S_FALSE && expect == FALSE),
 316                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_VECTOR,
 317                simple_convert[dst_idx].type, hr, expect ? "" : "not ");
 318
 319             /* dst DBTYPE_VECTOR */
 320             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type, simple_convert[dst_idx].type | DBTYPE_VECTOR);
 321             expect = FALSE;
 322             ok((hr == S_OK && expect == TRUE) ||
 323                (hr == S_FALSE && expect == FALSE),
 324                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type,
 325                simple_convert[dst_idx].type | DBTYPE_VECTOR, hr, expect ? "" : "not ");
 326
 327             /* src & dst DBTYPE_VECTOR */
 328             hr = IDataConvert_CanConvert(convert, simple_convert[src_idx].type | DBTYPE_VECTOR, simple_convert[dst_idx].type | DBTYPE_VECTOR);
 329             expect = FALSE;
 330             ok((hr == S_OK && expect == TRUE) ||
 331                (hr == S_FALSE && expect == FALSE),
 332                "%04x -> %04x: got %08x expect conversion to be %spossible\n", simple_convert[src_idx].type | DBTYPE_VECTOR,
 333                simple_convert[dst_idx].type | DBTYPE_VECTOR, hr, expect ? "" : "not ");
 334
 335
 336         }
 337
 338     IDataConvert_Release(convert);
 339 }
 340
 341 static void test_converttoi2(void)
 342 {
 343     IDataConvert *convert;
 344     HRESULT hr;
 345     signed short dst;
 346     BYTE src[20];
 347     DBSTATUS dst_status;
 348     DBLENGTH dst_len;
 349     static const WCHAR ten[] = {'1','0',0};
 350     BSTR b;
 351
 352     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 353     if(FAILED(hr))
 354     {
 355         win_skip("Unable to load oledb conversion library\n");
 356         return;
 357     }
 358
 359     dst = 0x1234;
 360     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 361     ok(hr == S_OK, "got %08x\n", hr);
 362     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 363     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 364     ok(dst == 0, "got %08x\n", dst);
 365
 366     dst = 0x1234;
 367     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 368     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 369     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 370     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 371     ok(dst == 0x1234, "got %08x\n", dst);
 372
 373     dst = 0x1234;
 374     *(short *)src = 0x4321;
 375     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, 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 %d\n", dst_len);
 379     ok(dst == 0x4321, "got %08x\n", dst);
 380
 381     dst = 0x1234;
 382     *(int *)src = 0x4321cafe;
 383     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 384 todo_wine
 385     ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
 386     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 387     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 388     ok(dst == 0x1234, "got %08x\n", dst);
 389
 390     dst = 0x1234;
 391     *(int *)src = 0x4321;
 392     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 393     ok(hr == S_OK, "got %08x\n", hr);
 394     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 395     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 396     ok(dst == 0x4321, "got %08x\n", dst);
 397
 398     dst = 0x1234;
 399     *(FLOAT *)src = 10.75;
 400     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 401     ok(hr == S_OK, "got %08x\n", hr);
 402     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 403     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 404     ok(dst == 11, "got %08x\n", dst);
 405
 406     dst = 0x1234;
 407     *(FLOAT *)src = -10.75;
 408     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 409     ok(hr == S_OK, "got %08x\n", hr);
 410     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 411     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 412     ok(dst == -11, "got %08x\n", dst);
 413
 414     dst = 0x1234;
 415     *(double *)src = 10.75;
 416     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 417     ok(hr == S_OK, "got %08x\n", hr);
 418     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 419     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 420     ok(dst == 11, "got %08x\n", dst);
 421
 422     dst = 0x1234;
 423     ((LARGE_INTEGER *)src)->QuadPart = 107500;
 424     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, 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 %d\n", dst_len);
 428     ok(dst == 11, "got %08x\n", dst);
 429
 430     dst = 0x1234;
 431     *(DATE *)src = 10.7500;
 432     hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 433     ok(hr == S_OK, "got %08x\n", hr);
 434     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 435     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 436     ok(dst == 11, "got %08x\n", dst);
 437
 438     dst = 0x1234;
 439     b = SysAllocString(ten);
 440     *(BSTR *)src = b;
 441     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, 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 %d\n", dst_len);
 445     ok(dst == 10, "got %08x\n", dst);
 446     SysFreeString(b);
 447
 448     dst = 0x1234;
 449     *(SCODE *)src = 0x4321cafe;
 450     hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 451     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 452     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 453     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 454     ok(dst == 0x1234, "got %08x\n", dst);
 455
 456     dst = 0x1234;
 457     *(VARIANT_BOOL *)src = VARIANT_TRUE;
 458     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, 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 %d\n", dst_len);
 462     ok(dst == -1, "got %08x\n", dst);
 463
 464     dst = 0x1234;
 465     *(VARIANT_BOOL *)src = VARIANT_FALSE;
 466     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 467     ok(hr == S_OK, "got %08x\n", hr);
 468     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 469     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 470     ok(dst == 0, "got %08x\n", dst);
 471
 472     dst = 0x1234;
 473     V_VT((VARIANT*)src) = VT_I2;
 474     V_I2((VARIANT*)src) = 0x4321;
 475     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 476 todo_wine
 477 {
 478     ok(hr == S_OK, "got %08x\n", hr);
 479     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 480 }
 481     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 482 todo_wine
 483     ok(dst == 0x4321, "got %08x\n", dst);
 484
 485     dst = 0x1234;
 486     memset(src, 0, sizeof(DECIMAL));
 487     ((DECIMAL*)src)->u1.Lo64 = 0x4321;
 488     hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 489     ok(hr == S_OK, "got %08x\n", hr);
 490     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 491     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 492     ok(dst == 0x4321, "got %08x\n", dst);
 493
 494     dst = 0x1234;
 495     *(signed char*)src = 0xab;
 496     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 497     ok(hr == S_OK, "got %08x\n", hr);
 498     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 499     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 500     ok(dst == (signed short)0xffab, "got %08x\n", dst);
 501
 502     dst = 0x1234;
 503     *(BYTE*)src = 0xab;
 504     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 505     ok(hr == S_OK, "got %08x\n", hr);
 506     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 507     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 508     ok(dst == 0xab, "got %08x\n", dst);
 509
 510     dst = 0x1234;
 511     *(WORD*)src = 0x4321;
 512     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 513     ok(hr == S_OK, "got %08x\n", hr);
 514     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 515     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 516     ok(dst == 0x4321, "got %08x\n", dst);
 517
 518     dst = 0x1234;
 519     *(WORD*)src = 0xabcd;
 520     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 521     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 522     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 523     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 524     ok(dst == 0x1234, "got %08x\n", dst);
 525
 526     dst = 0x1234;
 527     *(DWORD*)src = 0xabcd1234;
 528     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 529 todo_wine
 530     ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
 531     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 532     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 533     ok(dst == 0x1234, "got %08x\n", dst);
 534
 535     dst = 0x1234;
 536     *(DWORD*)src = 0x1234abcd;
 537     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 538 todo_wine
 539     ok(hr == DB_E_DATAOVERFLOW, "got %08x\n", hr);
 540     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 541     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 542     ok(dst == 0x1234, "got %08x\n", dst);
 543
 544     dst = 0x1234;
 545     *(DWORD*)src = 0x4321;
 546     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 547     ok(hr == S_OK, "got %08x\n", hr);
 548     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 549     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 550     ok(dst == 0x4321, "got %08x\n", dst);
 551
 552     dst = 0x1234;
 553     ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
 554     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 555     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 556     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 557     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 558     ok(dst == 0x1234, "got %08x\n", dst);
 559
 560     dst = 0x1234;
 561     ((LARGE_INTEGER*)src)->QuadPart = 0x4321;
 562     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 563     ok(hr == S_OK, "got %08x\n", hr);
 564     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 565     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 566     ok(dst == 0x4321, "got %08x\n", dst);
 567
 568     dst = 0x1234;
 569     ((ULARGE_INTEGER*)src)->QuadPart = 0x4321;
 570     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 571     ok(hr == S_OK, "got %08x\n", hr);
 572     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 573     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 574     ok(dst == 0x4321, "got %08x\n", dst);
 575
 576     dst = 0x1234;
 577     strcpy((char *)src, "10");
 578     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 579     ok(hr == S_OK, "got %08x\n", hr);
 580     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 581     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 582     ok(dst == 10, "got %08x\n", dst);
 583
 584     dst = 0x1234;
 585     strcpy((char *)src, "10");
 586     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I2, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 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     memcpy(src, ten, sizeof(ten));
 594     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I2, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 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, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 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     IDataConvert_Release(convert);
 609 }
 610
 611 static void test_converttoi4(void)
 612 {
 613     IDataConvert *convert;
 614     HRESULT hr;
 615     INT i4;
 616     BYTE src[20];
 617     DBSTATUS dst_status;
 618     DBLENGTH dst_len;
 619     static const WCHAR ten[] = {'1','0',0};
 620     BSTR b;
 621
 622     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 623     if(FAILED(hr))
 624     {
 625         win_skip("Unable to load oledb conversion library\n");
 626         return;
 627     }
 628
 629     i4 = 0x12345678;
 630     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 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(i4), "got %d\n", dst_len);
 634     ok(i4 == 0, "got %08x\n", i4);
 635
 636     i4 = 0x12345678;
 637     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 638     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 639     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 640     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 641     ok(i4 == 0x12345678, "got %08x\n", i4);
 642
 643     i4 = 0x12345678;
 644     *(short *)src = 0x4321;
 645     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 646     ok(hr == S_OK, "got %08x\n", hr);
 647     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 648     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 649     ok(i4 == 0x4321, "got %08x\n", i4);
 650
 651     i4 = 0x12345678;
 652     *(int *)src = 0x4321cafe;
 653     hr = IDataConvert_DataConvert(convert, DBTYPE_I4, 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 == 0x4321cafe, "got %08x\n", i4);
 658
 659     i4 = 0x12345678;
 660     *(FLOAT *)src = 10.75;
 661     hr = IDataConvert_DataConvert(convert, DBTYPE_R4, 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 == 11, "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     *(double *)src = 10.75;
 677     hr = IDataConvert_DataConvert(convert, DBTYPE_R8, 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     ((LARGE_INTEGER *)src)->QuadPart = 107500;
 685     hr = IDataConvert_DataConvert(convert, DBTYPE_CY, 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     *(DATE *)src = 10.7500;
 693     hr = IDataConvert_DataConvert(convert, DBTYPE_DATE, 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     b = SysAllocString(ten);
 701     *(BSTR *)src = b;
 702     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 703     ok(hr == S_OK, "got %08x\n", hr);
 704     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 705     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 706     ok(i4 == 10, "got %08x\n", i4);
 707     SysFreeString(b);
 708
 709     i4 = 0x12345678;
 710     *(SCODE *)src = 0x4321cafe;
 711     hr = IDataConvert_DataConvert(convert, DBTYPE_ERROR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 712     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 713     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 714     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 715     ok(i4 == 0x12345678, "got %08x\n", i4);
 716
 717     i4 = 0x12345678;
 718     *(VARIANT_BOOL *)src = VARIANT_TRUE;
 719     hr = IDataConvert_DataConvert(convert, DBTYPE_BOOL, 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 %d\n", dst_len);
 723     ok(i4 == 0xffffffff, "got %08x\n", i4);
 724
 725     i4 = 0x12345678;
 726     *(VARIANT_BOOL *)src = VARIANT_FALSE;
 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 == 0, "got %08x\n", i4);
 732
 733     i4 = 0x12345678;
 734     V_VT((VARIANT*)src) = VT_I2;
 735     V_I2((VARIANT*)src) = 0x1234;
 736     hr = IDataConvert_DataConvert(convert, DBTYPE_VARIANT, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 737 todo_wine
 738 {
 739     ok(hr == S_OK, "got %08x\n", hr);
 740     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 741 }
 742     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 743 todo_wine
 744     ok(i4 == 0x1234, "got %08x\n", i4);
 745
 746     i4 = 0x12345678;
 747     memset(src, 0, sizeof(DECIMAL));
 748     ((DECIMAL*)src)->u1.Lo64 = 0x1234;
 749     hr = IDataConvert_DataConvert(convert, DBTYPE_DECIMAL, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 750     ok(hr == S_OK, "got %08x\n", hr);
 751     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 752     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 753     ok(i4 == 0x1234, "got %08x\n", i4);
 754
 755     i4 = 0x12345678;
 756     *(signed char*)src = 0xab;
 757     hr = IDataConvert_DataConvert(convert, DBTYPE_I1, 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 == 0xffffffab, "got %08x\n", i4);
 762
 763     i4 = 0x12345678;
 764     *(BYTE*)src = 0xab;
 765     hr = IDataConvert_DataConvert(convert, DBTYPE_UI1, 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 == 0xab, "got %08x\n", i4);
 770
 771     i4 = 0x12345678;
 772     *(WORD*)src = 0xabcd;
 773     hr = IDataConvert_DataConvert(convert, DBTYPE_UI2, 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 == 0xabcd, "got %08x\n", i4);
 778
 779     i4 = 0x12345678;
 780     *(DWORD*)src = 0xabcd1234;
 781     hr = IDataConvert_DataConvert(convert, DBTYPE_UI4, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 782     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 783     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 784     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 785     ok(i4 == 0x12345678, "got %08x\n", i4);
 786
 787     i4 = 0x12345678;
 788     *(DWORD*)src = 0x1234abcd;
 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 == S_OK, "got %08x\n", hr);
 791     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 792     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 793     ok(i4 == 0x1234abcd, "got %08x\n", i4);
 794
 795     i4 = 0x12345678;
 796     ((LARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
 797     hr = IDataConvert_DataConvert(convert, DBTYPE_I8, 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     ((ULARGE_INTEGER*)src)->QuadPart = 0x1234abcd;
 805     hr = IDataConvert_DataConvert(convert, DBTYPE_UI8, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 806     ok(hr == S_OK, "got %08x\n", hr);
 807     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 808     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 809     ok(i4 == 0x1234abcd, "got %08x\n", i4);
 810
 811     i4 = 0x12345678;
 812     strcpy((char *)src, "10");
 813     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 2, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 814     ok(hr == S_OK, "got %08x\n", hr);
 815     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 816     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 817     ok(i4 == 10, "got %08x\n", i4);
 818
 819     i4 = 0x12345678;
 820     strcpy((char *)src, "10");
 821     hr = IDataConvert_DataConvert(convert, DBTYPE_STR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 822     ok(hr == S_OK, "got %08x\n", hr);
 823     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 824     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 825     ok(i4 == 10, "got %08x\n", i4);
 826
 827     i4 = 0x12345678;
 828     memcpy(src, ten, sizeof(ten));
 829     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 4, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, 0);
 830     ok(hr == S_OK, "got %08x\n", hr);
 831     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 832     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 833     ok(i4 == 10, "got %08x\n", i4);
 834
 835     i4 = 0x12345678;
 836     memcpy(src, ten, sizeof(ten));
 837     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_I4, 0, &dst_len, src, &i4, sizeof(i4), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
 838     ok(hr == S_OK, "got %08x\n", hr);
 839     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 840     ok(dst_len == sizeof(i4), "got %d\n", dst_len);
 841     ok(i4 == 10, "got %08x\n", i4);
 842
 843     IDataConvert_Release(convert);
 844 }
 845
 846 static void test_converttobstr(void)
 847 {
 848     IDataConvert *convert;
 849     HRESULT hr;
 850     BSTR dst;
 851     BYTE src[20];
 852     DBSTATUS dst_status;
 853     DBLENGTH dst_len;
 854     static const WCHAR ten[] = {'1','0',0};
 855     BSTR b;
 856
 857     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 858     if(FAILED(hr))
 859     {
 860         win_skip("Unable to load oledb conversion library\n");
 861         return;
 862     }
 863
 864     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 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(dst), "got %d\n", dst_len);
 868     ok(dst != NULL, "got %p\n", dst);
 869     ok(SysStringLen(dst) == 0, "got %d\n", SysStringLen(dst));
 870     SysFreeString(dst);
 871
 872     dst = (void*)0x1234;
 873     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 874     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 875     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 876     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 877     ok(dst == (void*)0x1234, "got %p\n", dst);
 878
 879     *(short *)src = 4321;
 880     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 881     ok(hr == S_OK, "got %08x\n", hr);
 882     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 883     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 884     ok(dst != NULL, "got %p\n", dst);
 885     ok(SysStringLen(dst) == 4, "got %d\n", SysStringLen(dst));
 886     SysFreeString(dst);
 887
 888     b = SysAllocString(ten);
 889     *(BSTR *)src = b;
 890     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 891     ok(hr == S_OK, "got %08x\n", hr);
 892     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 893     ok(dst_len == sizeof(dst), "got %d\n", dst_len);
 894     ok(dst != NULL, "got %p\n", dst);
 895     ok(dst != b, "got %p src %p\n", dst, b);
 896     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
 897     SysFreeString(dst);
 898     SysFreeString(b);
 899
 900     IDataConvert_Release(convert);
 901 }
 902
 903 static void test_converttowstr(void)
 904 {
 905     IDataConvert *convert;
 906     HRESULT hr;
 907     WCHAR dst[100];
 908     BYTE src[20];
 909     DBSTATUS dst_status;
 910     DBLENGTH dst_len;
 911     static const WCHAR ten[] = {'1','0',0};
 912     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
 913     BSTR b;
 914
 915     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
 916     if(FAILED(hr))
 917     {
 918         win_skip("Unable to load oledb conversion library\n");
 919         return;
 920     }
 921
 922
 923     memset(dst, 0xcc, sizeof(dst));
 924     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 925     ok(hr == S_OK, "got %08x\n", hr);
 926     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 927     ok(dst_len == 0, "got %d\n", dst_len);
 928     ok(dst[0] == 0, "got %02x\n", dst[0]);
 929     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
 930
 931     memset(dst, 0xcc, sizeof(dst));
 932     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 933     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
 934     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
 935     ok(dst_len == 0, "got %d\n", dst_len);
 936     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
 937
 938     *(short *)src = 4321;
 939     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 940     ok(hr == S_OK, "got %08x\n", hr);
 941     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 942     ok(dst_len == 8, "got %d\n", dst_len);
 943     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
 944
 945     *(short *)src = 4321;
 946     memset(dst, 0xcc, sizeof(dst));
 947     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 0, 0, &dst_status, 0, 0, 0);
 948     ok(hr == DB_E_ERRORSOCCURRED, "got %08x\n", hr);
 949     ok(dst_status == DBSTATUS_E_DATAOVERFLOW, "got %08x\n", dst_status);
 950     ok(dst_len == 8, "got %d\n", dst_len);
 951     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
 952
 953     *(short *)src = 4321;
 954     memset(dst, 0xcc, sizeof(dst));
 955     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, NULL, 0, 0, &dst_status, 0, 0, 0);
 956     ok(hr == S_OK, "got %08x\n", hr);
 957     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 958     ok(dst_len == 8, "got %d\n", dst_len);
 959     ok(dst[0] == 0xcccc, "got %02x\n", dst[0]);
 960
 961     *(short *)src = 4321;
 962     memset(dst, 0xcc, sizeof(dst));
 963     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 4, 0, &dst_status, 0, 0, 0);
 964     ok(hr == S_OK, "got %08x\n", hr);
 965     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
 966     ok(dst_len == 8, "got %d\n", dst_len);
 967     ok(dst[0] == '4', "got %02x\n", dst[0]);
 968     ok(dst[1] == 0, "got %02x\n", dst[1]);
 969     ok(dst[2] == 0xcccc, "got %02x\n", dst[2]);
 970
 971     *(short *)src = 4321;
 972     memset(dst, 0xcc, sizeof(dst));
 973     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 2, 0, &dst_status, 0, 0, 0);
 974     ok(hr == S_OK, "got %08x\n", hr);
 975     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
 976     ok(dst_len == 8, "got %d\n", dst_len);
 977     ok(dst[0] == 0, "got %02x\n", dst[0]);
 978     ok(dst[1] == 0xcccc, "got %02x\n", dst[1]);
 979
 980     *(short *)src = 4321;
 981     memset(dst, 0xcc, sizeof(dst));
 982     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_WSTR, 0, &dst_len, src, dst, 8, 0, &dst_status, 0, 0, 0);
 983     ok(hr == S_OK, "got %08x\n", hr);
 984     ok(dst_status == DBSTATUS_S_TRUNCATED, "got %08x\n", dst_status);
 985     ok(dst_len == 8, "got %d\n", dst_len);
 986     ok(dst[0] == '4', "got %02x\n", dst[0]);
 987     ok(dst[1] == '3', "got %02x\n", dst[1]);
 988     ok(dst[2] == '2', "got %02x\n", dst[2]);
 989     ok(dst[3] == 0, "got %02x\n", dst[3]);
 990     ok(dst[4] == 0xcccc, "got %02x\n", dst[4]);
 991
 992     b = SysAllocString(ten);
 993     *(BSTR *)src = b;
 994     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
 995     ok(hr == S_OK, "got %08x\n", hr);
 996     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
 997     ok(dst_len == 4, "got %d\n", dst_len);
 998     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
 999     SysFreeString(b);
1000
1001     memcpy(src, ten, sizeof(ten));
1002     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 2, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1003     ok(hr == S_OK, "got %08x\n", hr);
1004     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1005     ok(dst_len == 2, "got %d\n", dst_len);
1006     ok(dst[0] == '1', "got %02x\n", dst[0]);
1007     ok(dst[1] == 0, "got %02x\n", dst[1]);
1008
1009     memcpy(src, ten, sizeof(ten));
1010     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 4, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1011     ok(hr == S_OK, "got %08x\n", hr);
1012     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1013     ok(dst_len == 4, "got %d\n", dst_len);
1014     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1015
1016     memcpy(src, ten, sizeof(ten));
1017     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_WSTR, 0, &dst_len, src, dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
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 == 4, "got %d\n", dst_len);
1021     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1022
1023     IDataConvert_Release(convert);
1024 }
1025
1026 static void test_converttobyrefwstr(void)
1027 {
1028     IDataConvert *convert;
1029     HRESULT hr;
1030     WCHAR *dst;
1031     BYTE src[20];
1032     DBSTATUS dst_status;
1033     DBLENGTH dst_len;
1034     static const WCHAR ten[] = {'1','0',0};
1035     static const WCHAR fourthreetwoone[] = {'4','3','2','1',0};
1036     BSTR b;
1037
1038     hr = CoCreateInstance(&CLSID_OLEDB_CONVERSIONLIBRARY, NULL, CLSCTX_INPROC_SERVER, &IID_IDataConvert, (void**)&convert);
1039     if(FAILED(hr))
1040     {
1041         win_skip("Unable to load oledb conversion library\n");
1042         return;
1043     }
1044
1045     hr = IDataConvert_DataConvert(convert, DBTYPE_EMPTY, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1046     ok(hr == S_OK, "got %08x\n", hr);
1047     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1048     ok(dst_len == 0, "got %d\n", dst_len);
1049     ok(dst[0] == 0, "got %04x\n", dst[0]);
1050     CoTaskMemFree(dst);
1051
1052     dst = (void*)0x12345678;
1053     hr = IDataConvert_DataConvert(convert, DBTYPE_NULL, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1054     ok(hr == DB_E_UNSUPPORTEDCONVERSION, "got %08x\n", hr);
1055     ok(dst_status == DBSTATUS_E_BADACCESSOR, "got %08x\n", dst_status);
1056     ok(dst_len == 0, "got %d\n", dst_len);
1057     ok(dst == (void*)0x12345678, "got %p\n", dst);
1058
1059     *(short *)src = 4321;
1060     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1061     ok(hr == S_OK, "got %08x\n", hr);
1062     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1063     ok(dst_len == 8, "got %d\n", dst_len);
1064     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1065     CoTaskMemFree(dst);
1066
1067     *(short *)src = 4321;
1068     hr = IDataConvert_DataConvert(convert, DBTYPE_I2, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, 0, 0, &dst_status, 0, 0, 0);
1069     ok(hr == S_OK, "got %08x\n", hr);
1070     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1071     ok(dst_len == 8, "got %d\n", dst_len);
1072     ok(!lstrcmpW(dst, fourthreetwoone), "got %s\n", wine_dbgstr_w(dst));
1073     CoTaskMemFree(dst);
1074
1075     b = SysAllocString(ten);
1076     *(BSTR *)src = b;
1077     hr = IDataConvert_DataConvert(convert, DBTYPE_BSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1078     ok(hr == S_OK, "got %08x\n", hr);
1079     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1080     ok(dst_len == 4, "got %d\n", dst_len);
1081     ok(!lstrcmpW(b, dst), "got %s\n", wine_dbgstr_w(dst));
1082     CoTaskMemFree(dst);
1083     SysFreeString(b);
1084
1085     memcpy(src, ten, sizeof(ten));
1086     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 2, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1087     ok(hr == S_OK, "got %08x\n", hr);
1088     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1089     ok(dst_len == 2, "got %d\n", dst_len);
1090     ok(dst[0] == '1', "got %02x\n", dst[0]);
1091     ok(dst[1] == 0, "got %02x\n", dst[1]);
1092     CoTaskMemFree(dst);
1093
1094     memcpy(src, ten, sizeof(ten));
1095     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 4, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, 0);
1096     ok(hr == S_OK, "got %08x\n", hr);
1097     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1098     ok(dst_len == 4, "got %d\n", dst_len);
1099     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1100     CoTaskMemFree(dst);
1101
1102     memcpy(src, ten, sizeof(ten));
1103     hr = IDataConvert_DataConvert(convert, DBTYPE_WSTR, DBTYPE_BYREF | DBTYPE_WSTR, 0, &dst_len, src, &dst, sizeof(dst), 0, &dst_status, 0, 0, DBDATACONVERT_LENGTHFROMNTS);
1104     ok(hr == S_OK, "got %08x\n", hr);
1105     ok(dst_status == DBSTATUS_S_OK, "got %08x\n", dst_status);
1106     ok(dst_len == 4, "got %d\n", dst_len);
1107     ok(!lstrcmpW(ten, dst), "got %s\n", wine_dbgstr_w(dst));
1108     CoTaskMemFree(dst);
1109
1110     IDataConvert_Release(convert);
1111 }
1112
1113
1114 START_TEST(convert)
1115 {
1116     OleInitialize(NULL);
1117     test_dcinfo();
1118     test_canconvert();
1119     test_converttoi2();
1120     test_converttoi4();
1121     test_converttobstr();
1122     test_converttowstr();
1123     test_converttobyrefwstr();
1124     OleUninitialize();
1125 }