42#ifndef FADF_CREATEVECTOR
55#define GETPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func)
70#define START_REF_COUNT 1
72#define RECORD_SIZE_FAIL 17
98 IRecordInfo_AddRef(iface);
124 ok(0,
"unexpected call\n");
146 ok(0,
"unexpected call\n");
152 ok(0,
"unexpected call\n");
171 ok(0,
"unexpected call\n");
176 LPCOLESTR szFieldName,
VARIANT *pvarField)
178 ok(0,
"unexpected call\n");
183 LPCOLESTR szFieldName,
VARIANT *pvarField,
PVOID *ppvDataCArray)
185 ok(0,
"unexpected call\n");
190 LPCOLESTR szFieldName,
VARIANT *pvarField)
192 ok(0,
"unexpected call\n");
199 ok(0,
"unexpected call\n");
206 ok(0,
"unexpected call\n");
212 ok(0,
"unexpected call\n");
218 ok(0,
"unexpected call\n");
225 ok(0,
"unexpected call\n");
231 ok(0,
"unexpected call\n");
318 trace(
"VT_INT_PTR is supported\n");
324 trace(
"VT_INT_PTR is not supported\n");
329#define VARTYPE_NOT_SUPPORTED 0
338{
VT_I2, 2, FADF_HAVEVARTYPE,0},
339{
VT_I4, 4, FADF_HAVEVARTYPE,0},
340{
VT_R4, 4, FADF_HAVEVARTYPE,0},
341{
VT_R8, 8, FADF_HAVEVARTYPE,0},
342{
VT_CY, 8, FADF_HAVEVARTYPE,0},
343{
VT_DATE, 8, FADF_HAVEVARTYPE,0},
344{
VT_BSTR,
sizeof(
BSTR), FADF_HAVEVARTYPE,FADF_BSTR},
345{
VT_DISPATCH,
sizeof(LPDISPATCH), FADF_HAVEIID, FADF_DISPATCH},
347{
VT_BOOL, 2, FADF_HAVEVARTYPE,0},
352{
VT_I1, 1, FADF_HAVEVARTYPE,0},
353{
VT_UI1, 1, FADF_HAVEVARTYPE,0},
354{
VT_UI2, 2, FADF_HAVEVARTYPE,0},
355{
VT_UI4, 4, FADF_HAVEVARTYPE,0},
358{
VT_INT,
sizeof(
INT), FADF_HAVEVARTYPE,0},
383 unsigned int i, diff;
392 unsigned char *ptr1, *ptr2;
395 ok(
hres ==
S_OK,
"SafeArrayDestroy( NULL) returned 0x%x\n",
hres);
400 ok(
NULL ==
a,
"SAC(-1,1,[1,0]) not failed?\n");
405 ok(
NULL !=
a,
"SAC(VT_I4,1,[0,0]) failed.\n");
408 ok(
hres ==
S_OK,
"SAGLB of 0 size dimensioned array failed with %x\n",
hres);
409 ok(
l == 42,
"SAGLB of 0 size dimensioned array failed to return 42, but returned %d\n",
l);
411 ok(
hres ==
S_OK,
"SAGUB of 0 size dimensioned array failed with %x\n",
hres);
412 ok(
l == 41,
"SAGUB of 0 size dimensioned array failed to return 41, but returned %d\n",
l);
415 ok(
hres ==
S_OK,
"SafeArrayAccessData of 0 size dimensioned array failed with %x\n",
hres);
420 ok(
hres ==
S_OK,
"SAR of a 0 elements dimension failed with hres %x\n",
hres);
424 "SAR to a 0 elements dimension failed with hres %x\n",
hres);
426 ok(
hres ==
S_OK,
"SAD of 0 dim array failed with hres %x\n",
hres);
429 a->rgsabound[0].cElements = 2;
430 a->rgsabound[0].lLbound = 1;
431 a->rgsabound[1].cElements = 4;
432 a->rgsabound[1].lLbound = 1;
435 ok(
hres ==
S_OK,
"SafeArrayAllocData failed with hres %x\n",
hres);
442 ok(ptr1 - ptr2 == 14,
"SAPOI got wrong ptr\n");
443 *(
WORD *)ptr1 = 0x55aa;
451 ok(*(
WORD *)ptr1 == 0x55aa,
"Data not preserved when resizing array\n");
459 "Expanded area not zero-initialized\n");
463 ok(*(
WORD *)ptr1 == 0x55aa ||
465 "Data not preserved when resizing array\n");
473 ok(
a !=
NULL,
"SAC(VT_INT32,2,...) with 0 element dim failed.\n");
480 ok(
a !=
NULL,
"SAC(VT_INT32,2,...) with 0 element dim failed.\n");
488 ok(
a !=
NULL,
"SAC(VT_INT32,2,...) failed.\n");
494 ok (
l == 1,
"SAGLB 1 returned %d instead of 1\n",
l);
497 ok (
l == 23,
"SAGLB 2 returned %d instead of 23\n",
l);
505 ok (
l == 42,
"SAGUB 1 returned %d instead of 42\n",
l);
508 ok (
l == 24,
"SAGUB 2 returned %d instead of 24\n",
l);
513 ok(
i == 2,
"getdims of 2 din array returned %d\n",
i);
548 ok(diff == 8,
"ptr difference is not 8, but %d (%p vs %p)\n", diff, ptr2, ptr1);
555 ok(diff == 176,
"ptr difference is not 176, but %d (%p vs %p)\n", diff, ptr2, ptr1);
562 ok(diff == 76,
"ptr difference is not 76, but %d (%p vs %p)\n", diff, ptr2, ptr1);
580 "SAC(%d,1,[1,0]), %p result %d, expected %d\n",
586 "SAC of %d returned feature flags %x, expected %x\n",
590 "SAGE for vt %d returned elemsize %d instead of expected %d\n",
596 if (pSafeArrayGetVartype)
598 hres = pSafeArrayGetVartype(
a, &
vt);
612 if (pSafeArrayGetVartype) {
613 hres = pSafeArrayGetVartype(
c, &
vt);
619 if (pSafeArrayCopyData) {
620 hres = pSafeArrayCopyData(
a,
c);
638 ok(
a !=
NULL,
"SAC failed.\n");
645 ok(
hres==
S_OK,
"CTE VT_ARRAY|VT_UI1 -> VT_BSTR failed with %x\n",
hres);
646 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));
647 ok(
V_BSTR(&
v)[0] == 0x6548,
"First letter are not 'He', but %x\n",
V_BSTR(&
v)[0]);
654 ok(
hres==
S_OK,
"CTE VT_BSTR -> VT_UI1|VT_ARRAY failed with %x\n",
hres);
661 ok(
a!=
NULL,
"SAC should not fail\n");
676 ok(
hres ==
S_OK,
"SAUD failed after lock/destroy test\n");
679 ok(
hres ==
S_OK,
"SAD failed after lock/destroy test\n");
683 ok(
a!=
NULL,
"SAC should not fail\n");
685 ok(
hres ==
S_OK,
"SADD with data in array failed with hres %x\n",
hres);
696 ok(
hres ==
S_OK,
"Failed to allocate array descriptor, hr %#x.\n",
hres);
697 ok((
a->fFeatures & FADF_HAVEIID) == 0,
"Unexpected features mask %#x.\n",
a->fFeatures);
704 if (!pSafeArrayAllocDescriptorEx)
710 ok(
hres ==
S_OK,
"SafeArrayAllocDescriptorEx gave hres 0x%x\n",
hres);
711 ok(
a->fFeatures ==
vttypes[
i].expflags,
"SAADE(%d) resulted with flags %x, expected %x\n",
vttypes[
i].vt,
a->fFeatures,
vttypes[
i].expflags);
712 if (
a->fFeatures & FADF_HAVEIID) {
732 if (
a->fFeatures & FADF_RECORD) {
735 if (
a->fFeatures & FADF_HAVEVARTYPE) {
739 hres = pSafeArrayGetVartype(
a, &
vt);
744 ok(
vt ==
VT_UNKNOWN,
"SAGVT of array with VT_DISPATCH returned not VT_UNKNOWN, but %d\n",
vt);
749 if (
a->fFeatures & FADF_HAVEIID) {
754 ok(
IsEqualGUID(&iid, &IID_IStorage),
"returned iid is not IID_IStorage\n");
785 for (
i = 5;
i <= 65535;
i += 30)
800 if (!pSafeArrayAllocDescriptorEx)
812 hres = pSafeArrayAllocDescriptorEx(-1, 1, &
sa);
815 sa->rgsabound[0].cElements = 0;
816 sa->rgsabound[0].lLbound = 1;
833 for (dimension = 0; dimension <
ARRAY_SIZE(sab); dimension++)
845 ok(!
sa,
"Max bounds didn't fail\n");
847 memset(sab, 0,
sizeof(sab));
851 for (dimension = 0; dimension <
ARRAY_SIZE(sab); dimension++)
852 sab[dimension].cElements = 8;
855 for (dimension = 1; dimension < 4; dimension++)
864 ok(
sa !=
NULL,
"VARTYPE %d (@%d dimensions) failed\n",
vt, dimension);
867 "VARTYPE %d (@%d dimensions) succeeded!\n",
vt, dimension);
872 "VARTYPE %d (@%d dimensions) cDims is %d, expected %d\n",
875 "VARTYPE %d (@%d dimensions) cbElements is %d, expected %d\n",
880 ok((
sa->fFeatures & FADF_HAVEIID) == 0,
881 "Non interface type should not have FADF_HAVEIID\n");
888 ok(
sa->fFeatures & FADF_HAVEVARTYPE,
889 "Non interface type should have FADF_HAVEVARTYPE\n");
890 if (pSafeArrayGetVartype)
892 hres = pSafeArrayGetVartype(
sa, &aVt);
894 "Non interface type %d: bad type %d, hres %x\n",
vt, aVt,
hres);
900 ok(
sa->fFeatures & FADF_HAVEIID,
"Interface type should have FADF_HAVEIID\n");
903 ok((
sa->fFeatures & FADF_HAVEVARTYPE) == 0,
904 "Interface type %d should not have FADF_HAVEVARTYPE\n",
vt);
908 ok(
hres ==
S_OK,
"Lock VARTYPE %d (@%d dimensions) failed; hres 0x%x\n",
923 ok(
hres ==
S_OK,
"Unlock VARTYPE %d (@%d dims) hres 0x%x\n",
927 ok(
hres ==
S_OK,
"destroy VARTYPE %d (@%d dims) hres 0x%x\n",
944 win_skip(
"SafeArrayCreateVector not supported\n");
948 ok(
sa !=
NULL,
"SACV with 0 elements failed.\n");
972 "VARTYPE %d (@%d elements) cbElements is %d, expected %d\n",
976 ok(
hres ==
S_OK,
"Lock VARTYPE %d (@%d elements) failed; hres 0x%x\n",
982 ok(
hres ==
S_OK,
"Unlock VARTYPE %d (@%d elements) failed; hres 0x%x\n",
986 ok(
hres ==
S_OK,
"destroy VARTYPE %d (@%d elements) failed; hres 0x%x\n",
1008 for (dimension = 0; dimension <
ARRAY_SIZE(sab); dimension++)
1017test_LockUnlock_Vector:
1024 bVector ?
"vector " :
"\n",
hres);
1029 bVector ?
"vector " :
"\n",
count,
hres);
1036 bVector ?
"vector " :
"\n",
count,
hres);
1048 goto test_LockUnlock_Vector;
1058 int value = 0, gotvalue, dimension;
1060 unsigned int x,
y,
z,
a;
1062 for (dimension = 0; dimension <
ARRAY_SIZE(sab); dimension++)
1064 sab[dimension].
lLbound = dimension * 2 + 1;
1065 sab[dimension].
cElements = dimension * 3 + 1;
1072 ok(
sa->cbElements ==
sizeof(
value),
"int size mismatch\n");
1140 ok(
hres ==
S_OK,
"Failed to put element at (%d,%d,%d,%d) hres 0x%x\n",
1162 gotvalue =
value / 3;
1164 ok(
hres ==
S_OK,
"Failed to get element at (%d,%d,%d,%d) hres 0x%x\n",
1167 ok(
value == gotvalue,
"Got value %d instead of %d at (%d,%d,%d,%d)\n",
1185 ok(
sa !=
NULL,
"failed to create array\n");
1186 ok(irec->
ref == 2,
"got %d\n", irec->
ref);
1202 ok(irec->
ref == 1,
"got %d\n", irec->
ref);
1213 const OLECHAR szTest[5] = {
'T',
'e',
's',
't',
'\0' };
1219 ok(
sa !=
NULL,
"BSTR test couldn't create array\n");
1223 ok(
sa->cbElements ==
sizeof(
BSTR),
"BSTR size mismatch\n");
1229 ok(
hres ==
S_OK,
"Failed to put bstr element hres 0x%x\n",
hres);
1232 ok(
hres ==
S_OK,
"Failed to get bstr element at hres 0x%x\n",
hres);
1281 ok(
sa !=
NULL,
"UNKNOWN test couldn't create array\n");
1285 ok(
sa->cbElements ==
sizeof(
LPUNKNOWN),
"LPUNKNOWN size mismatch\n");
1290 ok(
hres ==
S_OK,
"Failed to put bstr element hres 0x%x\n",
hres);
1291 ok(
xtunk.ref == 2,
"Failed to increment refcount of iface.\n");
1294 ok(
xtunk.ref == 3,
"Failed to increment refcount of iface.\n");
1295 ok(
hres ==
S_OK,
"Failed to get bstr element at hres 0x%x\n",
hres);
1297 ok(gotvalue == &
xtunk.IUnknown_iface,
"Got %p instead of %p\n", gotvalue, &
xtunk.IUnknown_iface);
1300 ok(
xtunk.ref == 2,
"Failed to decrement refcount of iface.\n");
1313 ok(
sa !=
NULL,
"UNKNOWN test couldn't create array\n");
1317 ok(
sa->cbElements ==
sizeof(
LPUNKNOWN),
"LPUNKNOWN size mismatch\n");
1322 ok(
hres ==
S_OK,
"Failed to put IUnknown element hres 0x%x\n",
hres);
1323 ok(
xtunk.ref == 2,
"Failed to increment refcount of iface.\n");
1327 ok(
xtunk.ref == 1,
"Failed to decrement refcount\n");
1343 ok(
sa !=
NULL,
"VARIANT test couldn't create array\n");
1347 ok(
sa->cbElements ==
sizeof(
VARIANT),
"VARIANT size mismatch\n");
1353 ok(
hres ==
S_OK,
"Failed to put Variant I4 element hres 0x%x\n",
hres);
1355 V_VT(&gotvalue) = 0xdead;
1357 ok(
hres ==
S_OK,
"Failed to get variant element at hres 0x%x\n",
hres);
1361 ok(
hres ==
S_OK,
"Failed to get variant element at hres 0x%x\n",
hres);
1377 int dimension,
size = 1,
i;
1379 if (!pSafeArrayCopyData)
1381 win_skip(
"SafeArrayCopyData not supported\n");
1385 for (dimension = 0; dimension <
ARRAY_SIZE(sab); dimension++)
1387 sab[dimension].
lLbound = dimension * 2 + 2;
1388 sab[dimension].
cElements = dimension * 3 + 1;
1393 ok(
sa !=
NULL,
"Copy test couldn't create array\n");
1395 ok(sacopy !=
NULL,
"Copy test couldn't create copy array\n");
1400 ok(
sa->cbElements ==
sizeof(
int),
"int size mismatch\n");
1403 for (dimension = 0; dimension <
size; dimension++)
1406 data[dimension] = dimension;
1409 hres = pSafeArrayCopyData(
sa, sacopy);
1417 hres = pSafeArrayCopyData(
NULL, sacopy);
1423 hres = pSafeArrayCopyData(
sa, sacopy);
1427 hres = pSafeArrayCopyData(
sa, sacopy);
1432 hres = pSafeArrayCopyData(
sa, sacopy);
1436 hres = pSafeArrayCopyData(
sa, sacopy);
1443 hres = pSafeArrayCopyData(
sa, sacopy);
1455 ok(sacopy !=
NULL,
"Copy test couldn't create copy array\n");
1466 ok(sacopy->
fFeatures == orig && orig == FADF_HAVEVARTYPE,
"got features 0x%04x\n", sacopy->
fFeatures);
1467 sa->fFeatures &= ~feature;
1481 "got 0x%08x\n",
sa->fFeatures);
1493 ok(sacopy !=
NULL,
"Copy test couldn't create copy array\n");
1512 win_skip(
"SafeArrayCreateEx not supported\n");
1516 for (dimension = 0; dimension <
ARRAY_SIZE(sab); dimension++)
1524 ok(
sa ==
NULL,
"CreateEx NULL bounds didn't fail\n");
1528 ok(
sa !=
NULL,
"CreateEx (ITypeInfo) failed\n");
1546 ok(
sa !=
NULL,
"CreateEx (NULL) failed\n");
1560 ok(
sa !=
NULL,
"CreateEx (NULL-Unk) failed\n");
1575 ok(
sa ==
NULL,
"CreateEx (NULL-Rec) succeeded\n");
1582 ok(
sa !=
NULL,
"CreateEx (Fail Size) failed\n");
1601 ok(
sa !=
NULL,
"CreateEx (Rec) failed\n");
1605 if (
sa && pSafeArrayGetRecordInfo)
1610 hres = pSafeArrayGetRecordInfo(
sa, &saRec);
1614 IRecordInfo_Release(saRec);
1658 ok(
sa !=
NULL,
"Create() failed.\n");
1667 ok(
V_ARRAY(&
v) ==
sa,
"VariantClear: Overwrote value\n");
1670 ok(
sa !=
NULL,
"Create() failed.\n");
1699 ok(
sa !=
NULL,
"Create() failed.\n");
1710 "VariantCopy: hres 0x%x, Type %d\n",
hres,
V_VT(&vDst));
1711 ok(
V_ARRAYREF(&vDst) == &
sa,
"VariantClear: Performed deep copy\n");
1719 "VariantCopy: hres 0x%x, Type %d\n",
hres,
V_VT(&vDst));
1720 ok(
V_ARRAY(&vDst) !=
sa,
"VariantClear: Performed shallow copy\n");
1728 ok(
hres ==
S_OK,
"SafeArrayAllocDescriptor failed with error 0x%08x\n",
hres);
1730 sa->cbElements = 16;
1732 ok(
hres ==
S_OK,
"SafeArrayCopy failed with error 0x%08x\n",
hres);
1733 ok(
sa != sa2,
"SafeArrayCopy performed shallow copy\n");
1740 sa2 = (
void*)0xdeadbeef;
1742 ok(
hres ==
S_OK,
"SafeArrayCopy failed with error 0x%08x\n",
hres);
1743 ok(!sa2,
"SafeArrayCopy didn't return NULL for output array\n");
1746 ok(
hres ==
S_OK,
"SafeArrayAllocDescriptor failed with error 0x%08x\n",
hres);
1748 sa2 = (
void*)0xdeadbeef;
1751 "SafeArrayCopy with empty array should have failed with error E_INVALIDARG instead of 0x%08x\n",
1753 ok(!sa2,
"SafeArrayCopy didn't return NULL for output array\n");
1762 ok(
hres ==
S_OK,
"SafeArrayAllocDescriptor failed with error 0x%08x\n",
hres);
1763 ok(
sa->fFeatures == 0,
"got src features 0x%04x\n",
sa->fFeatures);
1764 sa->cbElements = 16;
1776 sa->fFeatures &= ~feature;
1785 "got 0x%08x\n",
sa->fFeatures);
1796#define MKARRAY(low,num,typ) sab.lLbound = low; sab.cElements = num; \
1797 sa = SafeArrayCreate(typ, 1, &sab); ok(sa != NULL, "Create() failed.\n"); \
1799 V_VT(&v) = VT_ARRAY|typ; V_ARRAY(&v) = sa; VariantInit(&v2)
1801#define MKARRAYCONT(low,num,typ) sab.lLbound = low; sab.cElements = num; \
1802 sa = SafeArrayCreate(typ, 1, &sab); if (!sa) continue; \
1803 V_VT(&v) = VT_ARRAY|typ; V_ARRAY(&v) = sa; VariantInit(&v2)
1807 static const char *szHello =
"Hello World";
1819 ok(
hres ==
S_OK,
"CTE VT_ARRAY|VT_UI1 -> VT_BSTR failed with %x\n",
hres);
1822 ok(
V_VT(&
v2) ==
VT_BSTR,
"CTE VT_ARRAY|VT_UI1 -> VT_BSTR did not return VT_BSTR, but %d.\n",
V_VT(&
v2));
1823 ok(
strcmp((
char*)
V_BSTR(&
v2),szHello) == 0,
"Expected string '%s', got '%s'\n", szHello,
1834 ok(
sa !=
NULL,
"CreateVector() failed.\n");
1849 ok(
hres ==
S_OK,
"CTE VT_ARRAY|VT_UI1 -> VT_BSTR failed with %x\n",
hres);
1852 ok(
V_VT(&
v) ==
VT_BSTR,
"CTE VT_ARRAY|VT_UI1 -> VT_BSTR did not return VT_BSTR, but %d.\n",
V_VT(&
v));
1853 ok(
strcmp((
char*)
V_BSTR(&
v),szHello) == 0,
"Expected string '%s', got '%s'\n", szHello,
1895 ok(
sa !=
NULL,
"CreateVector() failed.\n");
1908 ok(
sa !=
NULL,
"CreateVector() failed.\n");
1914 ok(
hres ==
S_OK,
"CTE VT_ARRAY|VT_UI1->VT_ARRAY|VT_UI1 returned %x\n",
hres);
1936 int value = 0xdeadbeef;
1944 ok(
sa !=
NULL,
"Create() failed.\n");
1945 ok(
sa->fFeatures == FADF_HAVEVARTYPE,
"got 0x%x\n",
sa->fFeatures);
1951 features = (
sa->fFeatures |= FADF_STATIC);
1952 temp_pvData =
sa->pvData;
1954 ok(
hres ==
S_OK,
"SADData FADF_STATIC failed, error code %x.\n",
hres);
1955 ok(features ==
sa->fFeatures,
"got 0x%x\n",
sa->fFeatures);
1956 ok(
sa->pvData == temp_pvData,
"SADData FADF_STATIC: pvData=%p, expected %p (fFeatures = %d).\n",
1957 sa->pvData, temp_pvData,
sa->fFeatures);
1959 ok(
value == 0,
"Data not cleared after SADData\n");
1962 features = (
sa->fFeatures ^= FADF_STATIC);
1964 ok(
hres ==
S_OK,
"SADData !FADF_STATIC failed, error code %x.\n",
hres);
1965 ok(features ==
sa->fFeatures,
"got 0x%x\n",
sa->fFeatures);
1966 ok(
sa->pvData ==
NULL,
"SADData !FADF_STATIC: pvData=%p, expected NULL.\n",
sa->pvData);
1978 ok(
sa !=
NULL,
"Create() failed.\n");
1979 ok(
sa->fFeatures == FADF_HAVEVARTYPE,
"got 0x%x\n",
sa->fFeatures);
1981 features =
sa->fFeatures;
1984 ok(features ==
sa->fFeatures,
"got 0x%x\n",
sa->fFeatures);
1991 ok(
sa->fFeatures == 0,
"got 0x%x\n",
sa->fFeatures);
1995 ok(
sa->fFeatures == 0,
"got 0x%x\n",
sa->fFeatures);
2002 ok(
sa->fFeatures == 0,
"got 0x%x\n",
sa->fFeatures);
2006 ok(
sa->fFeatures == 0,
"got 0x%x\n",
sa->fFeatures);
2016 ok(
sa->pvData !=
NULL,
"got %p\n",
sa->pvData);
2020 ok(
sa->fFeatures == FADF_HAVEVARTYPE,
"got 0x%x\n",
sa->fFeatures);
2066 ok(*dwptr ==
VT_UI1,
"got %d\n", *dwptr);
2076 ok(
sa !=
NULL,
"failed to create array\n");
int strcmp(const char *String1, const char *String2)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
ACPI_SIZE strlen(const char *String)
static struct sockaddr_in sa
#define InterlockedIncrement
#define InterlockedDecrement
struct tagVARIANT VARIANT
#define GetProcAddress(x, y)
#define HeapFree(x, y, z)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
HRESULT WINAPI SafeArrayUnlock(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE vt, UINT cDims, SAFEARRAY **ppsaOut)
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayCopy(SAFEARRAY *psa, SAFEARRAY **ppsaOut)
UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
HRESULT WINAPI SafeArrayGetIID(SAFEARRAY *psa, GUID *pGuid)
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
UINT WINAPI SafeArrayGetElemsize(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY *psa, IRecordInfo **pRinfo)
static DWORD SAFEARRAY_GetVTSize(VARTYPE vt)
HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY *psa, LONG *rgIndices, void **ppvData)
SAFEARRAY *WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound, LPVOID pvExtra)
HRESULT WINAPI SafeArrayLock(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
static const USHORT ignored_copy_features
HRESULT WINAPI SafeArrayRedim(SAFEARRAY *psa, SAFEARRAYBOUND *psabound)
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
HRESULT WINAPI SafeArrayCopyData(SAFEARRAY *psaSource, SAFEARRAY *psaTarget)
HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
HRESULT WINAPI SafeArraySetIID(SAFEARRAY *psa, REFGUID guid)
HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY *psa, VARTYPE *pvt)
HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
GLint GLint GLint GLint GLint x
GLint GLint GLint GLint GLint GLint y
GLuint GLuint GLsizei count
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
GLuint GLuint GLsizei GLenum const GLvoid * indices
GLboolean GLboolean GLboolean b
GLboolean GLboolean GLboolean GLboolean a
GLfloat GLfloat GLfloat v2
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
#define memcpy(s1, s2, n)
static void test_SafeArrayGetPutElement_VARIANT(void)
static void test_SafeArrayDestroyData(void)
static ULONG WINAPI tunk_Release(IUnknown *punk)
static void test_LockUnlock(void)
static HRESULT WINAPI RecordInfo_RecordCreateCopy(IRecordInfo *iface, PVOID pvSource, PVOID *ppvDest)
static void test_SafeArrayClear(void)
const USHORT FADF_CREATEVECTOR
static ULONG WINAPI RecordInfo_Release(IRecordInfo *iface)
struct IRecordInfoImpl IRecordInfoImpl
static void test_SafeArrayCreateEx(void)
static IRecordInfoImpl * impl_from_IRecordInfo(IRecordInfo *iface)
static HRESULT WINAPI RecordInfo_RecordDestroy(IRecordInfo *iface, PVOID pvRecord)
static HRESULT WINAPI RecordInfo_GetFieldNames(IRecordInfo *iface, ULONG *pcNames, BSTR *rgBstrNames)
static struct xtunk_impl xtunk
static void test_safearray_layout(void)
static HRESULT WINAPI RecordInfo_GetTypeInfo(IRecordInfo *iface, ITypeInfo **ppTypeInfo)
static void test_SafeArrayCreateLockDestroy(void)
static void test_SafeArrayRedim_IUnknown(void)
static void test_SafeArrayGetPutElement_BSTR(void)
#define VARTYPE_NOT_SUPPORTED
static ULONG WINAPI RecordInfo_AddRef(IRecordInfo *iface)
static void test_SafeArrayGetPutElement_IUnknown(void)
static struct @1693 vttypes[]
static const IRecordInfoVtbl RecordInfoVtbl
static SAFEARRAY **static SAFEARRAY *static VARTYPE *static IRecordInfo **static SAFEARRAY *WINAPI * pSafeArrayCreateEx(VARTYPE, UINT, SAFEARRAYBOUND *, LPVOID)
static HRESULT WINAPI RecordInfo_RecordClear(IRecordInfo *iface, PVOID pvExisting)
static BOOL WINAPI RecordInfo_IsMatchingType(IRecordInfo *iface, IRecordInfo *info2)
static const IUnknownVtbl xtunk_vtbl
static void test_SafeArrayCopyData(void)
static HRESULT WINAPI RecordInfo_GetSize(IRecordInfo *iface, ULONG *size)
static HRESULT WINAPI RecordInfo_GetGuid(IRecordInfo *iface, GUID *pguid)
static PVOID WINAPI RecordInfo_RecordCreate(IRecordInfo *iface)
static HRESULT WINAPI RecordInfo_GetField(IRecordInfo *iface, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
static HRESULT WINAPI tunk_QueryInterface(IUnknown *punk, REFIID riid, void **x)
static HRESULT WINAPI RecordInfo_GetFieldNoCopy(IRecordInfo *iface, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField, PVOID *ppvDataCArray)
static void test_SafeArrayChangeTypeEx(void)
static HRESULT WINAPI RecordInfo_GetName(IRecordInfo *iface, BSTR *pbstrName)
#define MKARRAY(low, num, typ)
static ULONG WINAPI tunk_AddRef(IUnknown *punk)
static void test_SafeArrayAllocDestroyDescriptor(void)
static HRESULT WINAPI RecordInfo_QueryInterface(IRecordInfo *iface, REFIID riid, void **obj)
static void test_VectorCreateLockDestroy(void)
static HRESULT WINAPI RecordInfo_RecordInit(IRecordInfo *iface, PVOID pvNew)
static void test_safearray(void)
static HRESULT WINAPI RecordInfo_PutField(IRecordInfo *iface, ULONG wFlags, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
static HRESULT WINAPI RecordInfo_RecordCopy(IRecordInfo *iface, PVOID pvExisting, PVOID pvNew)
static IRecordInfoImpl * IRecordInfoImpl_Construct(void)
static void test_SafeArrayGetPutElement(void)
static HRESULT WINAPI RecordInfo_PutFieldNoCopy(IRecordInfo *iface, ULONG wFlags, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
static void check_for_VT_INT_PTR(void)
static SAFEARRAY *WINAPI * pSafeArrayCreateVector(VARTYPE, LONG, ULONG)
static void test_SafeArrayCopy(void)
INTERNETFEATURELIST feature
unsigned __int3264 UINT_PTR
BSTR WINAPI SysAllocString(LPCOLESTR str)
UINT WINAPI SysStringLen(BSTR str)
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
#define IsEqualGUID(rguid1, rguid2)
#define IsEqualIID(riid1, riid2)
static __inline const char * wine_dbgstr_guid(const GUID *id)
IRecordInfo IRecordInfo_iface
#define CONTAINING_RECORD(address, type, field)
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *pvargDest, VARIANTARG *pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt)
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
void WINAPI VariantInit(VARIANTARG *pVarg)
HRESULT WINAPI VariantCopy(VARIANTARG *pvargDest, VARIANTARG *pvargSrc)
_In_ DWORD _Out_ _In_ WORD wFlags
_In_ ULONG _In_opt_ PVOID pvData
#define DISP_E_ARRAYISLOCKED
#define DISP_E_BADVARTYPE
#define DISP_E_TYPEMISMATCH