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