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