git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/safearray.c

   1 /*
   2  * SafeArray test program
   3  *
   4  * Copyright 2002 Marcus Meissner
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #define COBJMACROS
  28 #include "wine/test.h"
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "wingdi.h"
  33 #include "winnls.h"
  34 #include "winsock.h"
  35 #include "winerror.h"
  36 #include "winnt.h"
  37
  38 #include "wtypes.h"
  39 #include "oleauto.h"
  40
  41 static HMODULE hOleaut32;
  42
  43 static HRESULT (WINAPI *pSafeArrayAllocDescriptorEx)(VARTYPE,UINT,SAFEARRAY**);
  44 static HRESULT (WINAPI *pSafeArrayCopyData)(SAFEARRAY*,SAFEARRAY*);
  45 static HRESULT (WINAPI *pSafeArrayGetIID)(SAFEARRAY*,GUID*);
  46 static HRESULT (WINAPI *pSafeArraySetIID)(SAFEARRAY*,REFGUID);
  47 static HRESULT (WINAPI *pSafeArrayGetVartype)(SAFEARRAY*,VARTYPE*);
  48 static HRESULT (WINAPI *pSafeArrayGetRecordInfo)(SAFEARRAY*,IRecordInfo**);
  49 static SAFEARRAY* (WINAPI *pSafeArrayCreateEx)(VARTYPE,UINT,SAFEARRAYBOUND*,LPVOID);
  50 static SAFEARRAY* (WINAPI *pSafeArrayCreateVector)(VARTYPE,LONG,ULONG);
  51
  52 #define GETPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func)
  53
  54 /* Is a given function exported from oleaut32? */
  55 #define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
  56
  57 /* Have IRecordInfo data type? */
  58 #define HAVE_OLEAUT32_RECORD  HAVE_FUNC(SafeArraySetRecordInfo)
  59 /* Have R8 data type? */
  60 #define HAVE_OLEAUT32_R8      HAVE_FUNC(VarR8FromI1)
  61 /* Have I8/UI8 data type? */
  62 #define HAVE_OLEAUT32_I8      HAVE_FUNC(VarI8FromI1)
  63 /* Have the decimal type? */
  64 #define HAVE_OLEAUT32_DECIMAL HAVE_FUNC(VarDecAdd)
  65 /* Have INT_PTR/UINT_PTR type? */
  66 static BOOL HAVE_OLEAUT32_INT_PTR;
  67
  68 /* very old version? */
  69 #define IS_ANCIENT (!HAVE_FUNC(VarI1FromI2))
  70
  71 #define START_REF_COUNT 1
  72 #define RECORD_SIZE 64
  73 #define RECORD_SIZE_FAIL 17
  74 /************************************************************************
  75  * Dummy IRecordInfo Implementation
  76  */
  77 typedef struct IRecordInfoImpl
  78 {
  79   const IRecordInfoVtbl *lpvtbl;
  80   LONG ref;
  81   DWORD sizeCalled;
  82   DWORD clearCalled;
  83 } IRecordInfoImpl;
  84
  85 static const IRecordInfoVtbl IRecordInfoImpl_VTable;
  86
  87 static IRecordInfoImpl *IRecordInfoImpl_Construct(void)
  88 {
  89   IRecordInfoImpl *rec;
  90
  91   rec = HeapAlloc(GetProcessHeap(), 0, sizeof(IRecordInfoImpl));
  92   rec->lpvtbl = &IRecordInfoImpl_VTable;
  93   rec->ref = START_REF_COUNT;
  94   rec->clearCalled = 0;
  95   rec->sizeCalled = 0;
  96   return rec;
  97 }
  98
  99 static ULONG CALLBACK IRecordInfoImpl_AddRef(IRecordInfo *iface)
 100 {
 101   IRecordInfoImpl* This=(IRecordInfoImpl*)iface;
 102   return InterlockedIncrement(&This->ref);
 103 }
 104
 105 static ULONG CALLBACK IRecordInfoImpl_Release(IRecordInfo *iface)
 106 {
 107   IRecordInfoImpl* This=(IRecordInfoImpl*)iface;
 108   return InterlockedDecrement(&This->ref);
 109 }
 110
 111 static BOOL fail_GetSize; /* Whether to fail the GetSize call */
 112
 113 static HRESULT CALLBACK IRecordInfoImpl_RecordClear(IRecordInfo *iface, PVOID pvExisting)
 114 {
 115   IRecordInfoImpl* This=(IRecordInfoImpl*)iface;
 116   This->clearCalled++;
 117   return S_OK;
 118 }
 119
 120 static HRESULT CALLBACK IRecordInfoImpl_GetSize(IRecordInfo *iface, ULONG* size)
 121 {
 122   IRecordInfoImpl* This=(IRecordInfoImpl*)iface;
 123   This->sizeCalled++;
 124   *size = 17;
 125   if (fail_GetSize)
 126     return E_UNEXPECTED;
 127   *size = RECORD_SIZE;
 128   return S_OK;
 129 }
 130
 131 static HRESULT CALLBACK IRecordInfoImpl_Dummy(IRecordInfo *iface)
 132 {
 133   trace("Called an unexpected IRecordInfo method - please report!\n");
 134   /* Quit because we'll just crash anyway */
 135   fflush(NULL);
 136   exit(255);
 137 }
 138
 139 static const IRecordInfoVtbl IRecordInfoImpl_VTable =
 140 {
 141   (PVOID)IRecordInfoImpl_Dummy,
 142   IRecordInfoImpl_AddRef,
 143   IRecordInfoImpl_Release,
 144   (PVOID)IRecordInfoImpl_Dummy,
 145   IRecordInfoImpl_RecordClear,
 146   (PVOID)IRecordInfoImpl_Dummy,
 147   (PVOID)IRecordInfoImpl_Dummy,
 148   (PVOID)IRecordInfoImpl_Dummy,
 149   IRecordInfoImpl_GetSize,
 150   (PVOID)IRecordInfoImpl_Dummy,
 151   (PVOID)IRecordInfoImpl_Dummy,
 152   (PVOID)IRecordInfoImpl_Dummy,
 153   (PVOID)IRecordInfoImpl_Dummy,
 154   (PVOID)IRecordInfoImpl_Dummy,
 155   (PVOID)IRecordInfoImpl_Dummy,
 156   (PVOID)IRecordInfoImpl_Dummy,
 157   (PVOID)IRecordInfoImpl_Dummy,
 158   (PVOID)IRecordInfoImpl_Dummy,
 159   (PVOID)IRecordInfoImpl_Dummy
 160 };
 161
 162 static DWORD SAFEARRAY_GetVTSize(VARTYPE vt)
 163 {
 164   switch (vt)
 165   {
 166     case VT_I1:
 167     case VT_UI1:      return sizeof(BYTE);
 168     case VT_BOOL:
 169     case VT_I2:
 170     case VT_UI2:      return sizeof(SHORT);
 171     case VT_I4:
 172     case VT_UI4:
 173     case VT_R4:
 174     case VT_ERROR:    return sizeof(LONG);
 175     case VT_R8:
 176       if (HAVE_OLEAUT32_R8)
 177         return sizeof(LONG64);
 178     case VT_I8:
 179     case VT_UI8:
 180       if (HAVE_OLEAUT32_I8)
 181         return sizeof(LONG64);
 182       break;
 183     case VT_INT:
 184     case VT_UINT:     return sizeof(INT);
 185     case VT_INT_PTR:
 186     case VT_UINT_PTR:
 187       if (HAVE_OLEAUT32_INT_PTR)
 188         return sizeof(UINT_PTR);
 189       break;
 190     case VT_CY:       return sizeof(CY);
 191     case VT_DATE:     return sizeof(DATE);
 192     case VT_BSTR:     return sizeof(BSTR);
 193     case VT_DISPATCH: return sizeof(LPDISPATCH);
 194     case VT_VARIANT:  return sizeof(VARIANT);
 195     case VT_UNKNOWN:  return sizeof(LPUNKNOWN);
 196     case VT_DECIMAL:
 197       if (HAVE_OLEAUT32_DECIMAL)
 198         return sizeof(DECIMAL);
 199       break;
 200   }
 201   return 0;
 202 }
 203
 204 static void check_for_VT_INT_PTR(void)
 205 {
 206     /* Set a global flag if VT_INT_PTR is supported */
 207
 208     SAFEARRAY* a;
 209     SAFEARRAYBOUND bound;
 210     bound.cElements     = 0;
 211     bound.lLbound       = 0;
 212     a = SafeArrayCreate(VT_INT_PTR, 1, &bound);
 213     if (a) {
 214         trace("VT_INT_PTR is supported\n");
 215         HAVE_OLEAUT32_INT_PTR = TRUE;
 216         SafeArrayDestroy(a);
 217     }
 218     else {
 219         trace("VT_INT_PTR is not supported\n");
 220         HAVE_OLEAUT32_INT_PTR = FALSE;
 221     }
 222 }
 223
 224 #define VARTYPE_NOT_SUPPORTED 0
 225 static struct {
 226         VARTYPE vt;    /* VT */
 227         UINT elemsize; /* elementsize by VT */
 228         UINT expflags; /* fFeatures from SafeArrayAllocDescriptorEx */
 229         UINT addflags; /* additional fFeatures from SafeArrayCreate */
 230 } vttypes[] = {
 231 {VT_EMPTY,    VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 232 {VT_NULL,     VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 233 {VT_I2,       2,                    FADF_HAVEVARTYPE,0},
 234 {VT_I4,       4,                    FADF_HAVEVARTYPE,0},
 235 {VT_R4,       4,                    FADF_HAVEVARTYPE,0},
 236 {VT_R8,       8,                    FADF_HAVEVARTYPE,0},
 237 {VT_CY,       8,                    FADF_HAVEVARTYPE,0},
 238 {VT_DATE,     8,                    FADF_HAVEVARTYPE,0},
 239 {VT_BSTR,     sizeof(BSTR),         FADF_HAVEVARTYPE,FADF_BSTR},
 240 {VT_DISPATCH, sizeof(LPDISPATCH),   FADF_HAVEIID,    FADF_DISPATCH},
 241 {VT_ERROR,    4,                    FADF_HAVEVARTYPE,0},
 242 {VT_BOOL,     2,                    FADF_HAVEVARTYPE,0},
 243 {VT_VARIANT,  sizeof(VARIANT),      FADF_HAVEVARTYPE,FADF_VARIANT},
 244 {VT_UNKNOWN,  sizeof(LPUNKNOWN),    FADF_HAVEIID,    FADF_UNKNOWN},
 245 {VT_DECIMAL,  sizeof(DECIMAL),      FADF_HAVEVARTYPE,0},
 246 {15,          VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0}, /* no VT_xxx */
 247 {VT_I1,       1,                    FADF_HAVEVARTYPE,0},
 248 {VT_UI1,      1,                    FADF_HAVEVARTYPE,0},
 249 {VT_UI2,      2,                    FADF_HAVEVARTYPE,0},
 250 {VT_UI4,      4,                    FADF_HAVEVARTYPE,0},
 251 {VT_I8,       VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 252 {VT_UI8,      VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 253 {VT_INT,      sizeof(INT),          FADF_HAVEVARTYPE,0},
 254 {VT_UINT,     sizeof(UINT),         FADF_HAVEVARTYPE,0},
 255 {VT_VOID,     VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 256 {VT_HRESULT,  VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 257 {VT_PTR,      VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 258 {VT_SAFEARRAY,VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 259 {VT_CARRAY,   VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 260 {VT_USERDEFINED,VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 261 {VT_LPSTR,    VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 262 {VT_LPWSTR,   VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 263 {VT_FILETIME, VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 264 {VT_RECORD,   VARTYPE_NOT_SUPPORTED,FADF_RECORD,0},
 265 {VT_BLOB,     VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 266 {VT_STREAM,   VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 267 {VT_STORAGE,  VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 268 {VT_STREAMED_OBJECT,VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 269 {VT_STORED_OBJECT,VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 270 {VT_BLOB_OBJECT,VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 271 {VT_CF,       VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 272 {VT_CLSID,    VARTYPE_NOT_SUPPORTED,FADF_HAVEVARTYPE,0},
 273 };
 274
 275 static void test_safearray(void)
 276 {
 277         SAFEARRAY       *a, b, *c;
 278         unsigned int    i, diff;
 279         LONG            indices[2];
 280         HRESULT         hres;
 281         SAFEARRAYBOUND  bound, bounds[2];
 282         VARIANT         v;
 283         LPVOID          data;
 284         IID             iid;
 285         VARTYPE         vt;
 286         LONG            l;
 287         unsigned char   *ptr1, *ptr2;
 288
 289         hres = SafeArrayDestroy( NULL);
 290         ok( hres == S_OK, "SafeArrayDestroy( NULL) returned 0x%x\n", hres);
 291
 292         bound.cElements = 1;
 293         bound.lLbound   = 0;
 294         a = SafeArrayCreate(-1, 1, &bound);
 295         ok(NULL == a,"SAC(-1,1,[1,0]) not failed?\n");
 296
 297         bound.cElements = 0;
 298         bound.lLbound   = 42;
 299         a = SafeArrayCreate(VT_I4, 1, &bound);
 300         ok(NULL != a,"SAC(VT_I4,1,[0,0]) failed.\n");
 301
 302         hres = SafeArrayGetLBound(a, 1, &l);
 303         ok(hres == S_OK, "SAGLB of 0 size dimensioned array failed with %x\n",hres);
 304         ok(l == 42, "SAGLB of 0 size dimensioned array failed to return 42, but returned %d\n",l);
 305         hres = SafeArrayGetUBound(a, 1, &l);
 306         ok(hres == S_OK, "SAGUB of 0 size dimensioned array failed with %x\n",hres);
 307         ok(l == 41, "SAGUB of 0 size dimensioned array failed to return 41, but returned %d\n",l);
 308
 309         hres = SafeArrayAccessData(a, &data);
 310         ok(hres == S_OK, "SafeArrayAccessData of 0 size dimensioned array failed with %x\n", hres);
 311         SafeArrayUnaccessData(a);
 312
 313         bound.cElements = 2;
 314         hres = SafeArrayRedim(a, &bound);
 315         ok(hres == S_OK,"SAR of a 0 elements dimension failed with hres %x\n", hres);
 316         bound.cElements = 0;
 317         hres = SafeArrayRedim(a, &bound);
 318         ok(hres == S_OK || hres == E_OUTOFMEMORY,
 319           "SAR to a 0 elements dimension failed with hres %x\n", hres);
 320         hres = SafeArrayDestroy(a);
 321         ok(hres == S_OK,"SAD of 0 dim array faild with hres %x\n", hres);
 322
 323         SafeArrayAllocDescriptor(2, &a);
 324         a->rgsabound[0].cElements = 2;
 325         a->rgsabound[0].lLbound = 1;
 326         a->rgsabound[1].cElements = 4;
 327         a->rgsabound[1].lLbound = 1;
 328         a->cbElements = 2;
 329         SafeArrayAllocData(a);
 330
 331         indices[0] = 4;
 332         indices[1] = 2;
 333         hres = SafeArrayPtrOfIndex(a, indices, (void **)&ptr1);
 334         ok(hres == S_OK, "SAPOI failed with hres %x\n", hres);
 335         SafeArrayAccessData(a, (void **)&ptr2);
 336         ok(ptr1 - ptr2 == 14, "SAPOI got wrong ptr\n");
 337         *(WORD *)ptr1 = 0x55aa;
 338         SafeArrayUnaccessData(a);
 339
 340         bound.cElements = 10;
 341         bound.lLbound = 1;
 342         SafeArrayRedim(a, &bound);
 343         ptr1 = NULL;
 344         SafeArrayPtrOfIndex(a, indices, (void **)&ptr1);
 345         ok(*(WORD *)ptr1 == 0x55aa, "Data not preserved when resizing array\n");
 346
 347         bound.cElements = 10;
 348         bound.lLbound = 0;
 349         SafeArrayRedim(a, &bound);
 350         SafeArrayPtrOfIndex(a, indices, (void **)&ptr1);
 351         ok(*(WORD *)ptr1 == 0, "Expanded area not zero-initialized\n");
 352
 353         indices[1] = 1;
 354         SafeArrayPtrOfIndex(a, indices, (void **)&ptr1);
 355         ok(*(WORD *)ptr1 == 0x55aa, "Data not preserved when resizing array\n");
 356
 357         hres = SafeArrayDestroy(a);
 358         ok(hres == S_OK,"SAD faild with hres %x\n", hres);
 359
 360         bounds[0].cElements = 0;        bounds[0].lLbound =  1;
 361         bounds[1].cElements =  2;       bounds[1].lLbound = 23;
 362         a = SafeArrayCreate(VT_I4,2,bounds);
 363         ok(a != NULL,"SAC(VT_INT32,2,...) with 0 element dim failed.\n");
 364
 365         hres = SafeArrayDestroy(a);
 366         ok(hres == S_OK,"SAD faild with hres %x\n", hres);
 367         bounds[0].cElements = 1;        bounds[0].lLbound =  1;
 368         bounds[1].cElements = 0;        bounds[1].lLbound = 23;
 369         a = SafeArrayCreate(VT_I4,2,bounds);
 370         ok(a != NULL,"SAC(VT_INT32,2,...) with 0 element dim failed.\n");
 371
 372         hres = SafeArrayDestroy(a);
 373         ok(hres == S_OK,"SAD faild with hres %x\n", hres);
 374
 375         bounds[0].cElements = 42;       bounds[0].lLbound =  1;
 376         bounds[1].cElements =  2;       bounds[1].lLbound = 23;
 377     a = SafeArrayCreate(VT_I4,2,bounds);
 378     ok(a != NULL,"SAC(VT_INT32,2,...) failed.\n");
 379
 380         hres = SafeArrayGetLBound (a, 0, &l);
 381         ok (hres == DISP_E_BADINDEX, "SAGLB 0 failed with %x\n", hres);
 382         hres = SafeArrayGetLBound (a, 1, &l);
 383         ok (hres == S_OK, "SAGLB 1 failed with %x\n", hres);
 384         ok (l == 1, "SAGLB 1 returned %d instead of 1\n", l);
 385         hres = SafeArrayGetLBound (a, 2, &l);
 386         ok (hres == S_OK, "SAGLB 2 failed with %x\n", hres);
 387         ok (l == 23, "SAGLB 2 returned %d instead of 23\n", l);
 388         hres = SafeArrayGetLBound (a, 3, &l);
 389         ok (hres == DISP_E_BADINDEX, "SAGLB 3 failed with %x\n", hres);
 390
 391         hres = SafeArrayGetUBound (a, 0, &l);
 392         ok (hres == DISP_E_BADINDEX, "SAGUB 0 failed with %x\n", hres);
 393         hres = SafeArrayGetUBound (a, 1, &l);
 394         ok (hres == S_OK, "SAGUB 1 failed with %x\n", hres);
 395         ok (l == 42, "SAGUB 1 returned %d instead of 42\n", l);
 396         hres = SafeArrayGetUBound (a, 2, &l);
 397         ok (hres == S_OK, "SAGUB 2 failed with %x\n", hres);
 398         ok (l == 24, "SAGUB 2 returned %d instead of 24\n", l);
 399         hres = SafeArrayGetUBound (a, 3, &l);
 400         ok (hres == DISP_E_BADINDEX, "SAGUB 3 failed with %x\n", hres);
 401
 402         i = SafeArrayGetDim(a);
 403         ok(i == 2, "getdims of 2 din array returned %d\n",i);
 404
 405         indices[0] = 0;
 406         indices[1] = 23;
 407         hres = SafeArrayGetElement(a, indices, &i);
 408         ok(DISP_E_BADINDEX == hres,"SAGE failed [0,23], hres 0x%x\n",hres);
 409
 410         indices[0] = 1;
 411         indices[1] = 22;
 412         hres = SafeArrayGetElement(a, indices, &i);
 413         ok(DISP_E_BADINDEX == hres,"SAGE failed [1,22], hres 0x%x\n",hres);
 414
 415         indices[0] = 1;
 416         indices[1] = 23;
 417         hres = SafeArrayGetElement(a, indices, &i);
 418         ok(S_OK == hres,"SAGE failed [1,23], hres 0x%x\n",hres);
 419
 420         indices[0] = 1;
 421         indices[1] = 25;
 422         hres = SafeArrayGetElement(a, indices, &i);
 423         ok(DISP_E_BADINDEX == hres,"SAGE failed [1,24], hres 0x%x\n",hres);
 424
 425         indices[0] = 3;
 426         indices[1] = 23;
 427         hres = SafeArrayGetElement(a, indices, &i);
 428         ok(S_OK == hres,"SAGE failed [42,23], hres 0x%x\n",hres);
 429
 430         hres = SafeArrayAccessData(a, (void**)&ptr1);
 431         ok(S_OK == hres, "SAAD failed with 0x%x\n", hres);
 432
 433         indices[0] = 3;
 434         indices[1] = 23;
 435         hres = SafeArrayPtrOfIndex(a, indices, (void**)&ptr2);
 436         ok(S_OK == hres,"SAPOI failed [1,23], hres 0x%x\n",hres);
 437         diff = ptr2 - ptr1;
 438         ok(diff == 8,"ptr difference is not 8, but %d (%p vs %p)\n", diff, ptr2, ptr1);
 439
 440         indices[0] = 3;
 441         indices[1] = 24;
 442         hres = SafeArrayPtrOfIndex(a, indices, (void**)&ptr2);
 443         ok(S_OK == hres,"SAPOI failed [5,24], hres 0x%x\n",hres);
 444         diff = ptr2 - ptr1;
 445         ok(diff == 176,"ptr difference is not 176, but %d (%p vs %p)\n", diff, ptr2, ptr1);
 446
 447         indices[0] = 20;
 448         indices[1] = 23;
 449         hres = SafeArrayPtrOfIndex(a, indices, (void**)&ptr2);
 450         ok(S_OK == hres,"SAPOI failed [20,23], hres 0x%x\n",hres);
 451         diff = ptr2 - ptr1;
 452         ok(diff == 76,"ptr difference is not 76, but %d (%p vs %p)\n", diff, ptr2, ptr1);
 453
 454         hres = SafeArrayUnaccessData(a);
 455         ok(S_OK == hres, "SAUAD failed with 0x%x\n", hres);
 456
 457         hres = SafeArrayDestroy(a);
 458         ok(hres == S_OK,"SAD faild with hres %x\n", hres);
 459
 460         for (i=0;i<sizeof(vttypes)/sizeof(vttypes[0]);i++) {
 461         if ((i == VT_I8 || i == VT_UI8) && HAVE_OLEAUT32_I8)
 462         {
 463           vttypes[i].elemsize = sizeof(LONG64);
 464         }
 465
 466         a = SafeArrayCreate(vttypes[i].vt, 1, &bound);
 467
 468         ok((!a && !vttypes[i].elemsize) ||
 469            (a && vttypes[i].elemsize == a->cbElements) ||
 470            (IS_ANCIENT && (vttypes[i].vt == VT_DECIMAL || vttypes[i].vt == VT_I1 ||
 471             vttypes[i].vt == VT_UI2 || vttypes[i].vt == VT_UI4 || vttypes[i].vt == VT_INT ||
 472             vttypes[i].vt == VT_UINT)),
 473            "SAC(%d,1,[1,0]), %p result %d, expected %d\n",
 474            vttypes[i].vt,a,(a?a->cbElements:0),vttypes[i].elemsize);
 475
 476         if (a)
 477         {
 478           if (!HAVE_OLEAUT32_RECORD)
 479             vttypes[i].expflags = 0;
 480           ok(a->fFeatures == (vttypes[i].expflags | vttypes[i].addflags),
 481              "SAC of %d returned feature flags %x, expected %x\n",
 482           vttypes[i].vt, a->fFeatures,
 483           vttypes[i].expflags|vttypes[i].addflags);
 484           ok(SafeArrayGetElemsize(a) == vttypes[i].elemsize,
 485              "SAGE for vt %d returned elemsize %d instead of expected %d\n",
 486              vttypes[i].vt, SafeArrayGetElemsize(a),vttypes[i].elemsize);
 487         }
 488
 489                 if (!a) continue;
 490
 491         if (pSafeArrayGetVartype)
 492         {
 493             hres = pSafeArrayGetVartype(a, &vt);
 494             ok(hres == S_OK, "SAGVT of arra y with vt %d failed with %x\n", vttypes[i].vt, hres);
 495             /* Windows prior to Vista returns VT_UNKNOWN instead of VT_DISPATCH */
 496             ok(broken(vt == VT_UNKNOWN) || vt == vttypes[i].vt, "SAGVT of array with vt %d returned %d\n", vttypes[i].vt, vt);
 497         }
 498
 499                 hres = SafeArrayCopy(a, &c);
 500                 ok(hres == S_OK, "failed to copy safearray of vt %d with hres %x\n", vttypes[i].vt, hres);
 501
 502                 ok(vttypes[i].elemsize == c->cbElements,"copy of SAC(%d,1,[1,0]), result %d, expected %d\n",vttypes[i].vt,(c?c->cbElements:0),vttypes[i].elemsize
 503                 );
 504                 ok(c->fFeatures == (vttypes[i].expflags | vttypes[i].addflags),"SAC of %d returned feature flags %x, expected %x\n", vttypes[i].vt, c->fFeatures, vttypes[i].expflags|vttypes[i].addflags);
 505                 ok(SafeArrayGetElemsize(c) == vttypes[i].elemsize,"SAGE for vt %d returned elemsize %d instead of expected %d\n",vttypes[i].vt, SafeArrayGetElemsize(c),vttypes[i].elemsize);
 506
 507         if (pSafeArrayGetVartype) {
 508             hres = pSafeArrayGetVartype(c, &vt);
 509             ok(hres == S_OK, "SAGVT of array with vt %d failed with %x\n", vttypes[i].vt, hres);
 510             /* Windows prior to Vista returns VT_UNKNOWN instead of VT_DISPATCH */
 511             ok(broken(vt == VT_UNKNOWN) || vt == vttypes[i].vt, "SAGVT of array with vt %d returned %d\n", vttypes[i].vt, vt);
 512         }
 513
 514         if (pSafeArrayCopyData) {
 515             hres = pSafeArrayCopyData(a, c);
 516             ok(hres == S_OK, "failed to copy safearray data of vt %d with hres %x\n", vttypes[i].vt, hres);
 517
 518             hres = SafeArrayDestroyData(c);
 519             ok(hres == S_OK,"SADD of copy of array with vt %d failed with hres %x\n", vttypes[i].vt, hres);
 520         }
 521
 522                 hres = SafeArrayDestroy(c);
 523                 ok(hres == S_OK,"SAD faild with hres %x\n", hres);
 524
 525                 hres = SafeArrayDestroy(a);
 526                 ok(hres == S_OK,"SAD of array with vt %d failed with hres %x\n", vttypes[i].vt, hres);
 527         }
 528
 529         /* Test conversion of type|VT_ARRAY <-> VT_BSTR */
 530         bound.lLbound = 0;
 531         bound.cElements = 10;
 532         a = SafeArrayCreate(VT_UI1, 1, &bound);
 533         ok(a != NULL, "SAC failed.\n");
 534         ok(S_OK == SafeArrayAccessData(a, &data),"SACD failed\n");
 535         memcpy(data,"Hello World\n",10);
 536         ok(S_OK == SafeArrayUnaccessData(a),"SAUD failed\n");
 537         V_VT(&v) = VT_ARRAY|VT_UI1;
 538         V_ARRAY(&v) = a;
 539         hres = VariantChangeTypeEx(&v, &v, 0, 0, VT_BSTR);
 540         ok(hres==S_OK, "CTE VT_ARRAY|VT_UI1 -> VT_BSTR failed with %x\n",hres);
 541         ok(V_VT(&v) == VT_BSTR,"CTE VT_ARRAY|VT_UI1 -> VT_BSTR did not return VT_BSTR, but %d.v\n",V_VT(&v));
 542         ok(V_BSTR(&v)[0] == 0x6548,"First letter are not 'He', but %x\n", V_BSTR(&v)[0]);
 543         VariantClear(&v);
 544
 545         /* check locking functions */
 546         a = SafeArrayCreate(VT_I4, 1, &bound);
 547         ok(a!=NULL,"SAC should not fail\n");
 548
 549         hres = SafeArrayAccessData(a, &data);
 550         ok(hres == S_OK,"SAAD failed with hres %x\n",hres);
 551
 552         hres = SafeArrayDestroy(a);
 553         ok(hres == DISP_E_ARRAYISLOCKED,"locked safe array destroy not failed with DISP_E_ARRAYISLOCKED, but with hres %x\n", hres);
 554
 555         hres = SafeArrayDestroyData(a);
 556         ok(hres == DISP_E_ARRAYISLOCKED,"locked safe array destroy data not failed with DISP_E_ARRAYISLOCKED, but with hres %x\n", hres);
 557
 558         hres = SafeArrayDestroyDescriptor(a);
 559         ok(hres == DISP_E_ARRAYISLOCKED,"locked safe array destroy descriptor not failed with DISP_E_ARRAYISLOCKED, but with hres %x\n", hres);
 560
 561         hres = SafeArrayUnaccessData(a);
 562         ok(hres == S_OK,"SAUD failed after lock/destroy test\n");
 563
 564         hres = SafeArrayDestroy(a);
 565         ok(hres == S_OK,"SAD failed after lock/destroy test\n");
 566
 567         /* Test if we need to destroy data before descriptor */
 568         a = SafeArrayCreate(VT_I4, 1, &bound);
 569         ok(a!=NULL,"SAC should not fail\n");
 570         hres = SafeArrayDestroyDescriptor(a);
 571         ok(hres == S_OK,"SADD with data in array failed with hres %x\n",hres);
 572
 573         /* IID functions */
 574         /* init a small stack safearray */
 575     if (pSafeArraySetIID) {
 576         memset(&b, 0, sizeof(b));
 577         b.cDims = 1;
 578         memset(&iid, 0x42, sizeof(IID));
 579         hres = pSafeArraySetIID(&b,&iid);
 580         ok(hres == E_INVALIDARG,"SafeArraySetIID of non IID capable safearray did not return E_INVALIDARG, but %x\n",hres);
 581
 582         hres = SafeArrayAllocDescriptor(1,&a);
 583         ok((a->fFeatures & FADF_HAVEIID) == 0,"newly allocated descriptor with SAAD should not have FADF_HAVEIID\n");
 584         hres = pSafeArraySetIID(a,&iid);
 585         ok(hres == E_INVALIDARG,"SafeArraySetIID of newly allocated descriptor with SAAD should return E_INVALIDARG, but %x\n",hres);
 586
 587         hres = SafeArrayDestroyDescriptor(a);
 588         ok(hres == S_OK,"SADD failed with hres %x\n",hres);
 589     }
 590
 591     if (!pSafeArrayAllocDescriptorEx)
 592         return;
 593
 594         for (i=0;i<sizeof(vttypes)/sizeof(vttypes[0]);i++) {
 595         a = NULL;
 596                 hres = pSafeArrayAllocDescriptorEx(vttypes[i].vt,1,&a);
 597                 ok(a->fFeatures == vttypes[i].expflags,"SAADE(%d) resulted with flags %x, expected %x\n", vttypes[i].vt, a->fFeatures, vttypes[i].expflags);
 598                 if (a->fFeatures & FADF_HAVEIID) {
 599                         hres = pSafeArrayGetIID(a, &iid);
 600                         ok(hres == S_OK,"SAGIID failed for vt %d with hres %x\n", vttypes[i].vt,hres);
 601                         switch (vttypes[i].vt) {
 602                         case VT_UNKNOWN:
 603                                 ok(IsEqualGUID(((GUID*)a)-1,&IID_IUnknown),"guid for VT_UNKNOWN is not IID_IUnknown\n");
 604                                 ok(IsEqualGUID(&iid, &IID_IUnknown),"SAGIID returned wrong GUID for IUnknown\n");
 605                                 break;
 606                         case VT_DISPATCH:
 607                                 ok(IsEqualGUID(((GUID*)a)-1,&IID_IDispatch),"guid for VT_UNKNOWN is not IID_IDispatch\n");
 608                                 ok(IsEqualGUID(&iid, &IID_IDispatch),"SAGIID returned wrong GUID for IDispatch\n");
 609                                 break;
 610                         default:
 611                                 ok(FALSE,"unknown vt %d with FADF_HAVEIID\n",vttypes[i].vt);
 612                                 break;
 613                         }
 614                 } else {
 615                         hres = pSafeArrayGetIID(a, &iid);
 616                         ok(hres == E_INVALIDARG,"SAGIID did not fail for vt %d with hres %x\n", vttypes[i].vt,hres);
 617                 }
 618                 if (a->fFeatures & FADF_RECORD) {
 619                         ok(vttypes[i].vt == VT_RECORD,"FADF_RECORD for non record %d\n",vttypes[i].vt);
 620                 }
 621                 if (a->fFeatures & FADF_HAVEVARTYPE) {
 622                         ok(vttypes[i].vt == ((DWORD*)a)[-1], "FADF_HAVEVARTYPE set, but vt %d mismatch stored %d\n",vttypes[i].vt,((DWORD*)a)[-1]);
 623                 }
 624
 625                 hres = pSafeArrayGetVartype(a, &vt);
 626                 ok(hres == S_OK, "SAGVT of array with vt %d failed with %x\n", vttypes[i].vt, hres);
 627
 628                 if (vttypes[i].vt == VT_DISPATCH) {
 629                         /* Special case. Checked against Windows. */
 630                         ok(vt == VT_UNKNOWN, "SAGVT of array with VT_DISPATCH returned not VT_UNKNOWN, but %d\n", vt);
 631                 } else {
 632                         ok(vt == vttypes[i].vt, "SAGVT of array with vt %d returned %d\n", vttypes[i].vt, vt);
 633                 }
 634
 635                 if (a->fFeatures & FADF_HAVEIID) {
 636                         hres = pSafeArraySetIID(a, &IID_IStorage); /* random IID */
 637                         ok(hres == S_OK,"SASIID failed with FADF_HAVEIID set for vt %d with %x\n", vttypes[i].vt, hres);
 638                         hres = pSafeArrayGetIID(a, &iid);
 639                         ok(hres == S_OK,"SAGIID failed with FADF_HAVEIID set for vt %d with %x\n", vttypes[i].vt, hres);
 640                         ok(IsEqualGUID(&iid, &IID_IStorage),"returned iid is not IID_IStorage\n");
 641                 } else {
 642                         hres = pSafeArraySetIID(a, &IID_IStorage); /* random IID */
 643                         ok(hres == E_INVALIDARG,"SASIID did not failed with !FADF_HAVEIID set for vt %d with %x\n", vttypes[i].vt, hres);
 644                 }
 645                 hres = SafeArrayDestroyDescriptor(a);
 646                 ok(hres == S_OK,"SADD failed with hres %x\n",hres);
 647         }
 648 }
 649
 650 static void test_SafeArrayAllocDestroyDescriptor(void)
 651 {
 652   SAFEARRAY *sa;
 653   HRESULT hres;
 654   int i;
 655
 656   /* Failure cases */
 657   hres = SafeArrayAllocDescriptor(0, &sa);
 658   ok(hres == E_INVALIDARG, "0 dimensions gave hres 0x%x\n", hres);
 659
 660   hres = SafeArrayAllocDescriptor(65536, &sa);
 661   ok(IS_ANCIENT || hres == E_INVALIDARG,
 662      "65536 dimensions gave hres 0x%x\n", hres);
 663
 664   if (0)
 665   {
 666   /* Crashes on 95: XP & Wine return E_POINTER */
 667   hres=SafeArrayAllocDescriptor(1, NULL);
 668   ok(hres == E_POINTER,"NULL parm gave hres 0x%x\n", hres);
 669   }
 670
 671   /* Test up to the dimension boundary case */
 672   for (i = 5; i <= 65535; i += 30)
 673   {
 674     hres = SafeArrayAllocDescriptor(i, &sa);
 675     ok(hres == S_OK, "%d dimensions failed; hres 0x%x\n", i, hres);
 676
 677     if (hres == S_OK)
 678     {
 679       ok(SafeArrayGetDim(sa) == (UINT)i, "Dimension is %d; should be %d\n",
 680          SafeArrayGetDim(sa), i);
 681
 682       hres = SafeArrayDestroyDescriptor(sa);
 683       ok(hres == S_OK, "destroy failed; hres 0x%x\n", hres);
 684     }
 685   }
 686
 687   if (!pSafeArrayAllocDescriptorEx)
 688     return;
 689
 690   hres = pSafeArrayAllocDescriptorEx(VT_UI1, 0, &sa);
 691   ok(hres == E_INVALIDARG, "0 dimensions gave hres 0x%x\n", hres);
 692
 693   hres = pSafeArrayAllocDescriptorEx(VT_UI1, 65536, &sa);
 694   ok(hres == E_INVALIDARG, "65536 dimensions gave hres 0x%x\n", hres);
 695
 696   hres = pSafeArrayAllocDescriptorEx(VT_UI1, 1, NULL);
 697   ok(hres == E_POINTER,"NULL parm gave hres 0x%x\n", hres);
 698
 699   hres = pSafeArrayAllocDescriptorEx(-1, 1, &sa);
 700   ok(hres == S_OK, "VT = -1 gave hres 0x%x\n", hres);
 701
 702   sa->rgsabound[0].cElements = 0;
 703   sa->rgsabound[0].lLbound = 1;
 704
 705   hres = SafeArrayAllocData(sa);
 706   ok(hres == S_OK, "SafeArrayAllocData gave hres 0x%x\n", hres);
 707
 708   hres = SafeArrayDestroy(sa);
 709   ok(hres == S_OK,"SafeArrayDestroy failed with hres %x\n",hres);
 710 }
 711
 712 static void test_SafeArrayCreateLockDestroy(void)
 713 {
 714   SAFEARRAYBOUND sab[4];
 715   SAFEARRAY *sa;
 716   HRESULT hres;
 717   VARTYPE vt;
 718   int dimension;
 719
 720 #define NUM_DIMENSIONS (int)(sizeof(sab) / sizeof(sab[0]))
 721
 722   for (dimension = 0; dimension < NUM_DIMENSIONS; dimension++)
 723   {
 724     sab[dimension].lLbound = 0;
 725     sab[dimension].cElements = 8;
 726   }
 727
 728   /* Failure cases */
 729 /* This test crashes very early versions with no error checking...
 730   sa = SafeArrayCreate(VT_UI1, 1, NULL);
 731   ok(sa == NULL, "NULL bounds didn't fail\n");
 732 */
 733   sa = SafeArrayCreate(VT_UI1, 65536, sab);
 734   ok(IS_ANCIENT || !sa, "Max bounds didn't fail\n");
 735
 736   memset(sab, 0, sizeof(sab));
 737
 738   /* Don't test 0 sized dimensions, as Windows has a bug which allows this */
 739
 740   for (dimension = 0; dimension < NUM_DIMENSIONS; dimension++)
 741     sab[dimension].cElements = 8;
 742
 743   /* Test all VARTYPES in 1-4 dimensions */
 744   for (dimension = 1; dimension < 4; dimension++)
 745   {
 746     for (vt = VT_EMPTY; vt < VT_CLSID; vt++)
 747     {
 748       DWORD dwLen = SAFEARRAY_GetVTSize(vt);
 749
 750       sa = SafeArrayCreate(vt, dimension, sab);
 751
 752       if (dwLen)
 753         ok(sa || (IS_ANCIENT && (vt == VT_DECIMAL || vt == VT_I1 || vt == VT_UI2 ||
 754            vt == VT_UI4 || vt == VT_INT || vt == VT_UINT)),
 755            "VARTYPE %d (@%d dimensions) failed\n", vt, dimension);
 756       else
 757         ok(sa == NULL || vt == VT_R8,
 758            "VARTYPE %d (@%d dimensions) succeeded!\n", vt, dimension);
 759
 760       if (sa)
 761       {
 762         ok(SafeArrayGetDim(sa) == (UINT)dimension,
 763            "VARTYPE %d (@%d dimensions) cDims is %d, expected %d\n",
 764            vt, dimension, SafeArrayGetDim(sa), dimension);
 765         ok(SafeArrayGetElemsize(sa) == dwLen || vt == VT_R8,
 766            "VARTYPE %d (@%d dimensions) cbElements is %d, expected %d\n",
 767            vt, dimension, SafeArrayGetElemsize(sa), dwLen);
 768
 769         if (vt != VT_UNKNOWN && vt != VT_DISPATCH)
 770         {
 771           ok((sa->fFeatures & FADF_HAVEIID) == 0,
 772              "Non interface type should not have FADF_HAVEIID\n");
 773           if (pSafeArraySetIID)
 774           {
 775             hres = pSafeArraySetIID(sa, &IID_IUnknown);
 776             ok(hres == E_INVALIDARG,
 777                "Non interface type allowed SetIID(), hres %x\n", hres);
 778           }
 779           if (vt != VT_RECORD)
 780           {
 781             VARTYPE aVt;
 782
 783             ok(IS_ANCIENT || sa->fFeatures & FADF_HAVEVARTYPE,
 784                "Non interface type should have FADF_HAVEVARTYPE\n");
 785             if (pSafeArrayGetVartype)
 786             {
 787               hres = pSafeArrayGetVartype(sa, &aVt);
 788               ok(hres == S_OK && aVt == vt,
 789                  "Non interface type %d: bad type %d, hres %x\n", vt, aVt, hres);
 790             }
 791           }
 792         }
 793         else
 794         {
 795           ok(IS_ANCIENT || sa->fFeatures & FADF_HAVEIID,
 796              "Interface type should have FADF_HAVEIID\n");
 797           if (pSafeArraySetIID)
 798           {
 799             hres = pSafeArraySetIID(sa, &IID_IUnknown);
 800             ok(hres == S_OK,
 801                "Non interface type disallowed SetIID(), hres %x\n", hres);
 802           }
 803           ok((sa->fFeatures & FADF_HAVEVARTYPE) == 0,
 804              "Interface type %d should not have FADF_HAVEVARTYPE\n", vt);
 805         }
 806
 807         hres = SafeArrayLock(sa);
 808         ok(hres == S_OK, "Lock VARTYPE %d (@%d dimensions) failed; hres 0x%x\n",
 809            vt, dimension, hres);
 810
 811         if (hres == S_OK)
 812         {
 813           hres = SafeArrayDestroy(sa);
 814           ok(hres == DISP_E_ARRAYISLOCKED,"Destroy() got hres %x\n", hres);
 815
 816           hres = SafeArrayDestroyData(sa);
 817           ok(hres == DISP_E_ARRAYISLOCKED,"DestroyData() got hres %x\n", hres);
 818
 819           hres = SafeArrayDestroyDescriptor(sa);
 820           ok(hres == DISP_E_ARRAYISLOCKED,"DestroyDescriptor() got hres %x\n", hres);
 821
 822           hres = SafeArrayUnlock(sa);
 823           ok(hres == S_OK, "Unlock VARTYPE %d (@%d dims) hres 0x%x\n",
 824              vt, dimension, hres);
 825
 826           hres = SafeArrayDestroy(sa);
 827           ok(hres == S_OK, "destroy VARTYPE %d (@%d dims) hres 0x%x\n",
 828              vt, dimension, hres);
 829         }
 830       }
 831     }
 832   }
 833 }
 834
 835 static void test_VectorCreateLockDestroy(void)
 836 {
 837   SAFEARRAY *sa;
 838   HRESULT hres;
 839   VARTYPE vt;
 840   int element;
 841
 842   if (!pSafeArrayCreateVector)
 843     return;
 844   sa = pSafeArrayCreateVector(VT_UI1, 0, 0);
 845   ok(sa != NULL, "SACV with 0 elements failed.\n");
 846
 847   hres = SafeArrayDestroy(sa);
 848   ok(hres == S_OK, "SafeArrayDestroy failed with hres %x\n",hres);
 849
 850   /* Test all VARTYPES in different lengths */
 851   for (element = 1; element <= 101; element += 10)
 852   {
 853     for (vt = VT_EMPTY; vt < VT_CLSID; vt++)
 854     {
 855       DWORD dwLen = SAFEARRAY_GetVTSize(vt);
 856
 857       sa = pSafeArrayCreateVector(vt, 0, element);
 858
 859       if (dwLen)
 860         ok(sa != NULL, "VARTYPE %d (@%d elements) failed\n", vt, element);
 861       else
 862         ok(sa == NULL, "VARTYPE %d (@%d elements) succeeded!\n", vt, element);
 863
 864       if (sa)
 865       {
 866         ok(SafeArrayGetDim(sa) == 1, "VARTYPE %d (@%d elements) cDims %d, not 1\n",
 867            vt, element, SafeArrayGetDim(sa));
 868         ok(SafeArrayGetElemsize(sa) == dwLen,
 869            "VARTYPE %d (@%d elements) cbElements is %d, expected %d\n",
 870            vt, element, SafeArrayGetElemsize(sa), dwLen);
 871
 872         hres = SafeArrayLock(sa);
 873         ok(hres == S_OK, "Lock VARTYPE %d (@%d elements) failed; hres 0x%x\n",
 874            vt, element, hres);
 875
 876         if (hres == S_OK)
 877         {
 878           hres = SafeArrayUnlock(sa);
 879           ok(hres == S_OK, "Unlock VARTYPE %d (@%d elements) failed; hres 0x%x\n",
 880              vt, element, hres);
 881
 882           hres = SafeArrayDestroy(sa);
 883           ok(hres == S_OK, "destroy VARTYPE %d (@%d elements) failed; hres 0x%x\n",
 884              vt, element, hres);
 885         }
 886       }
 887     }
 888   }
 889 }
 890
 891 static void test_LockUnlock(void)
 892 {
 893   SAFEARRAYBOUND sab[4];
 894   SAFEARRAY *sa;
 895   HRESULT hres;
 896   BOOL bVector = FALSE;
 897   int dimension;
 898
 899   /* Failure cases */
 900   hres = SafeArrayLock(NULL);
 901   ok(hres == E_INVALIDARG, "Lock NULL array hres 0x%x\n", hres);
 902   hres = SafeArrayUnlock(NULL);
 903   ok(hres == E_INVALIDARG, "Lock NULL array hres 0x%x\n", hres);
 904
 905   for (dimension = 0; dimension < NUM_DIMENSIONS; dimension++)
 906   {
 907     sab[dimension].lLbound = 0;
 908     sab[dimension].cElements = 8;
 909   }
 910
 911   sa = SafeArrayCreate(VT_UI1, NUM_DIMENSIONS, sab);
 912
 913   /* Test maximum locks */
 914 test_LockUnlock_Vector:
 915   if (sa)
 916   {
 917     int count = 0;
 918
 919     hres = SafeArrayUnlock(sa);
 920     ok (hres == E_UNEXPECTED, "Bad %sUnlock gave hres 0x%x\n",
 921         bVector ? "vector " : "\n", hres);
 922
 923     while ((hres = SafeArrayLock(sa)) == S_OK)
 924       count++;
 925     ok (count == 65535 && hres == E_UNEXPECTED, "Lock %sfailed at %d; hres 0x%x\n",
 926         bVector ? "vector " : "\n", count, hres);
 927
 928     if (count == 65535 && hres == E_UNEXPECTED)
 929     {
 930       while ((hres = SafeArrayUnlock(sa)) == S_OK)
 931         count--;
 932       ok (count == 0 && hres == E_UNEXPECTED, "Unlock %sfailed at %d; hres 0x%x\n",
 933           bVector ? "vector " : "\n", count, hres);
 934     }
 935
 936     SafeArrayDestroy(sa);
 937   }
 938
 939   if (bVector == FALSE && pSafeArrayCreateVector)
 940   {
 941     /* Test again with a vector */
 942     sa = pSafeArrayCreateVector(VT_UI1, 0, 100);
 943     bVector = TRUE;
 944     goto test_LockUnlock_Vector;
 945   }
 946 }
 947
 948 static void test_SafeArrayGetPutElement(void)
 949 {
 950   SAFEARRAYBOUND sab[4];
 951   LONG indices[NUM_DIMENSIONS];
 952   SAFEARRAY *sa;
 953   HRESULT hres;
 954   int value = 0, gotvalue, dimension;
 955   unsigned int x,y,z,a;
 956
 957   for (dimension = 0; dimension < NUM_DIMENSIONS; dimension++)
 958   {
 959     sab[dimension].lLbound = dimension * 2 + 1;
 960     sab[dimension].cElements = dimension * 3 + 1;
 961   }
 962
 963   sa = SafeArrayCreate(VT_INT, NUM_DIMENSIONS, sab);
 964   if (!sa)
 965     return; /* Some early versions can't handle > 3 dims */
 966
 967   ok(sa->cbElements == sizeof(value), "int size mismatch\n");
 968   if (sa->cbElements != sizeof(value))
 969     return;
 970
 971   /* Failure cases */
 972   for (x = 0; x < NUM_DIMENSIONS; x++)
 973   {
 974     indices[0] = sab[0].lLbound;
 975     indices[1] = sab[1].lLbound;
 976     indices[2] = sab[2].lLbound;
 977     indices[3] = sab[3].lLbound;
 978
 979     indices[x] = indices[x] - 1;
 980     hres = SafeArrayPutElement(sa, indices, &value);
 981     ok(hres == DISP_E_BADINDEX, "Put allowed too small index in dimension %d\n", x);
 982     hres = SafeArrayGetElement(sa, indices, &value);
 983     ok(hres == DISP_E_BADINDEX, "Get allowed too small index in dimension %d\n", x);
 984
 985     indices[x] = sab[x].lLbound + sab[x].cElements;
 986     hres = SafeArrayPutElement(sa, indices, &value);
 987     ok(hres == DISP_E_BADINDEX, "Put allowed too big index in dimension %d\n", x);
 988     hres = SafeArrayGetElement(sa, indices, &value);
 989     ok(hres == DISP_E_BADINDEX, "Get allowed too big index in dimension %d\n", x);
 990   }
 991
 992   indices[0] = sab[0].lLbound;
 993   indices[1] = sab[1].lLbound;
 994   indices[2] = sab[2].lLbound;
 995   indices[3] = sab[3].lLbound;
 996
 997   hres = SafeArrayPutElement(NULL, indices, &value);
 998   ok(hres == E_INVALIDARG, "Put NULL array hres 0x%x\n", hres);
 999   hres = SafeArrayGetElement(NULL, indices, &value);
1000   ok(hres == E_INVALIDARG, "Get NULL array hres 0x%x\n", hres);
1001
1002   hres = SafeArrayPutElement(sa, NULL, &value);
1003   ok(hres == E_INVALIDARG, "Put NULL indices hres 0x%x\n", hres);
1004   hres = SafeArrayGetElement(sa, NULL, &value);
1005   ok(hres == E_INVALIDARG, "Get NULL indices hres 0x%x\n", hres);
1006
1007   if (0)
1008   {
1009   /* This is retarded. Windows checks every case of invalid parameters
1010    * except the following, which crashes. We ERR this in Wine.
1011    */
1012   hres = SafeArrayPutElement(sa, indices, NULL);
1013   ok(hres == E_INVALIDARG, "Put NULL value hres 0x%x\n", hres);
1014   }
1015
1016   hres = SafeArrayGetElement(sa, indices, NULL);
1017   ok(hres == E_INVALIDARG, "Get NULL value hres 0x%x\n", hres);
1018
1019   value = 0;
1020
1021   /* Make sure we can read and get back the correct values in 4 dimensions,
1022    * Each with a different size and lower bound.
1023    */
1024   for (x = 0; x < sab[0].cElements; x++)
1025   {
1026     indices[0] = sab[0].lLbound + x;
1027     for (y = 0; y < sab[1].cElements; y++)
1028     {
1029       indices[1] = sab[1].lLbound + y;
1030       for (z = 0; z < sab[2].cElements; z++)
1031       {
1032         indices[2] = sab[2].lLbound + z;
1033         for (a = 0; a < sab[3].cElements; a++)
1034         {
1035           indices[3] = sab[3].lLbound + a;
1036           hres = SafeArrayPutElement(sa, indices, &value);
1037           ok(hres == S_OK, "Failed to put element at (%d,%d,%d,%d) hres 0x%x\n",
1038              x, y, z, a, hres);
1039           value++;
1040         }
1041       }
1042     }
1043   }
1044
1045   value = 0;
1046
1047   for (x = 0; x < sab[0].cElements; x++)
1048   {
1049     indices[0] = sab[0].lLbound + x;
1050     for (y = 0; y < sab[1].cElements; y++)
1051     {
1052       indices[1] = sab[1].lLbound + y;
1053       for (z = 0; z < sab[2].cElements; z++)
1054       {
1055         indices[2] = sab[2].lLbound + z;
1056         for (a = 0; a < sab[3].cElements; a++)
1057         {
1058           indices[3] = sab[3].lLbound + a;
1059           gotvalue = value / 3;
1060           hres = SafeArrayGetElement(sa, indices, &gotvalue);
1061           ok(hres == S_OK, "Failed to get element at (%d,%d,%d,%d) hres 0x%x\n",
1062              x, y, z, a, hres);
1063           if (hres == S_OK)
1064             ok(value == gotvalue, "Got value %d instead of %d at (%d,%d,%d,%d)\n",
1065                gotvalue, value, x, y, z, a);
1066           value++;
1067         }
1068       }
1069     }
1070   }
1071   SafeArrayDestroy(sa);
1072 }
1073
1074 static void test_SafeArrayGetPutElement_BSTR(void)
1075 {
1076   SAFEARRAYBOUND sab;
1077   LONG indices[1];
1078   SAFEARRAY *sa;
1079   HRESULT hres;
1080   BSTR value = 0, gotvalue;
1081   const OLECHAR szTest[5] = { 'T','e','s','t','\0' };
1082
1083   sab.lLbound = 1;
1084   sab.cElements = 1;
1085
1086   sa = SafeArrayCreate(VT_BSTR, 1, &sab);
1087   ok(sa != NULL, "BSTR test couldn't create array\n");
1088   if (!sa)
1089     return;
1090
1091   ok(sa->cbElements == sizeof(BSTR), "BSTR size mismatch\n");
1092   if (sa->cbElements != sizeof(BSTR))
1093     return;
1094
1095   indices[0] = sab.lLbound;
1096   value = SysAllocString(szTest);
1097   ok (value != NULL, "Expected non-NULL\n");
1098   hres = SafeArrayPutElement(sa, indices, value);
1099   ok(hres == S_OK, "Failed to put bstr element hres 0x%x\n", hres);
1100   gotvalue = NULL;
1101   hres = SafeArrayGetElement(sa, indices, &gotvalue);
1102   ok(hres == S_OK, "Failed to get bstr element at hres 0x%x\n", hres);
1103   if (hres == S_OK)
1104     ok(SysStringLen(value) == SysStringLen(gotvalue), "Got len %d instead of %d\n", SysStringLen(gotvalue), SysStringLen(value));
1105   SafeArrayDestroy(sa);
1106   SysFreeString(value);
1107   SysFreeString(gotvalue);
1108 }
1109
1110 static int tunk_xref = 0;
1111 static HRESULT WINAPI tunk_QueryInterface(LPUNKNOWN punk,REFIID riid, LPVOID *x) {
1112         return E_FAIL;
1113 }
1114 static ULONG WINAPI tunk_AddRef(LPUNKNOWN punk) {
1115         return ++tunk_xref;
1116 }
1117
1118 static ULONG WINAPI tunk_Release(LPUNKNOWN punk) {
1119         return --tunk_xref;
1120 }
1121
1122 static const IUnknownVtbl xtunk_vtbl = {
1123         tunk_QueryInterface,
1124         tunk_AddRef,
1125         tunk_Release
1126 };
1127
1128 static struct xtunk_iface {
1129         const IUnknownVtbl *lpvtbl;
1130 } xtunk_iface;
1131
1132
1133 static void test_SafeArrayGetPutElement_IUnknown(void)
1134 {
1135   SAFEARRAYBOUND sab;
1136   LONG indices[1];
1137   SAFEARRAY *sa;
1138   HRESULT hres;
1139   LPUNKNOWN value = 0, gotvalue;
1140
1141   sab.lLbound = 1;
1142   sab.cElements = 1;
1143   sa = SafeArrayCreate(VT_UNKNOWN, 1, &sab);
1144   ok(sa != NULL, "UNKNOWN test couldn't create array\n");
1145   if (!sa)
1146     return;
1147
1148   ok(sa->cbElements == sizeof(LPUNKNOWN), "LPUNKNOWN size mismatch\n");
1149   if (sa->cbElements != sizeof(LPUNKNOWN))
1150     return;
1151
1152   indices[0] = sab.lLbound;
1153   xtunk_iface.lpvtbl = &xtunk_vtbl;
1154   value = (LPUNKNOWN)&xtunk_iface;
1155   tunk_xref = 1;
1156   ok (value != NULL, "Expected non-NULL\n");
1157   hres = SafeArrayPutElement(sa, indices, value);
1158   ok(hres == S_OK, "Failed to put bstr element hres 0x%x\n", hres);
1159   ok(tunk_xref == 2,"Failed to increment refcount of iface.\n");
1160   gotvalue = NULL;
1161   hres = SafeArrayGetElement(sa, indices, &gotvalue);
1162   ok(tunk_xref == 3,"Failed to increment refcount of iface.\n");
1163   ok(hres == S_OK, "Failed to get bstr element at hres 0x%x\n", hres);
1164   if (hres == S_OK)
1165     ok(value == gotvalue, "Got %p instead of %p\n", gotvalue, value);
1166   SafeArrayDestroy(sa);
1167   ok(tunk_xref == 2,"Failed to decrement refcount of iface.\n");
1168 }
1169
1170 static void test_SafeArrayRedim_IUnknown(void)
1171 {
1172   SAFEARRAYBOUND sab;
1173   LONG indices[1];
1174   SAFEARRAY *sa;
1175   HRESULT hres;
1176   LPUNKNOWN value;
1177
1178   sab.lLbound = 1;
1179   sab.cElements = 2;
1180   sa = SafeArrayCreate(VT_UNKNOWN, 1, &sab);
1181   ok(sa != NULL, "UNKNOWN test couldn't create array\n");
1182   if (!sa)
1183     return;
1184
1185   ok(sa->cbElements == sizeof(LPUNKNOWN), "LPUNKNOWN size mismatch\n");
1186   if (sa->cbElements != sizeof(LPUNKNOWN))
1187     return;
1188
1189   indices[0] = 2;
1190   xtunk_iface.lpvtbl = &xtunk_vtbl;
1191   value = (LPUNKNOWN)&xtunk_iface;
1192   tunk_xref = 1;
1193   hres = SafeArrayPutElement(sa, indices, value);
1194   ok(hres == S_OK, "Failed to put IUnknown element hres 0x%x\n", hres);
1195   ok(tunk_xref == 2,"Failed to increment refcount of iface.\n");
1196   sab.cElements = 1;
1197   hres = SafeArrayRedim(sa, &sab);
1198   ok(hres == S_OK, "Failed to shrink array hres 0x%x\n", hres);
1199   ok(tunk_xref == 1, "Failed to decrement refcount\n");
1200   SafeArrayDestroy(sa);
1201 }
1202
1203 static void test_SafeArrayGetPutElement_VARIANT(void)
1204 {
1205   SAFEARRAYBOUND sab;
1206   LONG indices[1];
1207   SAFEARRAY *sa;
1208   HRESULT hres;
1209   VARIANT value, gotvalue;
1210
1211   sab.lLbound = 1;
1212   sab.cElements = 1;
1213   sa = SafeArrayCreate(VT_VARIANT, 1, &sab);
1214   ok(sa != NULL, "VARIANT test couldn't create array\n");
1215   if (!sa)
1216     return;
1217
1218   ok(sa->cbElements == sizeof(VARIANT), "VARIANT size mismatch\n");
1219   if (sa->cbElements != sizeof(VARIANT))
1220     return;
1221
1222   indices[0] = sab.lLbound;
1223   V_VT(&value) = VT_I4;
1224   V_I4(&value) = 0x42424242;
1225   hres = SafeArrayPutElement(sa, indices, &value);
1226   ok(hres == S_OK, "Failed to put Variant I4 element hres 0x%x\n", hres);
1227
1228   V_VT(&gotvalue) = 0xdead;
1229   hres = SafeArrayGetElement(sa, indices, &gotvalue);
1230   ok(hres == S_OK, "Failed to get variant element at hres 0x%x\n", hres);
1231
1232   V_VT(&gotvalue) = VT_EMPTY;
1233   hres = SafeArrayGetElement(sa, indices, &gotvalue);
1234   ok(hres == S_OK, "Failed to get variant element at hres 0x%x\n", hres);
1235   if (hres == S_OK) {
1236     ok(V_VT(&value) == V_VT(&gotvalue), "Got type 0x%x instead of 0x%x\n", V_VT(&value), V_VT(&gotvalue));
1237     if (V_VT(&value) == V_VT(&gotvalue))
1238         ok(V_I4(&value) == V_I4(&gotvalue), "Got %d instead of %d\n", V_I4(&value), V_VT(&gotvalue));
1239   }
1240   SafeArrayDestroy(sa);
1241 }
1242
1243
1244 static void test_SafeArrayCopyData(void)
1245 {
1246   SAFEARRAYBOUND sab[4];
1247   SAFEARRAY *sa;
1248   SAFEARRAY *sacopy;
1249   HRESULT hres;
1250   int dimension,size=1;
1251
1252   if (!pSafeArrayCopyData)
1253     return;
1254
1255   for (dimension = 0; dimension < NUM_DIMENSIONS; dimension++)
1256   {
1257     sab[dimension].lLbound = dimension * 2 + 2;
1258     sab[dimension].cElements = dimension * 3 + 1;
1259     size *= sab[dimension].cElements;
1260   }
1261
1262   sa = SafeArrayCreate(VT_INT, NUM_DIMENSIONS, sab);
1263   ok(sa != NULL, "Copy test couldn't create array\n");
1264   sacopy = SafeArrayCreate(VT_INT, NUM_DIMENSIONS, sab);
1265   ok(sacopy != NULL, "Copy test couldn't create copy array\n");
1266
1267   if (!sa || !sacopy)
1268     return;
1269
1270   ok(sa->cbElements == sizeof(int), "int size mismatch\n");
1271   if (sa->cbElements != sizeof(int))
1272     return;
1273
1274   /* Fill the source array with some data; it doesn't matter what */
1275   for (dimension = 0; dimension < size; dimension++)
1276   {
1277     int* data = sa->pvData;
1278     data[dimension] = dimension;
1279   }
1280
1281   hres = pSafeArrayCopyData(sa, sacopy);
1282   ok(hres == S_OK, "copy data failed hres 0x%x\n", hres);
1283   if (hres == S_OK)
1284   {
1285     ok(!memcmp(sa->pvData, sacopy->pvData, size * sizeof(int)), "compared different\n");
1286   }
1287
1288   /* Failure cases */
1289   hres = pSafeArrayCopyData(NULL, sacopy);
1290   ok(hres == E_INVALIDARG, "Null copy source hres 0x%x\n", hres);
1291   hres = pSafeArrayCopyData(sa, NULL);
1292   ok(hres == E_INVALIDARG, "Null copy hres 0x%x\n", hres);
1293
1294   sacopy->rgsabound[0].cElements += 1;
1295   hres = pSafeArrayCopyData(sa, sacopy);
1296   ok(hres == E_INVALIDARG, "Bigger copy first dimension hres 0x%x\n", hres);
1297
1298   sacopy->rgsabound[0].cElements -= 2;
1299   hres = pSafeArrayCopyData(sa, sacopy);
1300   ok(hres == E_INVALIDARG, "Smaller copy first dimension hres 0x%x\n", hres);
1301   sacopy->rgsabound[0].cElements += 1;
1302
1303   sacopy->rgsabound[3].cElements += 1;
1304   hres = pSafeArrayCopyData(sa, sacopy);
1305   ok(hres == E_INVALIDARG, "Bigger copy last dimension hres 0x%x\n", hres);
1306
1307   sacopy->rgsabound[3].cElements -= 2;
1308   hres = pSafeArrayCopyData(sa, sacopy);
1309   ok(hres == E_INVALIDARG, "Smaller copy last dimension hres 0x%x\n", hres);
1310   sacopy->rgsabound[3].cElements += 1;
1311
1312   SafeArrayDestroy(sacopy);
1313   sacopy = NULL;
1314   hres = pSafeArrayCopyData(sa, sacopy);
1315   ok(hres == E_INVALIDARG, "->Null copy hres 0x%x\n", hres);
1316
1317   hres = SafeArrayCopy(sa, &sacopy);
1318   ok(hres == S_OK, "copy failed hres 0x%x\n", hres);
1319   if (hres == S_OK)
1320   {
1321     ok(SafeArrayGetElemsize(sa) == SafeArrayGetElemsize(sacopy),"elemsize wrong\n");
1322     ok(SafeArrayGetDim(sa) == SafeArrayGetDim(sacopy),"dimensions wrong\n");
1323     ok(!memcmp(sa->pvData, sacopy->pvData, size * sizeof(int)), "compared different\n");
1324   }
1325
1326   SafeArrayDestroy(sa);
1327 }
1328
1329 static void test_SafeArrayCreateEx(void)
1330 {
1331   IRecordInfoImpl* iRec;
1332   SAFEARRAYBOUND sab[4];
1333   SAFEARRAY *sa;
1334   HRESULT hres;
1335   int dimension;
1336
1337   if (!pSafeArrayCreateEx)
1338     return;
1339
1340   for (dimension = 0; dimension < NUM_DIMENSIONS; dimension++)
1341   {
1342     sab[dimension].lLbound = 0;
1343     sab[dimension].cElements = 8;
1344   }
1345
1346   /* Failure cases */
1347   sa = pSafeArrayCreateEx(VT_UI1, 1, NULL, NULL);
1348   ok(sa == NULL, "CreateEx NULL bounds didn't fail\n");
1349
1350   /* test IID storage & defaulting */
1351   sa = pSafeArrayCreateEx(VT_DISPATCH, 1, sab, (PVOID)&IID_ITypeInfo);
1352   ok(sa != NULL, "CreateEx (ITypeInfo) failed\n");
1353
1354   if (sa)
1355   {
1356     GUID guid;
1357     if (pSafeArrayGetIID)
1358     {
1359       hres = pSafeArrayGetIID(sa, &guid);
1360       ok(hres == S_OK, "CreateEx (ITypeInfo) no IID hres 0x%x\n", hres);
1361       if (hres == S_OK)
1362       {
1363         ok(IsEqualGUID(&guid, &IID_ITypeInfo), "CreateEx (ITypeInfo) bad IID\n");
1364       }
1365     }
1366     if (pSafeArraySetIID)
1367     {
1368       hres = pSafeArraySetIID(sa, &IID_IUnknown);
1369       ok(hres == S_OK, "Failed to set IID, hres = %8x\n", hres);
1370       if (hres == S_OK && pSafeArrayGetIID)
1371       {
1372         hres = pSafeArrayGetIID(sa, &guid);
1373         ok(hres == S_OK && IsEqualGUID(&guid, &IID_IUnknown), "Set bad IID\n");
1374       }
1375     }
1376     SafeArrayDestroy(sa);
1377   }
1378
1379   sa = pSafeArrayCreateEx(VT_DISPATCH, 1, sab, NULL);
1380   ok(sa != NULL, "CreateEx (NULL) failed\n");
1381
1382   if (sa)
1383   {
1384     GUID guid;
1385     if (pSafeArrayGetIID)
1386     {
1387       hres = pSafeArrayGetIID(sa, &guid);
1388       ok(hres == S_OK, "CreateEx (NULL) no IID hres 0x%x\n", hres);
1389       if (hres == S_OK)
1390       {
1391         ok(IsEqualGUID(&guid, &IID_IDispatch), "CreateEx (NULL) bad IID\n");
1392       }
1393     }
1394     SafeArrayDestroy(sa);
1395   }
1396
1397   sa = pSafeArrayCreateEx(VT_UNKNOWN, 1, sab, NULL);
1398   ok(sa != NULL, "CreateEx (NULL-Unk) failed\n");
1399
1400   if (sa)
1401   {
1402     GUID guid;
1403     if (pSafeArrayGetIID)
1404     {
1405       hres = pSafeArrayGetIID(sa, &guid);
1406       ok(hres == S_OK, "CreateEx (NULL-Unk) no IID hres 0x%x\n", hres);
1407       if (hres == S_OK)
1408       {
1409         ok(IsEqualGUID(&guid, &IID_IUnknown), "CreateEx (NULL-Unk) bad IID\n");
1410       }
1411     }
1412     SafeArrayDestroy(sa);
1413   }
1414
1415   /* VT_RECORD failure case */
1416   sa = pSafeArrayCreateEx(VT_RECORD, 1, sab, NULL);
1417   ok(sa == NULL, "CreateEx (NULL-Rec) succeded\n");
1418
1419   iRec = IRecordInfoImpl_Construct();
1420
1421   /* Win32 doesn't care if GetSize fails */
1422   fail_GetSize = TRUE;
1423   sa = pSafeArrayCreateEx(VT_RECORD, 1, sab, iRec);
1424   ok(sa != NULL, "CreateEx (Fail Size) failed\n");
1425   ok(iRec->ref == START_REF_COUNT + 1, "Wrong iRec refcount %d\n", iRec->ref);
1426   ok(iRec->sizeCalled == 1, "GetSize called %d times\n", iRec->sizeCalled);
1427   ok(iRec->clearCalled == 0, "Clear called %d times\n", iRec->clearCalled);
1428   if (sa)
1429   {
1430     ok(sa->cbElements == RECORD_SIZE_FAIL, "Altered size to %d\n", sa->cbElements);
1431     SafeArrayDestroy(sa);
1432     ok(iRec->clearCalled == sab[0].cElements, "Destroy->Clear called %d times\n", iRec->clearCalled);
1433   }
1434
1435   /* Test VT_RECORD array */
1436   fail_GetSize = FALSE;
1437   iRec->ref = START_REF_COUNT;
1438   iRec->sizeCalled = 0;
1439   iRec->clearCalled = 0;
1440   sa = pSafeArrayCreateEx(VT_RECORD, 1, sab, iRec);
1441   ok(sa != NULL, "CreateEx (Rec) failed\n");
1442   ok(iRec->ref == START_REF_COUNT + 1, "Wrong iRec refcount %d\n", iRec->ref);
1443   ok(iRec->sizeCalled == 1, "GetSize called %d times\n", iRec->sizeCalled);
1444   ok(iRec->clearCalled == 0, "Clear called %d times\n", iRec->clearCalled);
1445   if (sa && pSafeArrayGetRecordInfo)
1446   {
1447     IRecordInfo* saRec = NULL;
1448     hres = pSafeArrayGetRecordInfo(sa, &saRec);
1449
1450     ok(hres == S_OK,"GRI failed\n");
1451     ok(saRec == (IRecordInfo*)iRec,"Different saRec\n");
1452     ok(iRec->ref == START_REF_COUNT + 2, "Didn't AddRef %d\n", iRec->ref);
1453     if (iRec->ref == START_REF_COUNT + 2)
1454       IRecordInfo_Release(saRec);
1455
1456     ok(sa->cbElements == RECORD_SIZE,"Elemsize is %d\n", sa->cbElements);
1457
1458     SafeArrayDestroy(sa);
1459     ok(iRec->sizeCalled == 1, "Destroy->GetSize called %d times\n", iRec->sizeCalled);
1460     ok(iRec->clearCalled == sab[0].cElements, "Destroy->Clear called %d times\n", iRec->clearCalled);
1461     ok(iRec->ref == START_REF_COUNT, "Wrong iRec refcount %d\n", iRec->ref);
1462   }
1463 }
1464
1465 static void test_SafeArrayClear(void)
1466 {
1467   SAFEARRAYBOUND sab;
1468   SAFEARRAY *sa;
1469   VARIANTARG v;
1470   HRESULT hres;
1471
1472   sab.lLbound = 0;
1473   sab.cElements = 10;
1474   sa = SafeArrayCreate(VT_UI1, 1, &sab);
1475   ok(sa != NULL, "Create() failed.\n");
1476   if (!sa)
1477     return;
1478
1479   /* Test clearing non-NULL variants containing arrays */
1480   V_VT(&v) = VT_ARRAY|VT_UI1;
1481   V_ARRAY(&v) = sa;
1482   hres = VariantClear(&v);
1483   ok(hres == S_OK && V_VT(&v) == VT_EMPTY, "VariantClear: hres 0x%x, Type %d\n", hres, V_VT(&v));
1484   ok(V_ARRAY(&v) == sa, "VariantClear: Overwrote value\n");
1485
1486   sa = SafeArrayCreate(VT_UI1, 1, &sab);
1487   ok(sa != NULL, "Create() failed.\n");
1488   if (!sa)
1489     return;
1490
1491   V_VT(&v) = VT_SAFEARRAY;
1492   V_ARRAY(&v) = sa;
1493   hres = VariantClear(&v);
1494   ok(hres == DISP_E_BADVARTYPE, "VariantClear: hres 0x%x\n", hres);
1495
1496   V_VT(&v) = VT_SAFEARRAY|VT_BYREF;
1497   V_ARRAYREF(&v) = &sa;
1498   hres = VariantClear(&v);
1499   ok(hres == DISP_E_BADVARTYPE, "VariantClear: hres 0x%x\n", hres);
1500
1501   SafeArrayDestroy(sa);
1502 }
1503
1504 static void test_SafeArrayCopy(void)
1505 {
1506   SAFEARRAYBOUND sab;
1507   SAFEARRAY *sa, *sa2;
1508   VARIANTARG vSrc, vDst;
1509   HRESULT hres;
1510
1511   sab.lLbound = 0;
1512   sab.cElements = 10;
1513   sa = SafeArrayCreate(VT_UI1, 1, &sab);
1514   ok(sa != NULL, "Create() failed.\n");
1515   if (!sa)
1516     return;
1517
1518   /* Test copying non-NULL variants containing arrays */
1519   V_VT(&vSrc) = (VT_ARRAY|VT_BYREF|VT_UI1);
1520   V_ARRAYREF(&vSrc) = &sa;
1521   V_VT(&vDst) = VT_EMPTY;
1522
1523   hres = VariantCopy(&vDst, &vSrc);
1524   ok(hres == S_OK && V_VT(&vDst) == (VT_ARRAY|VT_BYREF|VT_UI1),
1525      "VariantCopy: hres 0x%x, Type %d\n", hres, V_VT(&vDst));
1526   ok(V_ARRAYREF(&vDst) == &sa, "VariantClear: Performed deep copy\n");
1527
1528   V_VT(&vSrc) = (VT_ARRAY|VT_UI1);
1529   V_ARRAY(&vSrc) = sa;
1530   V_VT(&vDst) = VT_EMPTY;
1531
1532   hres = VariantCopy(&vDst, &vSrc);
1533   ok(hres == S_OK && V_VT(&vDst) == (VT_ARRAY|VT_UI1),
1534      "VariantCopy: hres 0x%x, Type %d\n", hres, V_VT(&vDst));
1535   ok(V_ARRAY(&vDst) != sa, "VariantClear: Performed shallow copy\n");
1536
1537   SafeArrayDestroy(V_ARRAY(&vSrc));
1538   SafeArrayDestroy(V_ARRAY(&vDst));
1539
1540   hres = SafeArrayAllocDescriptor(1, &sa);
1541   ok(hres == S_OK, "SafeArrayAllocDescriptor failed with error 0x%08x\n", hres);
1542
1543   hres = SafeArrayCopy(sa, &sa2);
1544   ok(hres == E_INVALIDARG,
1545     "SafeArrayCopy with empty array should have failed with error E_INVALIDARG instead of 0x%08x\n",
1546     hres);
1547   sa->cbElements = 16;
1548   hres = SafeArrayCopy(sa, &sa2);
1549   ok(hres == S_OK, "SafeArrayCopy failed with error 0x%08x\n", hres);
1550
1551   SafeArrayDestroy(sa);
1552 }
1553
1554 #define MKARRAY(low,num,typ) sab.lLbound = low; sab.cElements = num; \
1555   sa = SafeArrayCreate(typ, 1, &sab); ok(sa != NULL, "Create() failed.\n"); \
1556   if (!sa) return; \
1557   V_VT(&v) = VT_ARRAY|typ; V_ARRAY(&v) = sa; VariantInit(&v2)
1558
1559 #define MKARRAYCONT(low,num,typ) sab.lLbound = low; sab.cElements = num; \
1560   sa = SafeArrayCreate(typ, 1, &sab); if (!sa) continue; \
1561   V_VT(&v) = VT_ARRAY|typ; V_ARRAY(&v) = sa; VariantInit(&v2)
1562
1563 static void test_SafeArrayChangeTypeEx(void)
1564 {
1565   static const char *szHello = "Hello World";
1566   SAFEARRAYBOUND sab;
1567   SAFEARRAY *sa;
1568   VARIANTARG v,v2;
1569   VARTYPE vt;
1570   HRESULT hres;
1571
1572   /* VT_ARRAY|VT_UI1 -> VT_BSTR */
1573   MKARRAY(0,strlen(szHello)+1,VT_UI1);
1574   memcpy(sa->pvData, szHello, strlen(szHello)+1);
1575
1576   hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_BSTR);
1577   ok(hres == S_OK, "CTE VT_ARRAY|VT_UI1 -> VT_BSTR failed with %x\n", hres);
1578   if (hres == S_OK)
1579   {
1580     ok(V_VT(&v2) == VT_BSTR, "CTE VT_ARRAY|VT_UI1 -> VT_BSTR did not return VT_BSTR, but %d.\n",V_VT(&v2));
1581     ok(strcmp((char*)V_BSTR(&v2),szHello) == 0,"Expected string '%s', got '%s'\n", szHello,
1582        (char*)V_BSTR(&v2));
1583     VariantClear(&v2);
1584   }
1585
1586   /* VT_VECTOR|VT_UI1 -> VT_BSTR */
1587   SafeArrayDestroy(sa);
1588   if (pSafeArrayCreateVector)
1589   {
1590     sa = pSafeArrayCreateVector(VT_UI1, 0, strlen(szHello)+1);
1591     ok(sa != NULL, "CreateVector() failed.\n");
1592     if (!sa)
1593       return;
1594
1595     memcpy(sa->pvData, szHello, strlen(szHello)+1);
1596     V_VT(&v) = VT_VECTOR|VT_UI1;
1597     V_ARRAY(&v) = sa;
1598     VariantInit(&v2);
1599
1600     hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_BSTR);
1601     ok(hres == DISP_E_BADVARTYPE, "CTE VT_VECTOR|VT_UI1 returned %x\n", hres);
1602
1603     /* (vector)VT_ARRAY|VT_UI1 -> VT_BSTR (In place) */
1604     V_VT(&v) = VT_ARRAY|VT_UI1;
1605     hres = VariantChangeTypeEx(&v, &v, 0, 0, VT_BSTR);
1606     ok(hres == S_OK, "CTE VT_ARRAY|VT_UI1 -> VT_BSTR failed with %x\n", hres);
1607     if (hres == S_OK)
1608     {
1609       ok(V_VT(&v) == VT_BSTR, "CTE VT_ARRAY|VT_UI1 -> VT_BSTR did not return VT_BSTR, but %d.\n",V_VT(&v));
1610       ok(strcmp((char*)V_BSTR(&v),szHello) == 0,"Expected string '%s', got '%s'\n", szHello,
1611               (char*)V_BSTR(&v));
1612       VariantClear(&v);
1613     }
1614   }
1615
1616   /* To/from BSTR only works with arrays of VT_UI1 */
1617   for (vt = 0; vt <= VT_CLSID; vt++)
1618   {
1619     if (vt == VT_UI1)
1620       continue;
1621
1622     MKARRAYCONT(0,1,vt);
1623     hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_BSTR);
1624     ok(hres != S_OK, "CTE VT_ARRAY|VT %d->BSTR succeeded\n", vt);
1625     VariantClear(&v2);
1626     VariantClear(&v);
1627   }
1628
1629   /* Can't change an array of one type into array of another type , even
1630    * if the other type is the same size
1631    */
1632   if (pSafeArrayCreateVector)
1633   {
1634     sa = pSafeArrayCreateVector(VT_UI1, 0, 1);
1635     ok(sa != NULL, "CreateVector() failed.\n");
1636     if (!sa)
1637       return;
1638
1639     V_VT(&v) = VT_ARRAY|VT_UI1;
1640     V_ARRAY(&v) = sa;
1641     hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_ARRAY|VT_I1);
1642     ok(hres == DISP_E_TYPEMISMATCH, "CTE VT_ARRAY|VT_UI1->VT_ARRAY|VT_I1 returned %x\n", hres);
1643
1644     /* But can change to the same array type */
1645     SafeArrayDestroy(sa);
1646     sa = pSafeArrayCreateVector(VT_UI1, 0, 1);
1647     ok(sa != NULL, "CreateVector() failed.\n");
1648     if (!sa)
1649       return;
1650     V_VT(&v) = VT_ARRAY|VT_UI1;
1651     V_ARRAY(&v) = sa;
1652     hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_ARRAY|VT_UI1);
1653     ok(hres == S_OK, "CTE VT_ARRAY|VT_UI1->VT_ARRAY|VT_UI1 returned %x\n", hres);
1654     SafeArrayDestroy(sa);
1655   }
1656
1657   /* NULL/EMPTY */
1658   MKARRAY(0,1,VT_UI1);
1659   hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_NULL);
1660   ok(hres == DISP_E_TYPEMISMATCH, "CTE VT_ARRAY|VT_UI1 returned %x\n", hres);
1661   MKARRAY(0,1,VT_UI1);
1662   hres = VariantChangeTypeEx(&v2, &v, 0, 0, VT_EMPTY);
1663   ok(hres == DISP_E_TYPEMISMATCH, "CTE VT_ARRAY|VT_UI1 returned %x\n", hres);
1664
1665 }
1666
1667 static void test_SafeArrayDestroyData (void)
1668 {
1669   SAFEARRAYBOUND sab;
1670   SAFEARRAY *sa;
1671   HRESULT hres;
1672   int value = 0xdeadbeef;
1673   LONG index[1];
1674   void HUGEP *temp_pvData;
1675
1676   sab.lLbound = 0;
1677   sab.cElements = 10;
1678   sa = SafeArrayCreate(VT_INT, 1, &sab);
1679   ok(sa != NULL, "Create() failed.\n");
1680   if (!sa)
1681     return;
1682   index[0] = 1;
1683   SafeArrayPutElement (sa, index, &value);
1684
1685 /* SafeArrayDestroyData shouldn't free pvData if FADF_STATIC is set. */
1686   sa->fFeatures |= FADF_STATIC;
1687   temp_pvData = sa->pvData;
1688   hres = SafeArrayDestroyData(sa);
1689   ok(hres == S_OK, "SADData FADF_STATIC failed, error code %x.\n",hres);
1690   ok(sa->pvData == temp_pvData, "SADData FADF_STATIC: pvData=%p, expected %p (fFeatures = %d).\n",
1691     sa->pvData, temp_pvData, sa->fFeatures);
1692   SafeArrayGetElement (sa, index, &value);
1693   ok(value == 0, "Data not cleared after SADData\n");
1694
1695 /* Clear FADF_STATIC, now really destroy the data. */
1696   sa->fFeatures ^= FADF_STATIC;
1697   hres = SafeArrayDestroyData(sa);
1698   ok(hres == S_OK, "SADData !FADF_STATIC failed, error code %x.\n",hres);
1699   ok(sa->pvData == NULL, "SADData !FADF_STATIC: pvData=%p, expected NULL.\n", sa->pvData);
1700
1701   hres = SafeArrayDestroy(sa);
1702   ok(hres == S_OK, "SAD failed, error code %x.\n", hres);
1703 }
1704
1705 START_TEST(safearray)
1706 {
1707     hOleaut32 = GetModuleHandleA("oleaut32.dll");
1708
1709     GETPTR(SafeArrayAllocDescriptorEx);
1710     GETPTR(SafeArrayCopyData);
1711     GETPTR(SafeArrayGetIID);
1712     GETPTR(SafeArraySetIID);
1713     GETPTR(SafeArrayGetVartype);
1714     GETPTR(SafeArrayCreateEx);
1715     GETPTR(SafeArrayCreateVector);
1716
1717     check_for_VT_INT_PTR();
1718     test_safearray();
1719     test_SafeArrayAllocDestroyDescriptor();
1720     test_SafeArrayCreateLockDestroy();
1721     test_VectorCreateLockDestroy();
1722     test_LockUnlock();
1723     test_SafeArrayChangeTypeEx();
1724     test_SafeArrayCopy();
1725     test_SafeArrayClear();
1726     test_SafeArrayCreateEx();
1727     test_SafeArrayCopyData();
1728     test_SafeArrayDestroyData();
1729     test_SafeArrayGetPutElement();
1730     test_SafeArrayGetPutElement_BSTR();
1731     test_SafeArrayGetPutElement_IUnknown();
1732     test_SafeArrayRedim_IUnknown();
1733     test_SafeArrayGetPutElement_VARIANT();
1734 }