42 #ifndef FADF_CREATEVECTOR 55 #define GETPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func) 70 #define START_REF_COUNT 1 71 #define RECORD_SIZE 64 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++)
1017 test_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);
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;
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");
unsigned __int3264 UINT_PTR
INTERNETFEATURELIST feature
static void test_VectorCreateLockDestroy(void)
UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
GLuint GLuint GLsizei GLenum const GLvoid * indices
struct tagVARIANT VARIANT
HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY *psa, IRecordInfo **pRinfo)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
static HRESULT WINAPI RecordInfo_RecordCopy(IRecordInfo *iface, PVOID pvExisting, PVOID pvNew)
ACPI_SIZE strlen(const char *String)
HRESULT WINAPI SafeArrayCopyData(SAFEARRAY *psaSource, SAFEARRAY *psaTarget)
static void test_safearray_layout(void)
GLuint GLuint GLsizei count
static HRESULT WINAPI RecordInfo_PutFieldNoCopy(IRecordInfo *iface, ULONG wFlags, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
static BOOL WINAPI RecordInfo_IsMatchingType(IRecordInfo *iface, IRecordInfo *info2)
static HRESULT WINAPI RecordInfo_GetField(IRecordInfo *iface, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
#define VARTYPE_NOT_SUPPORTED
const char * wine_dbgstr_guid(const GUID *guid)
static struct @1684 vttypes[]
static SAFEARRAY *WINAPI * pSafeArrayCreateVector(VARTYPE, LONG, ULONG)
static void test_SafeArrayGetPutElement_BSTR(void)
GLint GLint GLint GLint GLint x
static HRESULT WINAPI RecordInfo_RecordInit(IRecordInfo *iface, PVOID pvNew)
HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
void WINAPI VariantInit(VARIANTARG *pVarg)
static HRESULT(WINAPI *pSafeArrayAllocDescriptorEx)(VARTYPE
#define DISP_E_ARRAYISLOCKED
static void test_SafeArrayCopy(void)
static const USHORT ignored_copy_features[]
static const IUnknownVtbl xtunk_vtbl
const USHORT FADF_CREATEVECTOR
static HRESULT WINAPI RecordInfo_GetFieldNoCopy(IRecordInfo *iface, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField, PVOID *ppvDataCArray)
static HRESULT WINAPI RecordInfo_RecordClear(IRecordInfo *iface, PVOID pvExisting)
static ULONG WINAPI RecordInfo_AddRef(IRecordInfo *iface)
HRESULT WINAPI SafeArraySetIID(SAFEARRAY *psa, REFGUID guid)
static ULONG WINAPI RecordInfo_Release(IRecordInfo *iface)
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
static HRESULT WINAPI tunk_QueryInterface(IUnknown *punk, REFIID riid, void **x)
static void test_SafeArrayAllocDestroyDescriptor(void)
static HRESULT WINAPI RecordInfo_PutField(IRecordInfo *iface, ULONG wFlags, PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY *psa, LONG *rgIndices, void **ppvData)
_In_ ULONG _In_opt_ PVOID pvData
BSTR WINAPI SysAllocString(LPCOLESTR str)
static IRecordInfoImpl * IRecordInfoImpl_Construct(void)
static void test_SafeArrayCopyData(void)
static void test_SafeArrayGetPutElement(void)
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
HRESULT WINAPI SafeArrayLock(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayUnlock(SAFEARRAY *psa)
static void test_SafeArrayChangeTypeEx(void)
GLboolean GLboolean GLboolean b
#define DISP_E_TYPEMISMATCH
static HRESULT WINAPI RecordInfo_GetSize(IRecordInfo *iface, ULONG *size)
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
static HRESULT WINAPI RecordInfo_GetName(IRecordInfo *iface, BSTR *pbstrName)
SAFEARRAY *WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound, LPVOID pvExtra)
HRESULT WINAPI SafeArrayCopy(SAFEARRAY *psa, SAFEARRAY **ppsaOut)
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
static IRecordInfoImpl * impl_from_IRecordInfo(IRecordInfo *iface)
HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
static HRESULT WINAPI RecordInfo_GetGuid(IRecordInfo *iface, GUID *pguid)
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
#define DISP_E_BADVARTYPE
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
#define InterlockedDecrement
static DWORD SAFEARRAY_GetVTSize(VARTYPE vt)
#define memcpy(s1, s2, n)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
static void test_LockUnlock(void)
UINT WINAPI SysStringLen(BSTR str)
GLsizei const GLfloat * value
HRESULT WINAPI SafeArrayRedim(SAFEARRAY *psa, SAFEARRAYBOUND *psabound)
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
static void test_SafeArrayDestroyData(void)
_In_ DWORD _Out_ _In_ WORD wFlags
GLfloat GLfloat GLfloat v2
HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY *psa)
static HRESULT WINAPI RecordInfo_RecordDestroy(IRecordInfo *iface, PVOID pvRecord)
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
HRESULT WINAPI SafeArrayGetIID(SAFEARRAY *psa, GUID *pGuid)
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
static struct xtunk_impl xtunk
#define InterlockedIncrement
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
static void test_SafeArrayCreateEx(void)
struct IRecordInfoImpl IRecordInfoImpl
UINT WINAPI SafeArrayGetElemsize(SAFEARRAY *psa)
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE vt, UINT cDims, SAFEARRAY **ppsaOut)
static void test_SafeArrayRedim_IUnknown(void)
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY *psa, VARTYPE *pvt)
GLint GLint GLint GLint GLint GLint y
#define MKARRAY(low, num, typ)
static void test_safearray(void)
static HRESULT WINAPI RecordInfo_QueryInterface(IRecordInfo *iface, REFIID riid, void **obj)
HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
static HRESULT WINAPI RecordInfo_GetTypeInfo(IRecordInfo *iface, ITypeInfo **ppTypeInfo)
int strcmp(const char *String1, const char *String2)
#define GetProcAddress(x, y)
static void test_SafeArrayGetPutElement_IUnknown(void)
GLboolean GLboolean GLboolean GLboolean a
static HRESULT WINAPI RecordInfo_RecordCreateCopy(IRecordInfo *iface, PVOID pvSource, PVOID *ppvDest)
HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
HRESULT WINAPI VariantCopy(VARIANTARG *pvargDest, VARIANTARG *pvargSrc)
static void check_for_VT_INT_PTR(void)
static void test_SafeArrayGetPutElement_VARIANT(void)
static SAFEARRAY **static SAFEARRAY *static VARTYPE *static IRecordInfo **static SAFEARRAY *WINAPI * pSafeArrayCreateEx(VARTYPE, UINT, SAFEARRAYBOUND *, LPVOID)
static void test_SafeArrayClear(void)
static ULONG WINAPI tunk_AddRef(IUnknown *punk)
#define HeapFree(x, y, z)
static struct sockaddr_in sa
#define IsEqualIID(riid1, riid2)
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
static PVOID WINAPI RecordInfo_RecordCreate(IRecordInfo *iface)
static void test_SafeArrayCreateLockDestroy(void)
IRecordInfo IRecordInfo_iface
static ULONG WINAPI tunk_Release(IUnknown *punk)
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *pvargDest, VARIANTARG *pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt)
static HRESULT WINAPI RecordInfo_GetFieldNames(IRecordInfo *iface, ULONG *pcNames, BSTR *rgBstrNames)
static const IRecordInfoVtbl RecordInfoVtbl