mirror of
https://github.com/reactos/reactos.git
synced 2024-10-30 11:35:58 +00:00
438 lines
14 KiB
C
438 lines
14 KiB
C
/*
|
|
* Copyright 2010 Piotr Caban for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#define COBJMACROS
|
|
#define CONST_VTABLE
|
|
#define NONAMELESSUNION
|
|
|
|
#include <stdio.h>
|
|
#include <wine/test.h>
|
|
|
|
#include "winbase.h"
|
|
#include "shlobj.h"
|
|
#include "initguid.h"
|
|
|
|
DEFINE_GUID(FMTID_Test,0x12345678,0x1234,0x1234,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12);
|
|
DEFINE_GUID(FMTID_NotExisting, 0x12345678,0x1234,0x1234,0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x13);
|
|
|
|
#define DEFINE_EXPECT(func) \
|
|
static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
|
|
|
|
#define SET_EXPECT(func) \
|
|
expect_ ## func = TRUE
|
|
|
|
#define CHECK_EXPECT2(func) \
|
|
do { \
|
|
ok(expect_ ##func, "unexpected call " #func "\n"); \
|
|
called_ ## func = TRUE; \
|
|
}while(0)
|
|
|
|
#define CHECK_EXPECT(func) \
|
|
do { \
|
|
CHECK_EXPECT2(func); \
|
|
expect_ ## func = FALSE; \
|
|
}while(0)
|
|
|
|
#define CHECK_CALLED(func) \
|
|
do { \
|
|
ok(called_ ## func, "expected " #func "\n"); \
|
|
expect_ ## func = called_ ## func = FALSE; \
|
|
}while(0)
|
|
|
|
DEFINE_EXPECT(Create);
|
|
DEFINE_EXPECT(Delete);
|
|
DEFINE_EXPECT(Open);
|
|
DEFINE_EXPECT(ReadMultiple);
|
|
DEFINE_EXPECT(ReadMultipleCodePage);
|
|
DEFINE_EXPECT(Release);
|
|
DEFINE_EXPECT(Stat);
|
|
DEFINE_EXPECT(WriteMultiple);
|
|
|
|
static HRESULT (WINAPI *pSHPropStgCreate)(IPropertySetStorage*, REFFMTID, const CLSID*,
|
|
DWORD, DWORD, DWORD, IPropertyStorage**, UINT*);
|
|
static HRESULT (WINAPI *pSHPropStgReadMultiple)(IPropertyStorage*, UINT,
|
|
ULONG, const PROPSPEC*, PROPVARIANT*);
|
|
static HRESULT (WINAPI *pSHPropStgWriteMultiple)(IPropertyStorage*, UINT*,
|
|
ULONG, const PROPSPEC*, PROPVARIANT*, PROPID);
|
|
|
|
static void init(void)
|
|
{
|
|
HMODULE hmod = GetModuleHandleA("shell32.dll");
|
|
|
|
pSHPropStgCreate = (void*)GetProcAddress(hmod, "SHPropStgCreate");
|
|
pSHPropStgReadMultiple = (void*)GetProcAddress(hmod, "SHPropStgReadMultiple");
|
|
pSHPropStgWriteMultiple = (void*)GetProcAddress(hmod, "SHPropStgWriteMultiple");
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_QueryInterface(IPropertyStorage *This,
|
|
REFIID riid, void **ppvObject)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static ULONG WINAPI PropertyStorage_AddRef(IPropertyStorage *This)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return 2;
|
|
}
|
|
|
|
static ULONG WINAPI PropertyStorage_Release(IPropertyStorage *This)
|
|
{
|
|
CHECK_EXPECT(Release);
|
|
return 1;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_ReadMultiple(IPropertyStorage *This, ULONG cpspec,
|
|
const PROPSPEC *rgpspec, PROPVARIANT *rgpropvar)
|
|
{
|
|
if(cpspec == 1) {
|
|
CHECK_EXPECT(ReadMultipleCodePage);
|
|
|
|
ok(rgpspec != NULL, "rgpspec = NULL\n");
|
|
ok(rgpropvar != NULL, "rgpropvar = NULL\n");
|
|
|
|
ok(rgpspec[0].ulKind == PRSPEC_PROPID, "rgpspec[0].ulKind = %d\n", rgpspec[0].ulKind);
|
|
ok(rgpspec[0].u.propid == PID_CODEPAGE, "rgpspec[0].propid = %d\n", rgpspec[0].u.propid);
|
|
|
|
rgpropvar[0].vt = VT_I2;
|
|
rgpropvar[0].u.iVal = 1234;
|
|
} else {
|
|
CHECK_EXPECT(ReadMultiple);
|
|
|
|
ok(cpspec == 10, "cpspec = %u\n", cpspec);
|
|
ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p\n", rgpspec);
|
|
ok(rgpropvar != NULL, "rgpropvar = NULL\n");
|
|
|
|
ok(rgpropvar[0].vt==0 || broken(rgpropvar[0].vt==VT_BSTR), "rgpropvar[0].vt = %d\n", rgpropvar[0].vt);
|
|
|
|
rgpropvar[0].vt = VT_BSTR;
|
|
rgpropvar[0].u.bstrVal = (void*)0xdeadbeef;
|
|
rgpropvar[1].vt = VT_LPSTR;
|
|
rgpropvar[1].u.pszVal = (void*)0xdeadbeef;
|
|
rgpropvar[2].vt = VT_BYREF|VT_I1;
|
|
rgpropvar[2].u.pcVal = (void*)0xdeadbeef;
|
|
rgpropvar[3].vt = VT_BYREF|VT_VARIANT;
|
|
rgpropvar[3].u.pvarVal = (void*)0xdeadbeef;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_WriteMultiple(IPropertyStorage *This, ULONG cpspec,
|
|
const PROPSPEC *rgpspec, const PROPVARIANT *rgpropvar,
|
|
PROPID propidNameFirst)
|
|
{
|
|
CHECK_EXPECT(WriteMultiple);
|
|
|
|
ok(cpspec == 20, "cpspec = %d\n", cpspec);
|
|
ok(rgpspec == (void*)0xdeadbeef, "rgpspec = %p\n", rgpspec);
|
|
ok(rgpropvar == (void*)0xdeadbeef, "rgpropvar = %p\n", rgpspec);
|
|
ok(propidNameFirst == PID_FIRST_USABLE, "propidNameFirst = %d\n", propidNameFirst);
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_DeleteMultiple(IPropertyStorage *This, ULONG cpspec,
|
|
const PROPSPEC *rgpspec)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_ReadPropertyNames(IPropertyStorage *This, ULONG cpropid,
|
|
const PROPID *rgpropid, LPOLESTR *rglpwstrName)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_WritePropertyNames(IPropertyStorage *This, ULONG cpropid,
|
|
const PROPID *rgpropid, const LPOLESTR *rglpwstrName)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_DeletePropertyNames(IPropertyStorage *This, ULONG cpropid,
|
|
const PROPID *rgpropid)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_Commit(IPropertyStorage *This, DWORD grfCommitFlags)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_Revert(IPropertyStorage *This)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_Enum(IPropertyStorage *This, IEnumSTATPROPSTG **ppenum)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_SetTimes(IPropertyStorage *This, const FILETIME *pctime,
|
|
const FILETIME *patime, const FILETIME *pmtime)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_SetClass(IPropertyStorage *This, REFCLSID clsid)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertyStorage_Stat(IPropertyStorage *This, STATPROPSETSTG *statpsstg)
|
|
{
|
|
CHECK_EXPECT(Stat);
|
|
|
|
memset(statpsstg, 0, sizeof(STATPROPSETSTG));
|
|
memcpy(&statpsstg->fmtid, &FMTID_Test, sizeof(FMTID));
|
|
statpsstg->grfFlags = PROPSETFLAG_ANSI;
|
|
return S_OK;
|
|
}
|
|
|
|
static IPropertyStorageVtbl PropertyStorageVtbl = {
|
|
PropertyStorage_QueryInterface,
|
|
PropertyStorage_AddRef,
|
|
PropertyStorage_Release,
|
|
PropertyStorage_ReadMultiple,
|
|
PropertyStorage_WriteMultiple,
|
|
PropertyStorage_DeleteMultiple,
|
|
PropertyStorage_ReadPropertyNames,
|
|
PropertyStorage_WritePropertyNames,
|
|
PropertyStorage_DeletePropertyNames,
|
|
PropertyStorage_Commit,
|
|
PropertyStorage_Revert,
|
|
PropertyStorage_Enum,
|
|
PropertyStorage_SetTimes,
|
|
PropertyStorage_SetClass,
|
|
PropertyStorage_Stat
|
|
};
|
|
|
|
static IPropertyStorage PropertyStorage = { &PropertyStorageVtbl };
|
|
|
|
static HRESULT WINAPI PropertySetStorage_QueryInterface(IPropertySetStorage *This,
|
|
REFIID riid, void **ppvObject)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static ULONG WINAPI PropertySetStorage_AddRef(IPropertySetStorage *This)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return 2;
|
|
}
|
|
|
|
static ULONG WINAPI PropertySetStorage_Release(IPropertySetStorage *This)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return 1;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertySetStorage_Create(IPropertySetStorage *This,
|
|
REFFMTID rfmtid, const CLSID *pclsid, DWORD grfFlags,
|
|
DWORD grfMode, IPropertyStorage **ppprstg)
|
|
{
|
|
CHECK_EXPECT(Create);
|
|
ok(IsEqualGUID(rfmtid, &FMTID_Test) || IsEqualGUID(rfmtid, &FMTID_NotExisting),
|
|
"Incorrect rfmtid value\n");
|
|
ok(pclsid == NULL, "pclsid != NULL\n");
|
|
ok(grfFlags == PROPSETFLAG_ANSI, "grfFlags = %x\n", grfFlags);
|
|
ok(grfMode == STGM_READ, "grfMode = %x\n", grfMode);
|
|
|
|
*ppprstg = &PropertyStorage;
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertySetStorage_Open(IPropertySetStorage *This,
|
|
REFFMTID rfmtid, DWORD grfMode, IPropertyStorage **ppprstg)
|
|
{
|
|
CHECK_EXPECT(Open);
|
|
|
|
if(IsEqualGUID(rfmtid, &FMTID_Test)) {
|
|
ok(grfMode == STGM_READ, "grfMode = %x\n", grfMode);
|
|
|
|
*ppprstg = &PropertyStorage;
|
|
return S_OK;
|
|
}
|
|
|
|
return STG_E_FILENOTFOUND;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertySetStorage_Delete(IPropertySetStorage *This,
|
|
REFFMTID rfmtid)
|
|
{
|
|
CHECK_EXPECT(Delete);
|
|
ok(IsEqualGUID(rfmtid, &FMTID_Test), "wrong rfmtid value\n");
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI PropertySetStorage_Enum(IPropertySetStorage *This,
|
|
IEnumSTATPROPSETSTG **ppenum)
|
|
{
|
|
ok(0, "unexpected call\n");
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static IPropertySetStorageVtbl PropertySetStorageVtbl = {
|
|
PropertySetStorage_QueryInterface,
|
|
PropertySetStorage_AddRef,
|
|
PropertySetStorage_Release,
|
|
PropertySetStorage_Create,
|
|
PropertySetStorage_Open,
|
|
PropertySetStorage_Delete,
|
|
PropertySetStorage_Enum
|
|
};
|
|
|
|
static IPropertySetStorage PropertySetStorage = { &PropertySetStorageVtbl };
|
|
|
|
static void test_SHPropStg_functions(void)
|
|
{
|
|
IPropertyStorage *property_storage;
|
|
UINT codepage;
|
|
PROPVARIANT read[10];
|
|
HRESULT hres;
|
|
|
|
if(!pSHPropStgCreate || !pSHPropStgReadMultiple || !pSHPropStgWriteMultiple) {
|
|
win_skip("SHPropStg* functions are missing\n");
|
|
return;
|
|
}
|
|
|
|
if(0) {
|
|
/* Crashes on Windows */
|
|
pSHPropStgCreate(NULL, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
|
|
STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
|
|
pSHPropStgCreate(&PropertySetStorage, NULL, NULL, PROPSETFLAG_DEFAULT,
|
|
STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
|
|
pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
|
|
STGM_READ, OPEN_EXISTING, NULL, &codepage);
|
|
}
|
|
|
|
SET_EXPECT(Open);
|
|
SET_EXPECT(ReadMultipleCodePage);
|
|
hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_DEFAULT,
|
|
STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
|
|
ok(codepage == 1234, "codepage = %d\n", codepage);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(Open);
|
|
CHECK_CALLED(ReadMultipleCodePage);
|
|
|
|
SET_EXPECT(Open);
|
|
hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_NotExisting, NULL,
|
|
PROPSETFLAG_DEFAULT, STGM_READ, OPEN_EXISTING, &property_storage, &codepage);
|
|
ok(hres == STG_E_FILENOTFOUND, "hres = %x\n", hres);
|
|
CHECK_CALLED(Open);
|
|
|
|
SET_EXPECT(Open);
|
|
SET_EXPECT(Release);
|
|
SET_EXPECT(Delete);
|
|
SET_EXPECT(Create);
|
|
SET_EXPECT(ReadMultipleCodePage);
|
|
hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, NULL, PROPSETFLAG_ANSI,
|
|
STGM_READ, CREATE_ALWAYS, &property_storage, &codepage);
|
|
ok(codepage == 1234, "codepage = %d\n", codepage);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(Open);
|
|
CHECK_CALLED(Release);
|
|
CHECK_CALLED(Delete);
|
|
CHECK_CALLED(Create);
|
|
CHECK_CALLED(ReadMultipleCodePage);
|
|
|
|
SET_EXPECT(Open);
|
|
SET_EXPECT(Create);
|
|
SET_EXPECT(ReadMultipleCodePage);
|
|
hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_NotExisting, NULL, PROPSETFLAG_ANSI,
|
|
STGM_READ, CREATE_ALWAYS, &property_storage, &codepage);
|
|
ok(codepage == 1234, "codepage = %d\n", codepage);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(Open);
|
|
CHECK_CALLED(Create);
|
|
CHECK_CALLED(ReadMultipleCodePage);
|
|
|
|
SET_EXPECT(Open);
|
|
hres = pSHPropStgCreate(&PropertySetStorage, &FMTID_Test, &FMTID_NotExisting,
|
|
PROPSETFLAG_DEFAULT, STGM_READ, OPEN_EXISTING, &property_storage, NULL);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(Open);
|
|
|
|
SET_EXPECT(Stat);
|
|
SET_EXPECT(ReadMultipleCodePage);
|
|
SET_EXPECT(WriteMultiple);
|
|
codepage = 0;
|
|
hres = pSHPropStgWriteMultiple(property_storage, &codepage, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
ok(codepage == 1234, "codepage = %d\n", codepage);
|
|
CHECK_CALLED(Stat);
|
|
CHECK_CALLED(ReadMultipleCodePage);
|
|
CHECK_CALLED(WriteMultiple);
|
|
|
|
SET_EXPECT(Stat);
|
|
SET_EXPECT(ReadMultipleCodePage);
|
|
SET_EXPECT(WriteMultiple);
|
|
hres = pSHPropStgWriteMultiple(property_storage, NULL, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(Stat);
|
|
CHECK_CALLED(ReadMultipleCodePage);
|
|
CHECK_CALLED(WriteMultiple);
|
|
|
|
SET_EXPECT(Stat);
|
|
SET_EXPECT(WriteMultiple);
|
|
codepage = 1000;
|
|
hres = pSHPropStgWriteMultiple(property_storage, &codepage, 20, (void*)0xdeadbeef, (void*)0xdeadbeef, PID_FIRST_USABLE);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
ok(codepage == 1000, "codepage = %d\n", codepage);
|
|
CHECK_CALLED(Stat);
|
|
CHECK_CALLED(WriteMultiple);
|
|
|
|
read[0].vt = VT_BSTR;
|
|
read[0].u.bstrVal = (void*)0xdeadbeef;
|
|
SET_EXPECT(ReadMultiple);
|
|
SET_EXPECT(ReadMultipleCodePage);
|
|
SET_EXPECT(Stat);
|
|
hres = pSHPropStgReadMultiple(property_storage, 0, 10, (void*)0xdeadbeef, read);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(ReadMultiple);
|
|
CHECK_CALLED(ReadMultipleCodePage);
|
|
CHECK_CALLED(Stat);
|
|
|
|
SET_EXPECT(ReadMultiple);
|
|
SET_EXPECT(Stat);
|
|
hres = pSHPropStgReadMultiple(property_storage, 1251, 10, (void*)0xdeadbeef, read);
|
|
ok(hres == S_OK, "hres = %x\n", hres);
|
|
CHECK_CALLED(ReadMultiple);
|
|
CHECK_CALLED(Stat);
|
|
}
|
|
|
|
START_TEST(shellole)
|
|
{
|
|
init();
|
|
|
|
test_SHPropStg_functions();
|
|
}
|