| /* | |
| * 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(); | |
| } |