shell32/tests: Added SHPropStg* tests.

dlls/shell32/tests/Makefile.in

@@ -9,6 +9,7 @@ C_SRCS = \
 	generated.c \
 	progman_dde.c \
 	shelllink.c \
+	shellole.c \
 	shellpath.c \
 	shfldr_special.c \
 	shlexec.c \

dlls/shell32/tests/shellole.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();
+}