hres = IHTMLEventObj_get_x(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_x failed: %08x\n", hres);
- if(exl == -10) /* don't test the exact value */
- todo_wine ok_(__FILE__,line)(l > 0, "x = %d\n", l);
- else
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "x = %d, expected %d\n", l, exl);
}
hres = IHTMLEventObj_get_y(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_y failed: %08x\n", hres);
- if(exl == -10) /* don't test the exact value */
- todo_wine ok_(__FILE__,line)(l > 0, "y = %d\n", l);
- else
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "y = %d, expected %d\n", l, exl);
}
hres = IHTMLEventObj_get_clientX(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_clientX failed: %08x\n", hres);
- if(exl == -10) {/* don't test the exact value */
- if(xy_todo)
- todo_wine ok_(__FILE__,line)(l > 0, "clientX = %d\n", l);
- else
- ok_(__FILE__,line)(l > 0, "clientX = %d\n", l);
- }else {
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "clientX = %d, expected %d\n", l, exl);
- }
}
static void _test_event_clienty(unsigned line, IHTMLEventObj *event, LONG exl)
hres = IHTMLEventObj_get_clientY(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_clientY failed: %08x\n", hres);
- if(exl == -10) {/* don't test the exact value */
- if(xy_todo)
- todo_wine ok_(__FILE__,line)(l > 0, "clientY = %d\n", l);
- else
- ok_(__FILE__,line)(l > 0, "clientY = %d\n", l);
- }else {
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "clientY = %d, expected %d\n", l, exl);
- }
}
static void _test_event_offsetx(unsigned line, IHTMLEventObj *event, LONG exl)
hres = IHTMLEventObj_get_offsetX(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_offsetX failed: %08x\n", hres);
- if(exl == -10) /* don't test the exact value */
- todo_wine ok_(__FILE__,line)(l > 0, "offsetX = %d\n", l);
- else
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "offsetX = %d, expected %d\n", l, exl);
}
hres = IHTMLEventObj_get_offsetY(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_offsetY failed: %08x\n", hres);
- if(exl == -10) /* don't test the exact value */
- todo_wine ok_(__FILE__,line)(l > 0, "offsetY = %d\n", l);
- else
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "offsetY = %d, expected %d\n", l, exl);
}
hres = IHTMLEventObj_get_screenX(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_screenX failed: %08x\n", hres);
- if(exl == -10) { /* don't test the exact value */
- if(xy_todo)
- todo_wine ok_(__FILE__,line)(l > 0, "screenX = %d\n", l);
- else
- ok_(__FILE__,line)(l > 0, "screenX = %d\n", l);
- }else {
+ if(exl != -10) /* don't test the exact value */
ok_(__FILE__,line)(l == exl, "screenX = %d, expected %d\n", l, exl);
- }
}
static void _test_event_screeny(unsigned line, IHTMLEventObj *event, LONG exl)
hres = IHTMLEventObj_get_screenY(event, &l);
ok_(__FILE__,line)(hres == S_OK, "get_screenY failed: %08x\n", hres);
- if(exl == -10) { /* don't test the exact value */
- if(xy_todo)
- todo_wine ok_(__FILE__,line)(l > 0, "screenY = %d\n", l);
- else
- ok_(__FILE__,line)(l > 0, "screenY = %d\n", l);
- }else {
+ if(exl != -10) /* don't test the exact value for -10 */
ok_(__FILE__,line)(l == exl, "screenY = %d, expected %d\n", l, exl);
- }
}
static void _test_event_type(unsigned line, IHTMLEventObj *event, const char *exstr)
hres = IHTMLElement_put_onclick(div, v);
ok(hres == S_OK, "put_onclick failed: %08x\n", hres);
+ V_VT(&v) = VT_NULL;
+ hres = IHTMLElement_put_ondblclick(div, v);
+ ok(hres == S_OK, "put_ondblclick failed: %08x\n", hres);
+
V_VT(&v) = VT_EMPTY;
hres = IHTMLElement_get_onclick(div, &v);
ok(hres == S_OK, "get_onclick failed: %08x\n", hres);
#include "idispids.h"
#include "shlguid.h"
#include "perhist.h"
+#include "shobjidl.h"
#include "mshtml_test.h"
DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
DEFINE_EXPECT(TranslateUrl);
DEFINE_EXPECT(Advise_Close);
DEFINE_EXPECT(OnViewChange);
+DEFINE_EXPECT(EvaluateNewWindow);
static IUnknown *doc_unk;
static IMoniker *doc_mon;
static BOOL set_clientsite, container_locked, navigated_load;
static BOOL readystate_set_loading = FALSE, readystate_set_interactive = FALSE, load_from_stream;
static BOOL editmode = FALSE, show_failed;
-static BOOL inplace_deactivated;
+static BOOL inplace_deactivated, open_call;
static int stream_read, protocol_read;
static enum load_state_t {
LD_DOLOAD,
BSTR doc_url = (void*)0xdeadbeef;
HRESULT hres;
+ if(open_call)
+ return; /* FIXME */
+
hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&permon);
ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08x\n", hres);
if(FAILED(hres))
}else if(exurl) {
LPOLESTR url;
- ok(hres == S_OK, "GetCurrentMoniker failed: %08x\n", hres);
+ ok_(__FILE__,line)(hres == S_OK, "GetCurrentMoniker failed: %08x\n", hres);
hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
ok(hres == S_OK, "GetDisplayName failed: %08x\n", hres);
static IHlinkFrame HlinkFrame = { &HlinkFrameVtbl };
+static HRESULT WINAPI NewWindowManager_QueryInterface(INewWindowManager *iface, REFIID riid, void **ppv)
+{
+ ok(0, "unexpected call\n");
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI NewWindowManager_AddRef(INewWindowManager *iface)
+{
+ return 2;
+}
+
+static ULONG WINAPI NewWindowManager_Release(INewWindowManager *iface)
+{
+ return 1;
+}
+
+static HRESULT WINAPI NewWindowManager_EvaluateNewWindow(INewWindowManager *iface, LPCWSTR pszUrl,
+ LPCWSTR pszName, LPCWSTR pszUrlContext, LPCWSTR pszFeatures, BOOL fReplace, DWORD dwFlags,
+ DWORD dwUserActionTime)
+{
+ CHECK_EXPECT(EvaluateNewWindow);
+
+ ok(!strcmp_wa(pszUrl, "about:blank"), "pszUrl = %s\n", wine_dbgstr_w(pszUrl));
+ ok(!strcmp_wa(pszName, "test"), "pszName = %s\n", wine_dbgstr_w(pszName));
+ ok(!strcmp_wa(pszUrlContext, "about:blank"), "pszUrlContext = %s\n", wine_dbgstr_w(pszUrlContext));
+ ok(!pszFeatures, "pszFeatures = %s\n", wine_dbgstr_w(pszFeatures));
+ ok(!fReplace, "fReplace = %x\n", fReplace);
+ ok(dwFlags == NWMF_FIRST, "dwFlags = %x\n", dwFlags);
+ ok(!dwUserActionTime, "dwUserActionime = %d\n", dwUserActionTime);
+
+ return E_FAIL;
+}
+
+static const INewWindowManagerVtbl NewWindowManagerVtbl = {
+ NewWindowManager_QueryInterface,
+ NewWindowManager_AddRef,
+ NewWindowManager_Release,
+ NewWindowManager_EvaluateNewWindow
+};
+
+static INewWindowManager NewWindowManager = { &NewWindowManagerVtbl };
+
static HRESULT WINAPI PropertyNotifySink_QueryInterface(IPropertyNotifySink *iface,
REFIID riid, void**ppv)
{
static IOleContainer OleContainer = { &OleContainerVtbl };
+static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
+{
+ return QueryInterface(riid, ppv);
+}
+
+static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
+{
+ return 2;
+}
+
+static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
+{
+ return 1;
+}
+
+static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
+ IMoniker **ppmon)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
+{
+ CHECK_EXPECT(GetContainer);
+ ok(ppContainer != NULL, "ppContainer = NULL\n");
+ *ppContainer = &OleContainer;
+ return S_OK;
+}
+
+static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static const IOleClientSiteVtbl ClientSiteVtbl = {
+ ClientSite_QueryInterface,
+ ClientSite_AddRef,
+ ClientSite_Release,
+ ClientSite_SaveObject,
+ ClientSite_GetMoniker,
+ ClientSite_GetContainer,
+ ClientSite_ShowObject,
+ ClientSite_OnShowWindow,
+ ClientSite_RequestNewObjectLayout
+};
+
+static IOleClientSite ClientSite = { &ClientSiteVtbl };
+
static HRESULT WINAPI InPlaceFrame_QueryInterface(IOleInPlaceFrame *iface, REFIID riid, void **ppv)
{
static const GUID undocumented_frame_iid = {0xfbece6c9,0x48d7,0x4a37,{0x8f,0xe3,0x6a,0xd4,0x27,0x2f,0xdd,0xac}};
static HRESULT WINAPI InPlaceSiteWindowless_GetWindow(
IOleInPlaceSiteWindowless *iface, HWND *phwnd)
{
+ IOleClientSite *client_site;
+ IOleObject *ole_obj;
+ HRESULT hres;
+
CHECK_EXPECT2(GetWindow);
ok(phwnd != NULL, "phwnd = NULL\n");
*phwnd = container_hwnd;
+
+ hres = IUnknown_QueryInterface(doc_unk, &IID_IOleObject, (void**)&ole_obj);
+ ok(hres == S_OK, "Could not get IOleObject: %08x\n", hres);
+
+ hres = IOleObject_GetClientSite(ole_obj, &client_site);
+ IOleObject_Release(ole_obj);
+ ok(hres == S_OK, "GetClientSite failed: %08x\n", hres);
+ ok(client_site == &ClientSite, "client_site != ClientSite\n");
+ IOleClientSite_Release(client_site);
+
return S_OK;
}
static IOleInPlaceSiteWindowless InPlaceSiteWindowless = { &InPlaceSiteWindowlessVtbl };
-static HRESULT WINAPI ClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
-{
- return QueryInterface(riid, ppv);
-}
-
-static ULONG WINAPI ClientSite_AddRef(IOleClientSite *iface)
-{
- return 2;
-}
-
-static ULONG WINAPI ClientSite_Release(IOleClientSite *iface)
-{
- return 1;
-}
-
-static HRESULT WINAPI ClientSite_SaveObject(IOleClientSite *iface)
-{
- ok(0, "unexpected call\n");
- return E_NOTIMPL;
-}
-
-static HRESULT WINAPI ClientSite_GetMoniker(IOleClientSite *iface, DWORD dwAssign, DWORD dwWhichMoniker,
- IMoniker **ppmon)
-{
- ok(0, "unexpected call\n");
- return E_NOTIMPL;
-}
-
-static HRESULT WINAPI ClientSite_GetContainer(IOleClientSite *iface, IOleContainer **ppContainer)
-{
- CHECK_EXPECT(GetContainer);
- ok(ppContainer != NULL, "ppContainer = NULL\n");
- *ppContainer = &OleContainer;
- return S_OK;
-}
-
-static HRESULT WINAPI ClientSite_ShowObject(IOleClientSite *iface)
-{
- ok(0, "unexpected call\n");
- return E_NOTIMPL;
-}
-
-static HRESULT WINAPI ClientSite_OnShowWindow(IOleClientSite *iface, BOOL fShow)
-{
- ok(0, "unexpected call\n");
- return E_NOTIMPL;
-}
-
-static HRESULT WINAPI ClientSite_RequestNewObjectLayout(IOleClientSite *iface)
-{
- ok(0, "unexpected call\n");
- return E_NOTIMPL;
-}
-
-static const IOleClientSiteVtbl ClientSiteVtbl = {
- ClientSite_QueryInterface,
- ClientSite_AddRef,
- ClientSite_Release,
- ClientSite_SaveObject,
- ClientSite_GetMoniker,
- ClientSite_GetContainer,
- ClientSite_ShowObject,
- ClientSite_OnShowWindow,
- ClientSite_RequestNewObjectLayout
-};
-
-static IOleClientSite ClientSite = { &ClientSiteVtbl };
-
static HRESULT WINAPI DocumentSite_QueryInterface(IOleDocumentSite *iface, REFIID riid, void **ppv)
{
return QueryInterface(riid, ppv);
ok(V_BSTR(pvaIn) != NULL, "V_BSTR(pvaIn) = NULL\n");
test_readyState(NULL);
return S_OK;
+ case OLECMDID_UPDATETRAVELENTRY_DATARECOVERY:
+ return E_FAIL; /* FIXME */
default:
ok(0, "unexpected command %d\n", nCmdID);
return E_FAIL;
return S_OK;
}
+ if(IsEqualGUID(&SID_SNewWindowManager, guidService)) {
+ ok(IsEqualGUID(&IID_INewWindowManager, riid), "unexpected riid\n");
+ *ppv = &NewWindowManager;
+ return S_OK;
+ }
+
return E_NOINTERFACE;
}
"uninitialized"
};
+ if(open_call)
+ return; /* FIXME */
+
if(!unk)
unk = doc_unk;
test_download(DWL_VERBDONE);
}
+static void test_open_window(IHTMLDocument2 *doc)
+{
+ IHTMLWindow2 *window, *new_window;
+ BSTR name, url;
+ HRESULT hres;
+
+ hres = IHTMLDocument2_get_parentWindow(doc, &window);
+ ok(hres == S_OK, "get_parentWindow failed: %08x\n", hres);
+
+ url = a2bstr("about:blank");
+ name = a2bstr("test");
+ new_window = (void*)0xdeadbeef;
+
+ open_call = TRUE;
+
+ SET_EXPECT(TranslateUrl);
+ SET_EXPECT(EvaluateNewWindow);
+
+ hres = IHTMLWindow2_open(window, url, name, NULL, VARIANT_FALSE, &new_window);
+ todo_wine
+ ok(hres == S_OK, "open failed: %08x\n", hres);
+ todo_wine
+ ok(new_window == NULL, "new_window != NULL\n");
+
+ todo_wine
+ CHECK_CALLED(TranslateUrl);
+ todo_wine
+ CHECK_CALLED(EvaluateNewWindow);
+
+ open_call = FALSE;
+ SysFreeString(url);
+ SysFreeString(name);
+
+ IHTMLWindow2_Release(window);
+ SysFreeString(name);
+}
+
static void test_clear(IHTMLDocument2 *doc)
{
HRESULT hres;
hres = IUnknown_QueryInterface(doc, &IID_IStdMarshalInfo, (void**)&qi);
ok(hres == E_NOINTERFACE, "QueryInterface returned %08x, expected E_NOINTERFACE\n", hres);
ok(qi == NULL, "qi=%p, expected NULL\n", qi);
+
+ hres = IUnknown_QueryInterface(doc, &IID_IDispatch, (void**)&qi);
+ ok(hres == S_OK, "Could not get IDispatch interface: %08x\n", hres);
+ ok(qi != (IUnknown*)doc, "disp == doc\n");
+ IUnknown_Release(qi);
}
static void init_test(enum load_state_t ls) {
test_GetCurMoniker((IUnknown*)doc, http_mon, NULL);
test_put_href(doc);
+ test_open_window(doc);
test_InPlaceDeactivate(doc, TRUE);
test_Close(doc, FALSE);
win_skip("CLSID_AutoComplete is not registered\n");
return NULL;
}
- ok(SUCCEEDED(r), "no IID_IAutoComplete (0x%08x)\n", r);
+ ok(r == S_OK, "no IID_IAutoComplete (0x%08x)\n", r);
/* AutoComplete source */
r = CoCreateInstance(&CLSID_ACLMulti, NULL, CLSCTX_INPROC_SERVER,
win_skip("CLSID_ACLMulti is not registered\n");
return NULL;
}
- ok(SUCCEEDED(r), "no IID_IACList (0x%08x)\n", r);
+ ok(r == S_OK, "no IID_IACList (0x%08x)\n", r);
+if (0)
+{
+ /* crashes on native */
+ r = IAutoComplete_Init(ac, hEdit, NULL, NULL, NULL);
+}
/* bind to edit control */
r = IAutoComplete_Init(ac, hEdit, acSource, NULL, NULL);
- ok(SUCCEEDED(r), "Init failed (0x%08x)\n", r);
+ ok(r == S_OK, "Init failed (0x%08x)\n", r);
IUnknown_Release(acSource);
IAutoComplete* ac;
r = CoInitialize(NULL);
- ok(SUCCEEDED(r), "CoInitialize failed (0x%08x). Tests aborted.\n", r);
- if (FAILED(r))
+ ok(r == S_OK, "CoInitialize failed (0x%08x). Tests aborted.\n", r);
+ if (r != S_OK)
return;
createMainWnd();
* Test helper macros
*/
+#define TEST_TYPE_SIZE(type, size) C_ASSERT(sizeof(type) == size);
+
+#ifdef TYPE_ALIGNMENT
+# define TEST_TYPE_ALIGN(type, align) C_ASSERT(TYPE_ALIGNMENT(type) == align);
+#else
+# define TEST_TYPE_ALIGN(type, align)
+#endif
+
+#ifdef _TYPE_ALIGNMENT
+# define TEST_TARGET_ALIGN(type, align) C_ASSERT(_TYPE_ALIGNMENT(*(type)0) == align);
+# define TEST_FIELD_ALIGN(type, field, align) C_ASSERT(_TYPE_ALIGNMENT(((type*)0)->field) == align);
+#else
+# define TEST_TARGET_ALIGN(type, align)
+# define TEST_FIELD_ALIGN(type, field, align)
+#endif
+
+#define TEST_FIELD_OFFSET(type, field, offset) C_ASSERT(FIELD_OFFSET(type, field) == offset);
+
+#define TEST_TARGET_SIZE(type, size) TEST_TYPE_SIZE(*(type)0, size)
+#define TEST_FIELD_SIZE(type, field, size) TEST_TYPE_SIZE((((type*)0)->field), size)
+#define TEST_TYPE_SIGNED(type) C_ASSERT((type) -1 < 0);
+#define TEST_TYPE_UNSIGNED(type) C_ASSERT((type) -1 > 0);
+
+
#ifdef _WIN64
-# define TEST_TYPE_SIZE(type, size)
-# define TEST_TYPE_ALIGN(type, align)
-# define TEST_TARGET_ALIGN(type, align)
-# define TEST_FIELD_ALIGN(type, field, align)
-# define TEST_FIELD_OFFSET(type, field, offset)
+static void test_pack_BLOB(void)
+{
+ /* BLOB */
+ TEST_TYPE_SIZE (BLOB, 16)
+ TEST_TYPE_ALIGN (BLOB, 8)
+ TEST_FIELD_SIZE (BLOB, cbSize, 4)
+ TEST_FIELD_ALIGN (BLOB, cbSize, 4)
+ TEST_FIELD_OFFSET(BLOB, cbSize, 0)
+ TEST_FIELD_SIZE (BLOB, pBlobData, 8)
+ TEST_FIELD_ALIGN (BLOB, pBlobData, 8)
+ TEST_FIELD_OFFSET(BLOB, pBlobData, 8)
+}
+
+static void test_pack_BSTR(void)
+{
+ /* BSTR */
+ TEST_TYPE_SIZE (BSTR, 8)
+ TEST_TYPE_ALIGN (BSTR, 8)
+ TEST_TARGET_SIZE (BSTR, 2)
+ TEST_TARGET_ALIGN(BSTR, 2)
+}
+
+static void test_pack_BSTRBLOB(void)
+{
+ /* BSTRBLOB */
+ TEST_TYPE_SIZE (BSTRBLOB, 16)
+ TEST_TYPE_ALIGN (BSTRBLOB, 8)
+ TEST_FIELD_SIZE (BSTRBLOB, cbSize, 4)
+ TEST_FIELD_ALIGN (BSTRBLOB, cbSize, 4)
+ TEST_FIELD_OFFSET(BSTRBLOB, cbSize, 0)
+ TEST_FIELD_SIZE (BSTRBLOB, pData, 8)
+ TEST_FIELD_ALIGN (BSTRBLOB, pData, 8)
+ TEST_FIELD_OFFSET(BSTRBLOB, pData, 8)
+}
+
+static void test_pack_BYTE_BLOB(void)
+{
+ /* BYTE_BLOB */
+ TEST_TYPE_SIZE (BYTE_BLOB, 8)
+ TEST_TYPE_ALIGN (BYTE_BLOB, 4)
+ TEST_FIELD_SIZE (BYTE_BLOB, clSize, 4)
+ TEST_FIELD_ALIGN (BYTE_BLOB, clSize, 4)
+ TEST_FIELD_OFFSET(BYTE_BLOB, clSize, 0)
+ TEST_FIELD_SIZE (BYTE_BLOB, abData, 1)
+ TEST_FIELD_ALIGN (BYTE_BLOB, abData, 1)
+ TEST_FIELD_OFFSET(BYTE_BLOB, abData, 4)
+}
+
+static void test_pack_BYTE_SIZEDARR(void)
+{
+ /* BYTE_SIZEDARR */
+ TEST_TYPE_SIZE (BYTE_SIZEDARR, 16)
+ TEST_TYPE_ALIGN (BYTE_SIZEDARR, 8)
+ TEST_FIELD_SIZE (BYTE_SIZEDARR, clSize, 4)
+ TEST_FIELD_ALIGN (BYTE_SIZEDARR, clSize, 4)
+ TEST_FIELD_OFFSET(BYTE_SIZEDARR, clSize, 0)
+ TEST_FIELD_SIZE (BYTE_SIZEDARR, pData, 8)
+ TEST_FIELD_ALIGN (BYTE_SIZEDARR, pData, 8)
+ TEST_FIELD_OFFSET(BYTE_SIZEDARR, pData, 8)
+}
+
+static void test_pack_CLIPDATA(void)
+{
+ /* CLIPDATA */
+ TEST_TYPE_SIZE (CLIPDATA, 16)
+ TEST_TYPE_ALIGN (CLIPDATA, 8)
+ TEST_FIELD_SIZE (CLIPDATA, cbSize, 4)
+ TEST_FIELD_ALIGN (CLIPDATA, cbSize, 4)
+ TEST_FIELD_OFFSET(CLIPDATA, cbSize, 0)
+ TEST_FIELD_SIZE (CLIPDATA, ulClipFmt, 4)
+ TEST_FIELD_ALIGN (CLIPDATA, ulClipFmt, 4)
+ TEST_FIELD_OFFSET(CLIPDATA, ulClipFmt, 4)
+ TEST_FIELD_SIZE (CLIPDATA, pClipData, 8)
+ TEST_FIELD_ALIGN (CLIPDATA, pClipData, 8)
+ TEST_FIELD_OFFSET(CLIPDATA, pClipData, 8)
+}
+
+static void test_pack_CLIPFORMAT(void)
+{
+ /* CLIPFORMAT */
+ TEST_TYPE_SIZE (CLIPFORMAT, 2)
+ TEST_TYPE_ALIGN (CLIPFORMAT, 2)
+ TEST_TYPE_UNSIGNED(CLIPFORMAT)
+}
+
+static void test_pack_COAUTHIDENTITY(void)
+{
+ /* COAUTHIDENTITY */
+ TEST_TYPE_SIZE (COAUTHIDENTITY, 48)
+ TEST_TYPE_ALIGN (COAUTHIDENTITY, 8)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, User, 8)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, User, 8)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, User, 0)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, UserLength, 4)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, UserLength, 4)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, UserLength, 8)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, Domain, 8)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, Domain, 8)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, Domain, 16)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, DomainLength, 4)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, DomainLength, 4)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, DomainLength, 24)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, Password, 8)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, Password, 8)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, Password, 32)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, PasswordLength, 4)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, PasswordLength, 4)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, PasswordLength, 40)
+ TEST_FIELD_SIZE (COAUTHIDENTITY, Flags, 4)
+ TEST_FIELD_ALIGN (COAUTHIDENTITY, Flags, 4)
+ TEST_FIELD_OFFSET(COAUTHIDENTITY, Flags, 44)
+}
+
+static void test_pack_COAUTHINFO(void)
+{
+ /* COAUTHINFO */
+ TEST_TYPE_SIZE (COAUTHINFO, 40)
+ TEST_TYPE_ALIGN (COAUTHINFO, 8)
+ TEST_FIELD_SIZE (COAUTHINFO, dwAuthnSvc, 4)
+ TEST_FIELD_ALIGN (COAUTHINFO, dwAuthnSvc, 4)
+ TEST_FIELD_OFFSET(COAUTHINFO, dwAuthnSvc, 0)
+ TEST_FIELD_SIZE (COAUTHINFO, dwAuthzSvc, 4)
+ TEST_FIELD_ALIGN (COAUTHINFO, dwAuthzSvc, 4)
+ TEST_FIELD_OFFSET(COAUTHINFO, dwAuthzSvc, 4)
+ TEST_FIELD_SIZE (COAUTHINFO, pwszServerPrincName, 8)
+ TEST_FIELD_ALIGN (COAUTHINFO, pwszServerPrincName, 8)
+ TEST_FIELD_OFFSET(COAUTHINFO, pwszServerPrincName, 8)
+ TEST_FIELD_SIZE (COAUTHINFO, dwAuthnLevel, 4)
+ TEST_FIELD_ALIGN (COAUTHINFO, dwAuthnLevel, 4)
+ TEST_FIELD_OFFSET(COAUTHINFO, dwAuthnLevel, 16)
+ TEST_FIELD_SIZE (COAUTHINFO, dwImpersonationLevel, 4)
+ TEST_FIELD_ALIGN (COAUTHINFO, dwImpersonationLevel, 4)
+ TEST_FIELD_OFFSET(COAUTHINFO, dwImpersonationLevel, 20)
+ TEST_FIELD_SIZE (COAUTHINFO, pAuthIdentityData, 8)
+ TEST_FIELD_ALIGN (COAUTHINFO, pAuthIdentityData, 8)
+ TEST_FIELD_OFFSET(COAUTHINFO, pAuthIdentityData, 24)
+ TEST_FIELD_SIZE (COAUTHINFO, dwCapabilities, 4)
+ TEST_FIELD_ALIGN (COAUTHINFO, dwCapabilities, 4)
+ TEST_FIELD_OFFSET(COAUTHINFO, dwCapabilities, 32)
+}
+
+static void test_pack_DATE(void)
+{
+ /* DATE */
+ TEST_TYPE_SIZE (DATE, 8)
+ TEST_TYPE_ALIGN (DATE, 8)
+}
+
+static void test_pack_DOUBLE(void)
+{
+ /* DOUBLE */
+ TEST_TYPE_SIZE (DOUBLE, 8)
+ TEST_TYPE_ALIGN (DOUBLE, 8)
+}
+
+static void test_pack_DWORD_SIZEDARR(void)
+{
+ /* DWORD_SIZEDARR */
+ TEST_TYPE_SIZE (DWORD_SIZEDARR, 16)
+ TEST_TYPE_ALIGN (DWORD_SIZEDARR, 8)
+ TEST_FIELD_SIZE (DWORD_SIZEDARR, clSize, 4)
+ TEST_FIELD_ALIGN (DWORD_SIZEDARR, clSize, 4)
+ TEST_FIELD_OFFSET(DWORD_SIZEDARR, clSize, 0)
+ TEST_FIELD_SIZE (DWORD_SIZEDARR, pData, 8)
+ TEST_FIELD_ALIGN (DWORD_SIZEDARR, pData, 8)
+ TEST_FIELD_OFFSET(DWORD_SIZEDARR, pData, 8)
+}
+
+static void test_pack_FLAGGED_BYTE_BLOB(void)
+{
+ /* FLAGGED_BYTE_BLOB */
+ TEST_TYPE_SIZE (FLAGGED_BYTE_BLOB, 12)
+ TEST_TYPE_ALIGN (FLAGGED_BYTE_BLOB, 4)
+ TEST_FIELD_SIZE (FLAGGED_BYTE_BLOB, fFlags, 4)
+ TEST_FIELD_ALIGN (FLAGGED_BYTE_BLOB, fFlags, 4)
+ TEST_FIELD_OFFSET(FLAGGED_BYTE_BLOB, fFlags, 0)
+ TEST_FIELD_SIZE (FLAGGED_BYTE_BLOB, clSize, 4)
+ TEST_FIELD_ALIGN (FLAGGED_BYTE_BLOB, clSize, 4)
+ TEST_FIELD_OFFSET(FLAGGED_BYTE_BLOB, clSize, 4)
+ TEST_FIELD_SIZE (FLAGGED_BYTE_BLOB, abData, 1)
+ TEST_FIELD_ALIGN (FLAGGED_BYTE_BLOB, abData, 1)
+ TEST_FIELD_OFFSET(FLAGGED_BYTE_BLOB, abData, 8)
+}
+
+static void test_pack_FLAGGED_WORD_BLOB(void)
+{
+ /* FLAGGED_WORD_BLOB */
+ TEST_TYPE_SIZE (FLAGGED_WORD_BLOB, 12)
+ TEST_TYPE_ALIGN (FLAGGED_WORD_BLOB, 4)
+ TEST_FIELD_SIZE (FLAGGED_WORD_BLOB, fFlags, 4)
+ TEST_FIELD_ALIGN (FLAGGED_WORD_BLOB, fFlags, 4)
+ TEST_FIELD_OFFSET(FLAGGED_WORD_BLOB, fFlags, 0)
+ TEST_FIELD_SIZE (FLAGGED_WORD_BLOB, clSize, 4)
+ TEST_FIELD_ALIGN (FLAGGED_WORD_BLOB, clSize, 4)
+ TEST_FIELD_OFFSET(FLAGGED_WORD_BLOB, clSize, 4)
+ TEST_FIELD_SIZE (FLAGGED_WORD_BLOB, asData, 2)
+ TEST_FIELD_ALIGN (FLAGGED_WORD_BLOB, asData, 2)
+ TEST_FIELD_OFFSET(FLAGGED_WORD_BLOB, asData, 8)
+}
+
+static void test_pack_HMETAFILEPICT(void)
+{
+ /* HMETAFILEPICT */
+ TEST_TYPE_SIZE (HMETAFILEPICT, 8)
+ TEST_TYPE_ALIGN (HMETAFILEPICT, 8)
+}
+
+static void test_pack_HYPER_SIZEDARR(void)
+{
+ /* HYPER_SIZEDARR */
+ TEST_TYPE_SIZE (HYPER_SIZEDARR, 16)
+ TEST_TYPE_ALIGN (HYPER_SIZEDARR, 8)
+ TEST_FIELD_SIZE (HYPER_SIZEDARR, clSize, 4)
+ TEST_FIELD_ALIGN (HYPER_SIZEDARR, clSize, 4)
+ TEST_FIELD_OFFSET(HYPER_SIZEDARR, clSize, 0)
+ TEST_FIELD_SIZE (HYPER_SIZEDARR, pData, 8)
+ TEST_FIELD_ALIGN (HYPER_SIZEDARR, pData, 8)
+ TEST_FIELD_OFFSET(HYPER_SIZEDARR, pData, 8)
+}
+
+static void test_pack_LPBLOB(void)
+{
+ /* LPBLOB */
+ TEST_TYPE_SIZE (LPBLOB, 8)
+ TEST_TYPE_ALIGN (LPBLOB, 8)
+}
+
+static void test_pack_LPBSTR(void)
+{
+ /* LPBSTR */
+ TEST_TYPE_SIZE (LPBSTR, 8)
+ TEST_TYPE_ALIGN (LPBSTR, 8)
+ TEST_TARGET_SIZE (LPBSTR, 8)
+ TEST_TARGET_ALIGN(LPBSTR, 8)
+}
+
+static void test_pack_LPBSTRBLOB(void)
+{
+ /* LPBSTRBLOB */
+ TEST_TYPE_SIZE (LPBSTRBLOB, 8)
+ TEST_TYPE_ALIGN (LPBSTRBLOB, 8)
+}
+
+static void test_pack_LPCOLESTR(void)
+{
+ /* LPCOLESTR */
+ TEST_TYPE_SIZE (LPCOLESTR, 8)
+ TEST_TYPE_ALIGN (LPCOLESTR, 8)
+ TEST_TARGET_SIZE (LPCOLESTR, 2)
+ TEST_TARGET_ALIGN(LPCOLESTR, 2)
+}
+
+static void test_pack_LPCY(void)
+{
+ /* LPCY */
+ TEST_TYPE_SIZE (LPCY, 8)
+ TEST_TYPE_ALIGN (LPCY, 8)
+}
+
+static void test_pack_LPDECIMAL(void)
+{
+ /* LPDECIMAL */
+ TEST_TYPE_SIZE (LPDECIMAL, 8)
+ TEST_TYPE_ALIGN (LPDECIMAL, 8)
+}
+
+static void test_pack_LPOLESTR(void)
+{
+ /* LPOLESTR */
+ TEST_TYPE_SIZE (LPOLESTR, 8)
+ TEST_TYPE_ALIGN (LPOLESTR, 8)
+ TEST_TARGET_SIZE (LPOLESTR, 2)
+ TEST_TARGET_ALIGN(LPOLESTR, 2)
+}
+
+static void test_pack_OLECHAR(void)
+{
+ /* OLECHAR */
+ TEST_TYPE_SIZE (OLECHAR, 2)
+ TEST_TYPE_ALIGN (OLECHAR, 2)
+}
+
+static void test_pack_PROPID(void)
+{
+ /* PROPID */
+ TEST_TYPE_SIZE (PROPID, 4)
+ TEST_TYPE_ALIGN (PROPID, 4)
+}
+
+static void test_pack_RemHBITMAP(void)
+{
+ /* RemHBITMAP */
+ TEST_TYPE_SIZE (RemHBITMAP, 8)
+ TEST_TYPE_ALIGN (RemHBITMAP, 4)
+ TEST_FIELD_SIZE (RemHBITMAP, cbData, 4)
+ TEST_FIELD_ALIGN (RemHBITMAP, cbData, 4)
+ TEST_FIELD_OFFSET(RemHBITMAP, cbData, 0)
+ TEST_FIELD_SIZE (RemHBITMAP, data, 1)
+ TEST_FIELD_ALIGN (RemHBITMAP, data, 1)
+ TEST_FIELD_OFFSET(RemHBITMAP, data, 4)
+}
+
+static void test_pack_RemHENHMETAFILE(void)
+{
+ /* RemHENHMETAFILE */
+ TEST_TYPE_SIZE (RemHENHMETAFILE, 8)
+ TEST_TYPE_ALIGN (RemHENHMETAFILE, 4)
+ TEST_FIELD_SIZE (RemHENHMETAFILE, cbData, 4)
+ TEST_FIELD_ALIGN (RemHENHMETAFILE, cbData, 4)
+ TEST_FIELD_OFFSET(RemHENHMETAFILE, cbData, 0)
+ TEST_FIELD_SIZE (RemHENHMETAFILE, data, 1)
+ TEST_FIELD_ALIGN (RemHENHMETAFILE, data, 1)
+ TEST_FIELD_OFFSET(RemHENHMETAFILE, data, 4)
+}
+
+static void test_pack_RemHGLOBAL(void)
+{
+ /* RemHGLOBAL */
+ TEST_TYPE_SIZE (RemHGLOBAL, 12)
+ TEST_TYPE_ALIGN (RemHGLOBAL, 4)
+ TEST_FIELD_SIZE (RemHGLOBAL, fNullHGlobal, 4)
+ TEST_FIELD_ALIGN (RemHGLOBAL, fNullHGlobal, 4)
+ TEST_FIELD_OFFSET(RemHGLOBAL, fNullHGlobal, 0)
+ TEST_FIELD_SIZE (RemHGLOBAL, cbData, 4)
+ TEST_FIELD_ALIGN (RemHGLOBAL, cbData, 4)
+ TEST_FIELD_OFFSET(RemHGLOBAL, cbData, 4)
+ TEST_FIELD_SIZE (RemHGLOBAL, data, 1)
+ TEST_FIELD_ALIGN (RemHGLOBAL, data, 1)
+ TEST_FIELD_OFFSET(RemHGLOBAL, data, 8)
+}
+
+static void test_pack_RemHMETAFILEPICT(void)
+{
+ /* RemHMETAFILEPICT */
+ TEST_TYPE_SIZE (RemHMETAFILEPICT, 20)
+ TEST_TYPE_ALIGN (RemHMETAFILEPICT, 4)
+ TEST_FIELD_SIZE (RemHMETAFILEPICT, mm, 4)
+ TEST_FIELD_ALIGN (RemHMETAFILEPICT, mm, 4)
+ TEST_FIELD_OFFSET(RemHMETAFILEPICT, mm, 0)
+ TEST_FIELD_SIZE (RemHMETAFILEPICT, xExt, 4)
+ TEST_FIELD_ALIGN (RemHMETAFILEPICT, xExt, 4)
+ TEST_FIELD_OFFSET(RemHMETAFILEPICT, xExt, 4)
+ TEST_FIELD_SIZE (RemHMETAFILEPICT, yExt, 4)
+ TEST_FIELD_ALIGN (RemHMETAFILEPICT, yExt, 4)
+ TEST_FIELD_OFFSET(RemHMETAFILEPICT, yExt, 8)
+ TEST_FIELD_SIZE (RemHMETAFILEPICT, cbData, 4)
+ TEST_FIELD_ALIGN (RemHMETAFILEPICT, cbData, 4)
+ TEST_FIELD_OFFSET(RemHMETAFILEPICT, cbData, 12)
+ TEST_FIELD_SIZE (RemHMETAFILEPICT, data, 1)
+ TEST_FIELD_ALIGN (RemHMETAFILEPICT, data, 1)
+ TEST_FIELD_OFFSET(RemHMETAFILEPICT, data, 16)
+}
+
+static void test_pack_RemHPALETTE(void)
+{
+ /* RemHPALETTE */
+ TEST_TYPE_SIZE (RemHPALETTE, 8)
+ TEST_TYPE_ALIGN (RemHPALETTE, 4)
+ TEST_FIELD_SIZE (RemHPALETTE, cbData, 4)
+ TEST_FIELD_ALIGN (RemHPALETTE, cbData, 4)
+ TEST_FIELD_OFFSET(RemHPALETTE, cbData, 0)
+ TEST_FIELD_SIZE (RemHPALETTE, data, 1)
+ TEST_FIELD_ALIGN (RemHPALETTE, data, 1)
+ TEST_FIELD_OFFSET(RemHPALETTE, data, 4)
+}
+
+static void test_pack_SCODE(void)
+{
+ /* SCODE */
+ TEST_TYPE_SIZE (SCODE, 4)
+ TEST_TYPE_ALIGN (SCODE, 4)
+}
+
+static void test_pack_UP_BYTE_BLOB(void)
+{
+ /* UP_BYTE_BLOB */
+ TEST_TYPE_SIZE (UP_BYTE_BLOB, 8)
+ TEST_TYPE_ALIGN (UP_BYTE_BLOB, 8)
+ TEST_TARGET_SIZE (UP_BYTE_BLOB, 8)
+ TEST_TARGET_ALIGN(UP_BYTE_BLOB, 4)
+}
+
+static void test_pack_UP_FLAGGED_BYTE_BLOB(void)
+{
+ /* UP_FLAGGED_BYTE_BLOB */
+ TEST_TYPE_SIZE (UP_FLAGGED_BYTE_BLOB, 8)
+ TEST_TYPE_ALIGN (UP_FLAGGED_BYTE_BLOB, 8)
+ TEST_TARGET_SIZE (UP_FLAGGED_BYTE_BLOB, 12)
+ TEST_TARGET_ALIGN(UP_FLAGGED_BYTE_BLOB, 4)
+}
+
+static void test_pack_UP_FLAGGED_WORD_BLOB(void)
+{
+ /* UP_FLAGGED_WORD_BLOB */
+ TEST_TYPE_SIZE (UP_FLAGGED_WORD_BLOB, 8)
+ TEST_TYPE_ALIGN (UP_FLAGGED_WORD_BLOB, 8)
+ TEST_TARGET_SIZE (UP_FLAGGED_WORD_BLOB, 12)
+ TEST_TARGET_ALIGN(UP_FLAGGED_WORD_BLOB, 4)
+}
+
+static void test_pack_VARIANT_BOOL(void)
+{
+ /* VARIANT_BOOL */
+ TEST_TYPE_SIZE (VARIANT_BOOL, 2)
+ TEST_TYPE_ALIGN (VARIANT_BOOL, 2)
+ TEST_TYPE_SIGNED(VARIANT_BOOL)
+}
+
+static void test_pack_VARTYPE(void)
+{
+ /* VARTYPE */
+ TEST_TYPE_SIZE (VARTYPE, 2)
+ TEST_TYPE_ALIGN (VARTYPE, 2)
+ TEST_TYPE_UNSIGNED(VARTYPE)
+}
+
+static void test_pack_WORD_SIZEDARR(void)
+{
+ /* WORD_SIZEDARR */
+ TEST_TYPE_SIZE (WORD_SIZEDARR, 16)
+ TEST_TYPE_ALIGN (WORD_SIZEDARR, 8)
+ TEST_FIELD_SIZE (WORD_SIZEDARR, clSize, 4)
+ TEST_FIELD_ALIGN (WORD_SIZEDARR, clSize, 4)
+ TEST_FIELD_OFFSET(WORD_SIZEDARR, clSize, 0)
+ TEST_FIELD_SIZE (WORD_SIZEDARR, pData, 8)
+ TEST_FIELD_ALIGN (WORD_SIZEDARR, pData, 8)
+ TEST_FIELD_OFFSET(WORD_SIZEDARR, pData, 8)
+}
+
+static void test_pack_remoteMETAFILEPICT(void)
+{
+ /* remoteMETAFILEPICT */
+ TEST_TYPE_SIZE (remoteMETAFILEPICT, 24)
+ TEST_TYPE_ALIGN (remoteMETAFILEPICT, 8)
+ TEST_FIELD_SIZE (remoteMETAFILEPICT, mm, 4)
+ TEST_FIELD_ALIGN (remoteMETAFILEPICT, mm, 4)
+ TEST_FIELD_OFFSET(remoteMETAFILEPICT, mm, 0)
+ TEST_FIELD_SIZE (remoteMETAFILEPICT, xExt, 4)
+ TEST_FIELD_ALIGN (remoteMETAFILEPICT, xExt, 4)
+ TEST_FIELD_OFFSET(remoteMETAFILEPICT, xExt, 4)
+ TEST_FIELD_SIZE (remoteMETAFILEPICT, yExt, 4)
+ TEST_FIELD_ALIGN (remoteMETAFILEPICT, yExt, 4)
+ TEST_FIELD_OFFSET(remoteMETAFILEPICT, yExt, 8)
+ TEST_FIELD_SIZE (remoteMETAFILEPICT, hMF, 8)
+ TEST_FIELD_ALIGN (remoteMETAFILEPICT, hMF, 8)
+ TEST_FIELD_OFFSET(remoteMETAFILEPICT, hMF, 16)
+}
+
+static void test_pack_userBITMAP(void)
+{
+ /* userBITMAP */
+ TEST_TYPE_SIZE (userBITMAP, 28)
+ TEST_TYPE_ALIGN (userBITMAP, 4)
+ TEST_FIELD_SIZE (userBITMAP, bmType, 4)
+ TEST_FIELD_ALIGN (userBITMAP, bmType, 4)
+ TEST_FIELD_OFFSET(userBITMAP, bmType, 0)
+ TEST_FIELD_SIZE (userBITMAP, bmWidth, 4)
+ TEST_FIELD_ALIGN (userBITMAP, bmWidth, 4)
+ TEST_FIELD_OFFSET(userBITMAP, bmWidth, 4)
+ TEST_FIELD_SIZE (userBITMAP, bmHeight, 4)
+ TEST_FIELD_ALIGN (userBITMAP, bmHeight, 4)
+ TEST_FIELD_OFFSET(userBITMAP, bmHeight, 8)
+ TEST_FIELD_SIZE (userBITMAP, bmWidthBytes, 4)
+ TEST_FIELD_ALIGN (userBITMAP, bmWidthBytes, 4)
+ TEST_FIELD_OFFSET(userBITMAP, bmWidthBytes, 12)
+ TEST_FIELD_SIZE (userBITMAP, bmPlanes, 2)
+ TEST_FIELD_ALIGN (userBITMAP, bmPlanes, 2)
+ TEST_FIELD_OFFSET(userBITMAP, bmPlanes, 16)
+ TEST_FIELD_SIZE (userBITMAP, bmBitsPixel, 2)
+ TEST_FIELD_ALIGN (userBITMAP, bmBitsPixel, 2)
+ TEST_FIELD_OFFSET(userBITMAP, bmBitsPixel, 18)
+ TEST_FIELD_SIZE (userBITMAP, cbSize, 4)
+ TEST_FIELD_ALIGN (userBITMAP, cbSize, 4)
+ TEST_FIELD_OFFSET(userBITMAP, cbSize, 20)
+ TEST_FIELD_SIZE (userBITMAP, pBuffer, 1)
+ TEST_FIELD_ALIGN (userBITMAP, pBuffer, 1)
+ TEST_FIELD_OFFSET(userBITMAP, pBuffer, 24)
+}
+
+static void test_pack_userCLIPFORMAT(void)
+{
+ /* userCLIPFORMAT */
+ TEST_FIELD_SIZE (userCLIPFORMAT, fContext, 4)
+ TEST_FIELD_ALIGN (userCLIPFORMAT, fContext, 4)
+ TEST_FIELD_OFFSET(userCLIPFORMAT, fContext, 0)
+}
+
+static void test_pack_userHBITMAP(void)
+{
+ /* userHBITMAP */
+ TEST_FIELD_SIZE (userHBITMAP, fContext, 4)
+ TEST_FIELD_ALIGN (userHBITMAP, fContext, 4)
+ TEST_FIELD_OFFSET(userHBITMAP, fContext, 0)
+}
+
+static void test_pack_userHENHMETAFILE(void)
+{
+ /* userHENHMETAFILE */
+ TEST_FIELD_SIZE (userHENHMETAFILE, fContext, 4)
+ TEST_FIELD_ALIGN (userHENHMETAFILE, fContext, 4)
+ TEST_FIELD_OFFSET(userHENHMETAFILE, fContext, 0)
+}
+
+static void test_pack_userHGLOBAL(void)
+{
+ /* userHGLOBAL */
+ TEST_FIELD_SIZE (userHGLOBAL, fContext, 4)
+ TEST_FIELD_ALIGN (userHGLOBAL, fContext, 4)
+ TEST_FIELD_OFFSET(userHGLOBAL, fContext, 0)
+}
+
+static void test_pack_userHMETAFILE(void)
+{
+ /* userHMETAFILE */
+ TEST_FIELD_SIZE (userHMETAFILE, fContext, 4)
+ TEST_FIELD_ALIGN (userHMETAFILE, fContext, 4)
+ TEST_FIELD_OFFSET(userHMETAFILE, fContext, 0)
+}
+
+static void test_pack_userHMETAFILEPICT(void)
+{
+ /* userHMETAFILEPICT */
+ TEST_FIELD_SIZE (userHMETAFILEPICT, fContext, 4)
+ TEST_FIELD_ALIGN (userHMETAFILEPICT, fContext, 4)
+ TEST_FIELD_OFFSET(userHMETAFILEPICT, fContext, 0)
+}
+
+static void test_pack_userHPALETTE(void)
+{
+ /* userHPALETTE */
+ TEST_FIELD_SIZE (userHPALETTE, fContext, 4)
+ TEST_FIELD_ALIGN (userHPALETTE, fContext, 4)
+ TEST_FIELD_OFFSET(userHPALETTE, fContext, 0)
+}
+
+static void test_pack_wireBSTR(void)
+{
+ /* wireBSTR */
+ TEST_TYPE_SIZE (wireBSTR, 8)
+ TEST_TYPE_ALIGN (wireBSTR, 8)
+ TEST_TARGET_SIZE (wireBSTR, 12)
+ TEST_TARGET_ALIGN(wireBSTR, 4)
+}
+
+static void test_pack_wireCLIPFORMAT(void)
+{
+ /* wireCLIPFORMAT */
+ TEST_TYPE_SIZE (wireCLIPFORMAT, 8)
+ TEST_TYPE_ALIGN (wireCLIPFORMAT, 8)
+}
+
+static void test_pack_wireHBITMAP(void)
+{
+ /* wireHBITMAP */
+ TEST_TYPE_SIZE (wireHBITMAP, 8)
+ TEST_TYPE_ALIGN (wireHBITMAP, 8)
+}
+
+static void test_pack_wireHENHMETAFILE(void)
+{
+ /* wireHENHMETAFILE */
+ TEST_TYPE_SIZE (wireHENHMETAFILE, 8)
+ TEST_TYPE_ALIGN (wireHENHMETAFILE, 8)
+}
+
+static void test_pack_wireHGLOBAL(void)
+{
+ /* wireHGLOBAL */
+ TEST_TYPE_SIZE (wireHGLOBAL, 8)
+ TEST_TYPE_ALIGN (wireHGLOBAL, 8)
+}
+
+static void test_pack_wireHMETAFILE(void)
+{
+ /* wireHMETAFILE */
+ TEST_TYPE_SIZE (wireHMETAFILE, 8)
+ TEST_TYPE_ALIGN (wireHMETAFILE, 8)
+}
+
+static void test_pack_wireHMETAFILEPICT(void)
+{
+ /* wireHMETAFILEPICT */
+ TEST_TYPE_SIZE (wireHMETAFILEPICT, 8)
+ TEST_TYPE_ALIGN (wireHMETAFILEPICT, 8)
+}
+
+static void test_pack_wireHPALETTE(void)
+{
+ /* wireHPALETTE */
+ TEST_TYPE_SIZE (wireHPALETTE, 8)
+ TEST_TYPE_ALIGN (wireHPALETTE, 8)
+}
+
+static void test_pack_CLSID(void)
+{
+ /* CLSID */
+ TEST_TYPE_SIZE (CLSID, 16)
+ TEST_TYPE_ALIGN (CLSID, 4)
+}
+
+static void test_pack_FMTID(void)
+{
+ /* FMTID */
+ TEST_TYPE_SIZE (FMTID, 16)
+ TEST_TYPE_ALIGN (FMTID, 4)
+}
+
+static void test_pack_IID(void)
+{
+ /* IID */
+ TEST_TYPE_SIZE (IID, 16)
+ TEST_TYPE_ALIGN (IID, 4)
+}
+
+static void test_pack_APPBARDATA(void)
+{
+ /* APPBARDATA */
+ TEST_TYPE_SIZE (APPBARDATA, 48)
+ TEST_TYPE_ALIGN (APPBARDATA, 8)
+ TEST_FIELD_SIZE (APPBARDATA, cbSize, 4)
+ TEST_FIELD_ALIGN (APPBARDATA, cbSize, 4)
+ TEST_FIELD_OFFSET(APPBARDATA, cbSize, 0)
+ TEST_FIELD_SIZE (APPBARDATA, hWnd, 8)
+ TEST_FIELD_ALIGN (APPBARDATA, hWnd, 8)
+ TEST_FIELD_OFFSET(APPBARDATA, hWnd, 8)
+ TEST_FIELD_SIZE (APPBARDATA, uCallbackMessage, 4)
+ TEST_FIELD_ALIGN (APPBARDATA, uCallbackMessage, 4)
+ TEST_FIELD_OFFSET(APPBARDATA, uCallbackMessage, 16)
+ TEST_FIELD_SIZE (APPBARDATA, uEdge, 4)
+ TEST_FIELD_ALIGN (APPBARDATA, uEdge, 4)
+ TEST_FIELD_OFFSET(APPBARDATA, uEdge, 20)
+ TEST_FIELD_SIZE (APPBARDATA, rc, 16)
+ TEST_FIELD_ALIGN (APPBARDATA, rc, 4)
+ TEST_FIELD_OFFSET(APPBARDATA, rc, 24)
+ TEST_FIELD_SIZE (APPBARDATA, lParam, 8)
+ TEST_FIELD_ALIGN (APPBARDATA, lParam, 8)
+ TEST_FIELD_OFFSET(APPBARDATA, lParam, 40)
+}
+
+static void test_pack_DRAGINFOA(void)
+{
+ /* DRAGINFOA */
+ TEST_TYPE_SIZE (DRAGINFOA, 32)
+ TEST_TYPE_ALIGN (DRAGINFOA, 8)
+ TEST_FIELD_SIZE (DRAGINFOA, uSize, 4)
+ TEST_FIELD_ALIGN (DRAGINFOA, uSize, 4)
+ TEST_FIELD_OFFSET(DRAGINFOA, uSize, 0)
+ TEST_FIELD_SIZE (DRAGINFOA, pt, 8)
+ TEST_FIELD_ALIGN (DRAGINFOA, pt, 4)
+ TEST_FIELD_OFFSET(DRAGINFOA, pt, 4)
+ TEST_FIELD_SIZE (DRAGINFOA, fNC, 4)
+ TEST_FIELD_ALIGN (DRAGINFOA, fNC, 4)
+ TEST_FIELD_OFFSET(DRAGINFOA, fNC, 12)
+ TEST_FIELD_SIZE (DRAGINFOA, lpFileList, 8)
+ TEST_FIELD_ALIGN (DRAGINFOA, lpFileList, 8)
+ TEST_FIELD_OFFSET(DRAGINFOA, lpFileList, 16)
+ TEST_FIELD_SIZE (DRAGINFOA, grfKeyState, 4)
+ TEST_FIELD_ALIGN (DRAGINFOA, grfKeyState, 4)
+ TEST_FIELD_OFFSET(DRAGINFOA, grfKeyState, 24)
+}
+
+static void test_pack_DRAGINFOW(void)
+{
+ /* DRAGINFOW */
+ TEST_TYPE_SIZE (DRAGINFOW, 32)
+ TEST_TYPE_ALIGN (DRAGINFOW, 8)
+ TEST_FIELD_SIZE (DRAGINFOW, uSize, 4)
+ TEST_FIELD_ALIGN (DRAGINFOW, uSize, 4)
+ TEST_FIELD_OFFSET(DRAGINFOW, uSize, 0)
+ TEST_FIELD_SIZE (DRAGINFOW, pt, 8)
+ TEST_FIELD_ALIGN (DRAGINFOW, pt, 4)
+ TEST_FIELD_OFFSET(DRAGINFOW, pt, 4)
+ TEST_FIELD_SIZE (DRAGINFOW, fNC, 4)
+ TEST_FIELD_ALIGN (DRAGINFOW, fNC, 4)
+ TEST_FIELD_OFFSET(DRAGINFOW, fNC, 12)
+ TEST_FIELD_SIZE (DRAGINFOW, lpFileList, 8)
+ TEST_FIELD_ALIGN (DRAGINFOW, lpFileList, 8)
+ TEST_FIELD_OFFSET(DRAGINFOW, lpFileList, 16)
+ TEST_FIELD_SIZE (DRAGINFOW, grfKeyState, 4)
+ TEST_FIELD_ALIGN (DRAGINFOW, grfKeyState, 4)
+ TEST_FIELD_OFFSET(DRAGINFOW, grfKeyState, 24)
+}
+
+static void test_pack_FILEOP_FLAGS(void)
+{
+ /* FILEOP_FLAGS */
+ TEST_TYPE_SIZE (FILEOP_FLAGS, 2)
+ TEST_TYPE_ALIGN (FILEOP_FLAGS, 2)
+ TEST_TYPE_UNSIGNED(FILEOP_FLAGS)
+}
+
+static void test_pack_LPDRAGINFOA(void)
+{
+ /* LPDRAGINFOA */
+ TEST_TYPE_SIZE (LPDRAGINFOA, 8)
+ TEST_TYPE_ALIGN (LPDRAGINFOA, 8)
+ TEST_TARGET_SIZE (LPDRAGINFOA, 32)
+ TEST_TARGET_ALIGN(LPDRAGINFOA, 8)
+}
+
+static void test_pack_LPDRAGINFOW(void)
+{
+ /* LPDRAGINFOW */
+ TEST_TYPE_SIZE (LPDRAGINFOW, 8)
+ TEST_TYPE_ALIGN (LPDRAGINFOW, 8)
+ TEST_TARGET_SIZE (LPDRAGINFOW, 32)
+ TEST_TARGET_ALIGN(LPDRAGINFOW, 8)
+}
+
+static void test_pack_LPSHELLEXECUTEINFOA(void)
+{
+ /* LPSHELLEXECUTEINFOA */
+ TEST_TYPE_SIZE (LPSHELLEXECUTEINFOA, 8)
+ TEST_TYPE_ALIGN (LPSHELLEXECUTEINFOA, 8)
+}
+
+static void test_pack_LPSHELLEXECUTEINFOW(void)
+{
+ /* LPSHELLEXECUTEINFOW */
+ TEST_TYPE_SIZE (LPSHELLEXECUTEINFOW, 8)
+ TEST_TYPE_ALIGN (LPSHELLEXECUTEINFOW, 8)
+}
+
+static void test_pack_LPSHFILEOPSTRUCTA(void)
+{
+ /* LPSHFILEOPSTRUCTA */
+ TEST_TYPE_SIZE (LPSHFILEOPSTRUCTA, 8)
+ TEST_TYPE_ALIGN (LPSHFILEOPSTRUCTA, 8)
+ TEST_TARGET_SIZE (LPSHFILEOPSTRUCTA, 56)
+ TEST_TARGET_ALIGN(LPSHFILEOPSTRUCTA, 8)
+}
+
+static void test_pack_LPSHFILEOPSTRUCTW(void)
+{
+ /* LPSHFILEOPSTRUCTW */
+ TEST_TYPE_SIZE (LPSHFILEOPSTRUCTW, 8)
+ TEST_TYPE_ALIGN (LPSHFILEOPSTRUCTW, 8)
+ TEST_TARGET_SIZE (LPSHFILEOPSTRUCTW, 56)
+ TEST_TARGET_ALIGN(LPSHFILEOPSTRUCTW, 8)
+}
+
+static void test_pack_LPSHNAMEMAPPINGA(void)
+{
+ /* LPSHNAMEMAPPINGA */
+ TEST_TYPE_SIZE (LPSHNAMEMAPPINGA, 8)
+ TEST_TYPE_ALIGN (LPSHNAMEMAPPINGA, 8)
+ TEST_TARGET_SIZE (LPSHNAMEMAPPINGA, 24)
+ TEST_TARGET_ALIGN(LPSHNAMEMAPPINGA, 8)
+}
+
+static void test_pack_LPSHNAMEMAPPINGW(void)
+{
+ /* LPSHNAMEMAPPINGW */
+ TEST_TYPE_SIZE (LPSHNAMEMAPPINGW, 8)
+ TEST_TYPE_ALIGN (LPSHNAMEMAPPINGW, 8)
+ TEST_TARGET_SIZE (LPSHNAMEMAPPINGW, 24)
+ TEST_TARGET_ALIGN(LPSHNAMEMAPPINGW, 8)
+}
+
+static void test_pack_NOTIFYICONDATAA(void)
+{
+ /* NOTIFYICONDATAA */
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, cbSize, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, cbSize, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, cbSize, 0)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, hWnd, 8)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, hWnd, 8)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, hWnd, 8)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, uID, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, uID, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, uID, 16)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, uFlags, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, uFlags, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, uFlags, 20)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, uCallbackMessage, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, uCallbackMessage, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, uCallbackMessage, 24)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, hIcon, 8)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, hIcon, 8)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, hIcon, 32)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, szTip, 128)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, szTip, 1)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, szTip, 40)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, dwState, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, dwState, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, dwState, 168)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, dwStateMask, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, dwStateMask, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, dwStateMask, 172)
+ TEST_FIELD_SIZE (NOTIFYICONDATAA, szInfo, 256)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAA, szInfo, 1)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAA, szInfo, 176)
+}
+
+static void test_pack_NOTIFYICONDATAW(void)
+{
+ /* NOTIFYICONDATAW */
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, cbSize, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, cbSize, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, cbSize, 0)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, hWnd, 8)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, hWnd, 8)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, hWnd, 8)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, uID, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, uID, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, uID, 16)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, uFlags, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, uFlags, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, uFlags, 20)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, uCallbackMessage, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, uCallbackMessage, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, uCallbackMessage, 24)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, hIcon, 8)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, hIcon, 8)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, hIcon, 32)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, szTip, 256)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, szTip, 2)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, szTip, 40)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, dwState, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, dwState, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, dwState, 296)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, dwStateMask, 4)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, dwStateMask, 4)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, dwStateMask, 300)
+ TEST_FIELD_SIZE (NOTIFYICONDATAW, szInfo, 512)
+ TEST_FIELD_ALIGN (NOTIFYICONDATAW, szInfo, 2)
+ TEST_FIELD_OFFSET(NOTIFYICONDATAW, szInfo, 304)
+}
+
+static void test_pack_PAPPBARDATA(void)
+{
+ /* PAPPBARDATA */
+ TEST_TYPE_SIZE (PAPPBARDATA, 8)
+ TEST_TYPE_ALIGN (PAPPBARDATA, 8)
+ TEST_TARGET_SIZE (PAPPBARDATA, 48)
+ TEST_TARGET_ALIGN(PAPPBARDATA, 8)
+}
+
+static void test_pack_PNOTIFYICONDATAA(void)
+{
+ /* PNOTIFYICONDATAA */
+ TEST_TYPE_SIZE (PNOTIFYICONDATAA, 8)
+ TEST_TYPE_ALIGN (PNOTIFYICONDATAA, 8)
+}
+
+static void test_pack_PNOTIFYICONDATAW(void)
+{
+ /* PNOTIFYICONDATAW */
+ TEST_TYPE_SIZE (PNOTIFYICONDATAW, 8)
+ TEST_TYPE_ALIGN (PNOTIFYICONDATAW, 8)
+}
+
+static void test_pack_PRINTEROP_FLAGS(void)
+{
+ /* PRINTEROP_FLAGS */
+ TEST_TYPE_SIZE (PRINTEROP_FLAGS, 2)
+ TEST_TYPE_ALIGN (PRINTEROP_FLAGS, 2)
+ TEST_TYPE_UNSIGNED(PRINTEROP_FLAGS)
+}
+
+static void test_pack_SHELLEXECUTEINFOA(void)
+{
+ /* SHELLEXECUTEINFOA */
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, cbSize, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, cbSize, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, cbSize, 0)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, fMask, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, fMask, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, fMask, 4)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, hwnd, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, hwnd, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, hwnd, 8)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, lpVerb, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, lpVerb, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, lpVerb, 16)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, lpFile, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, lpFile, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, lpFile, 24)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, lpParameters, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, lpParameters, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, lpParameters, 32)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, lpDirectory, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, lpDirectory, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, lpDirectory, 40)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, nShow, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, nShow, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, nShow, 48)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, hInstApp, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, hInstApp, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, hInstApp, 56)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, lpIDList, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, lpIDList, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, lpIDList, 64)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, lpClass, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, lpClass, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, lpClass, 72)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, hkeyClass, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, hkeyClass, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, hkeyClass, 80)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOA, dwHotKey, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOA, dwHotKey, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOA, dwHotKey, 88)
+}
+
+static void test_pack_SHELLEXECUTEINFOW(void)
+{
+ /* SHELLEXECUTEINFOW */
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, cbSize, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, cbSize, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, cbSize, 0)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, fMask, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, fMask, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, fMask, 4)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, hwnd, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, hwnd, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, hwnd, 8)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, lpVerb, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, lpVerb, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, lpVerb, 16)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, lpFile, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, lpFile, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, lpFile, 24)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, lpParameters, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, lpParameters, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, lpParameters, 32)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, lpDirectory, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, lpDirectory, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, lpDirectory, 40)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, nShow, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, nShow, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, nShow, 48)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, hInstApp, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, hInstApp, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, hInstApp, 56)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, lpIDList, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, lpIDList, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, lpIDList, 64)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, lpClass, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, lpClass, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, lpClass, 72)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, hkeyClass, 8)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, hkeyClass, 8)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, hkeyClass, 80)
+ TEST_FIELD_SIZE (SHELLEXECUTEINFOW, dwHotKey, 4)
+ TEST_FIELD_ALIGN (SHELLEXECUTEINFOW, dwHotKey, 4)
+ TEST_FIELD_OFFSET(SHELLEXECUTEINFOW, dwHotKey, 88)
+}
+
+static void test_pack_SHFILEINFOA(void)
+{
+ /* SHFILEINFOA */
+ TEST_TYPE_SIZE (SHFILEINFOA, 360)
+ TEST_TYPE_ALIGN (SHFILEINFOA, 8)
+ TEST_FIELD_SIZE (SHFILEINFOA, hIcon, 8)
+ TEST_FIELD_ALIGN (SHFILEINFOA, hIcon, 8)
+ TEST_FIELD_OFFSET(SHFILEINFOA, hIcon, 0)
+ TEST_FIELD_SIZE (SHFILEINFOA, iIcon, 4)
+ TEST_FIELD_ALIGN (SHFILEINFOA, iIcon, 4)
+ TEST_FIELD_OFFSET(SHFILEINFOA, iIcon, 8)
+ TEST_FIELD_SIZE (SHFILEINFOA, dwAttributes, 4)
+ TEST_FIELD_ALIGN (SHFILEINFOA, dwAttributes, 4)
+ TEST_FIELD_OFFSET(SHFILEINFOA, dwAttributes, 12)
+ TEST_FIELD_SIZE (SHFILEINFOA, szDisplayName, 260)
+ TEST_FIELD_ALIGN (SHFILEINFOA, szDisplayName, 1)
+ TEST_FIELD_OFFSET(SHFILEINFOA, szDisplayName, 16)
+ TEST_FIELD_SIZE (SHFILEINFOA, szTypeName, 80)
+ TEST_FIELD_ALIGN (SHFILEINFOA, szTypeName, 1)
+ TEST_FIELD_OFFSET(SHFILEINFOA, szTypeName, 276)
+}
+
+static void test_pack_SHFILEINFOW(void)
+{
+ /* SHFILEINFOW */
+ TEST_TYPE_SIZE (SHFILEINFOW, 696)
+ TEST_TYPE_ALIGN (SHFILEINFOW, 8)
+ TEST_FIELD_SIZE (SHFILEINFOW, hIcon, 8)
+ TEST_FIELD_ALIGN (SHFILEINFOW, hIcon, 8)
+ TEST_FIELD_OFFSET(SHFILEINFOW, hIcon, 0)
+ TEST_FIELD_SIZE (SHFILEINFOW, iIcon, 4)
+ TEST_FIELD_ALIGN (SHFILEINFOW, iIcon, 4)
+ TEST_FIELD_OFFSET(SHFILEINFOW, iIcon, 8)
+ TEST_FIELD_SIZE (SHFILEINFOW, dwAttributes, 4)
+ TEST_FIELD_ALIGN (SHFILEINFOW, dwAttributes, 4)
+ TEST_FIELD_OFFSET(SHFILEINFOW, dwAttributes, 12)
+ TEST_FIELD_SIZE (SHFILEINFOW, szDisplayName, 520)
+ TEST_FIELD_ALIGN (SHFILEINFOW, szDisplayName, 2)
+ TEST_FIELD_OFFSET(SHFILEINFOW, szDisplayName, 16)
+ TEST_FIELD_SIZE (SHFILEINFOW, szTypeName, 160)
+ TEST_FIELD_ALIGN (SHFILEINFOW, szTypeName, 2)
+ TEST_FIELD_OFFSET(SHFILEINFOW, szTypeName, 536)
+}
+
+static void test_pack_SHFILEOPSTRUCTA(void)
+{
+ /* SHFILEOPSTRUCTA */
+ TEST_TYPE_SIZE (SHFILEOPSTRUCTA, 56)
+ TEST_TYPE_ALIGN (SHFILEOPSTRUCTA, 8)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, hwnd, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, hwnd, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, hwnd, 0)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, wFunc, 4)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, wFunc, 4)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, wFunc, 8)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, pFrom, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, pFrom, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, pFrom, 16)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, pTo, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, pTo, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, pTo, 24)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, fFlags, 2)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, fFlags, 2)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, fFlags, 32)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, fAnyOperationsAborted, 4)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, fAnyOperationsAborted, 4)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, fAnyOperationsAborted, 36)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, hNameMappings, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, hNameMappings, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, hNameMappings, 40)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTA, lpszProgressTitle, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTA, lpszProgressTitle, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTA, lpszProgressTitle, 48)
+}
+
+static void test_pack_SHFILEOPSTRUCTW(void)
+{
+ /* SHFILEOPSTRUCTW */
+ TEST_TYPE_SIZE (SHFILEOPSTRUCTW, 56)
+ TEST_TYPE_ALIGN (SHFILEOPSTRUCTW, 8)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, hwnd, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, hwnd, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, hwnd, 0)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, wFunc, 4)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, wFunc, 4)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, wFunc, 8)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, pFrom, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, pFrom, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, pFrom, 16)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, pTo, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, pTo, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, pTo, 24)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, fFlags, 2)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, fFlags, 2)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, fFlags, 32)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, fAnyOperationsAborted, 4)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, fAnyOperationsAborted, 4)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, fAnyOperationsAborted, 36)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, hNameMappings, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, hNameMappings, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, hNameMappings, 40)
+ TEST_FIELD_SIZE (SHFILEOPSTRUCTW, lpszProgressTitle, 8)
+ TEST_FIELD_ALIGN (SHFILEOPSTRUCTW, lpszProgressTitle, 8)
+ TEST_FIELD_OFFSET(SHFILEOPSTRUCTW, lpszProgressTitle, 48)
+}
+
+static void test_pack_SHNAMEMAPPINGA(void)
+{
+ /* SHNAMEMAPPINGA */
+ TEST_TYPE_SIZE (SHNAMEMAPPINGA, 24)
+ TEST_TYPE_ALIGN (SHNAMEMAPPINGA, 8)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGA, pszOldPath, 8)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGA, pszOldPath, 8)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGA, pszOldPath, 0)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGA, pszNewPath, 8)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGA, pszNewPath, 8)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGA, pszNewPath, 8)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGA, cchOldPath, 4)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGA, cchOldPath, 4)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGA, cchOldPath, 16)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGA, cchNewPath, 4)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGA, cchNewPath, 4)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGA, cchNewPath, 20)
+}
+
+static void test_pack_SHNAMEMAPPINGW(void)
+{
+ /* SHNAMEMAPPINGW */
+ TEST_TYPE_SIZE (SHNAMEMAPPINGW, 24)
+ TEST_TYPE_ALIGN (SHNAMEMAPPINGW, 8)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGW, pszOldPath, 8)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGW, pszOldPath, 8)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGW, pszOldPath, 0)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGW, pszNewPath, 8)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGW, pszNewPath, 8)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGW, pszNewPath, 8)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGW, cchOldPath, 4)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGW, cchOldPath, 4)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGW, cchOldPath, 16)
+ TEST_FIELD_SIZE (SHNAMEMAPPINGW, cchNewPath, 4)
+ TEST_FIELD_ALIGN (SHNAMEMAPPINGW, cchNewPath, 4)
+ TEST_FIELD_OFFSET(SHNAMEMAPPINGW, cchNewPath, 20)
+}
+
+static void test_pack_ITEMIDLIST(void)
+{
+ /* ITEMIDLIST (pack 1) */
+ TEST_TYPE_SIZE (ITEMIDLIST, 3)
+ TEST_TYPE_ALIGN (ITEMIDLIST, 1)
+ TEST_FIELD_SIZE (ITEMIDLIST, mkid, 3)
+ TEST_FIELD_ALIGN (ITEMIDLIST, mkid, 1)
+ TEST_FIELD_OFFSET(ITEMIDLIST, mkid, 0)
+}
+
+static void test_pack_LPCITEMIDLIST(void)
+{
+ /* LPCITEMIDLIST */
+ TEST_TYPE_SIZE (LPCITEMIDLIST, 8)
+ TEST_TYPE_ALIGN (LPCITEMIDLIST, 8)
+ TEST_TARGET_SIZE (LPCITEMIDLIST, 3)
+ TEST_TARGET_ALIGN(LPCITEMIDLIST, 1)
+}
+
+static void test_pack_LPCSHITEMID(void)
+{
+ /* LPCSHITEMID */
+ TEST_TYPE_SIZE (LPCSHITEMID, 8)
+ TEST_TYPE_ALIGN (LPCSHITEMID, 8)
+ TEST_TARGET_SIZE (LPCSHITEMID, 3)
+ TEST_TARGET_ALIGN(LPCSHITEMID, 1)
+}
+
+static void test_pack_LPITEMIDLIST(void)
+{
+ /* LPITEMIDLIST */
+ TEST_TYPE_SIZE (LPITEMIDLIST, 8)
+ TEST_TYPE_ALIGN (LPITEMIDLIST, 8)
+}
+
+static void test_pack_LPSHELLDETAILS(void)
+{
+ /* LPSHELLDETAILS */
+ TEST_TYPE_SIZE (LPSHELLDETAILS, 8)
+ TEST_TYPE_ALIGN (LPSHELLDETAILS, 8)
+}
+
+static void test_pack_LPSHITEMID(void)
+{
+ /* LPSHITEMID */
+ TEST_TYPE_SIZE (LPSHITEMID, 8)
+ TEST_TYPE_ALIGN (LPSHITEMID, 8)
+}
+
+static void test_pack_LPSTRRET(void)
+{
+ /* LPSTRRET */
+ TEST_TYPE_SIZE (LPSTRRET, 8)
+ TEST_TYPE_ALIGN (LPSTRRET, 8)
+}
+
+static void test_pack_SHELLDETAILS(void)
+{
+ /* SHELLDETAILS (pack 1) */
+ TEST_FIELD_SIZE (SHELLDETAILS, fmt, 4)
+ TEST_FIELD_ALIGN (SHELLDETAILS, fmt, 1)
+ TEST_FIELD_OFFSET(SHELLDETAILS, fmt, 0)
+ TEST_FIELD_SIZE (SHELLDETAILS, cxChar, 4)
+ TEST_FIELD_ALIGN (SHELLDETAILS, cxChar, 1)
+ TEST_FIELD_OFFSET(SHELLDETAILS, cxChar, 4)
+}
+
+static void test_pack_SHITEMID(void)
+{
+ /* SHITEMID (pack 1) */
+ TEST_TYPE_SIZE (SHITEMID, 3)
+ TEST_TYPE_ALIGN (SHITEMID, 1)
+ TEST_FIELD_SIZE (SHITEMID, cb, 2)
+ TEST_FIELD_ALIGN (SHITEMID, cb, 1)
+ TEST_FIELD_OFFSET(SHITEMID, cb, 0)
+ TEST_FIELD_SIZE (SHITEMID, abID, 1)
+ TEST_FIELD_ALIGN (SHITEMID, abID, 1)
+ TEST_FIELD_OFFSET(SHITEMID, abID, 2)
+}
+
+static void test_pack_STRRET(void)
+{
+ /* STRRET (pack 8) */
+ TEST_FIELD_SIZE (STRRET, uType, 4)
+ TEST_FIELD_ALIGN (STRRET, uType, 4)
+ TEST_FIELD_OFFSET(STRRET, uType, 0)
+}
+
+static void test_pack_AUTO_SCROLL_DATA(void)
+{
+ /* AUTO_SCROLL_DATA (pack 1) */
+ TEST_TYPE_SIZE (AUTO_SCROLL_DATA, 48)
+ TEST_TYPE_ALIGN (AUTO_SCROLL_DATA, 1)
+ TEST_FIELD_SIZE (AUTO_SCROLL_DATA, iNextSample, 4)
+ TEST_FIELD_ALIGN (AUTO_SCROLL_DATA, iNextSample, 1)
+ TEST_FIELD_OFFSET(AUTO_SCROLL_DATA, iNextSample, 0)
+ TEST_FIELD_SIZE (AUTO_SCROLL_DATA, dwLastScroll, 4)
+ TEST_FIELD_ALIGN (AUTO_SCROLL_DATA, dwLastScroll, 1)
+ TEST_FIELD_OFFSET(AUTO_SCROLL_DATA, dwLastScroll, 4)
+ TEST_FIELD_SIZE (AUTO_SCROLL_DATA, bFull, 4)
+ TEST_FIELD_ALIGN (AUTO_SCROLL_DATA, bFull, 1)
+ TEST_FIELD_OFFSET(AUTO_SCROLL_DATA, bFull, 8)
+ TEST_FIELD_SIZE (AUTO_SCROLL_DATA, pts, 24)
+ TEST_FIELD_ALIGN (AUTO_SCROLL_DATA, pts, 1)
+ TEST_FIELD_OFFSET(AUTO_SCROLL_DATA, pts, 12)
+ TEST_FIELD_SIZE (AUTO_SCROLL_DATA, dwTimes, 12)
+ TEST_FIELD_ALIGN (AUTO_SCROLL_DATA, dwTimes, 1)
+ TEST_FIELD_OFFSET(AUTO_SCROLL_DATA, dwTimes, 36)
+}
+
+static void test_pack_BFFCALLBACK(void)
+{
+ /* BFFCALLBACK */
+ TEST_TYPE_SIZE (BFFCALLBACK, 8)
+ TEST_TYPE_ALIGN (BFFCALLBACK, 8)
+}
+
+static void test_pack_BROWSEINFOA(void)
+{
+ /* BROWSEINFOA (pack 8) */
+ TEST_TYPE_SIZE (BROWSEINFOA, 64)
+ TEST_TYPE_ALIGN (BROWSEINFOA, 8)
+ TEST_FIELD_SIZE (BROWSEINFOA, hwndOwner, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOA, hwndOwner, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOA, hwndOwner, 0)
+ TEST_FIELD_SIZE (BROWSEINFOA, pidlRoot, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOA, pidlRoot, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOA, pidlRoot, 8)
+ TEST_FIELD_SIZE (BROWSEINFOA, pszDisplayName, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOA, pszDisplayName, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOA, pszDisplayName, 16)
+ TEST_FIELD_SIZE (BROWSEINFOA, lpszTitle, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOA, lpszTitle, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOA, lpszTitle, 24)
+ TEST_FIELD_SIZE (BROWSEINFOA, ulFlags, 4)
+ TEST_FIELD_ALIGN (BROWSEINFOA, ulFlags, 4)
+ TEST_FIELD_OFFSET(BROWSEINFOA, ulFlags, 32)
+ TEST_FIELD_SIZE (BROWSEINFOA, lpfn, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOA, lpfn, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOA, lpfn, 40)
+ TEST_FIELD_SIZE (BROWSEINFOA, lParam, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOA, lParam, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOA, lParam, 48)
+ TEST_FIELD_SIZE (BROWSEINFOA, iImage, 4)
+ TEST_FIELD_ALIGN (BROWSEINFOA, iImage, 4)
+ TEST_FIELD_OFFSET(BROWSEINFOA, iImage, 56)
+}
+
+static void test_pack_BROWSEINFOW(void)
+{
+ /* BROWSEINFOW (pack 8) */
+ TEST_TYPE_SIZE (BROWSEINFOW, 64)
+ TEST_TYPE_ALIGN (BROWSEINFOW, 8)
+ TEST_FIELD_SIZE (BROWSEINFOW, hwndOwner, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOW, hwndOwner, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOW, hwndOwner, 0)
+ TEST_FIELD_SIZE (BROWSEINFOW, pidlRoot, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOW, pidlRoot, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOW, pidlRoot, 8)
+ TEST_FIELD_SIZE (BROWSEINFOW, pszDisplayName, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOW, pszDisplayName, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOW, pszDisplayName, 16)
+ TEST_FIELD_SIZE (BROWSEINFOW, lpszTitle, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOW, lpszTitle, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOW, lpszTitle, 24)
+ TEST_FIELD_SIZE (BROWSEINFOW, ulFlags, 4)
+ TEST_FIELD_ALIGN (BROWSEINFOW, ulFlags, 4)
+ TEST_FIELD_OFFSET(BROWSEINFOW, ulFlags, 32)
+ TEST_FIELD_SIZE (BROWSEINFOW, lpfn, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOW, lpfn, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOW, lpfn, 40)
+ TEST_FIELD_SIZE (BROWSEINFOW, lParam, 8)
+ TEST_FIELD_ALIGN (BROWSEINFOW, lParam, 8)
+ TEST_FIELD_OFFSET(BROWSEINFOW, lParam, 48)
+ TEST_FIELD_SIZE (BROWSEINFOW, iImage, 4)
+ TEST_FIELD_ALIGN (BROWSEINFOW, iImage, 4)
+ TEST_FIELD_OFFSET(BROWSEINFOW, iImage, 56)
+}
+
+static void test_pack_CABINETSTATE(void)
+{
+ /* CABINETSTATE (pack 1) */
+ TEST_TYPE_SIZE (CABINETSTATE, 12)
+ TEST_TYPE_ALIGN (CABINETSTATE, 1)
+ TEST_FIELD_SIZE (CABINETSTATE, cLength, 2)
+ TEST_FIELD_ALIGN (CABINETSTATE, cLength, 1)
+ TEST_FIELD_OFFSET(CABINETSTATE, cLength, 0)
+ TEST_FIELD_SIZE (CABINETSTATE, nVersion, 2)
+ TEST_FIELD_ALIGN (CABINETSTATE, nVersion, 1)
+ TEST_FIELD_OFFSET(CABINETSTATE, nVersion, 2)
+ TEST_FIELD_SIZE (CABINETSTATE, fMenuEnumFilter, 4)
+ TEST_FIELD_ALIGN (CABINETSTATE, fMenuEnumFilter, 1)
+ TEST_FIELD_OFFSET(CABINETSTATE, fMenuEnumFilter, 8)
+}
+
+static void test_pack_CIDA(void)
+{
+ /* CIDA (pack 1) */
+ TEST_TYPE_SIZE (CIDA, 8)
+ TEST_TYPE_ALIGN (CIDA, 1)
+ TEST_FIELD_SIZE (CIDA, cidl, 4)
+ TEST_FIELD_ALIGN (CIDA, cidl, 1)
+ TEST_FIELD_OFFSET(CIDA, cidl, 0)
+ TEST_FIELD_SIZE (CIDA, aoffset, 4)
+ TEST_FIELD_ALIGN (CIDA, aoffset, 1)
+ TEST_FIELD_OFFSET(CIDA, aoffset, 4)
+}
+
+static void test_pack_CSFV(void)
+{
+ /* CSFV (pack 8) */
+ TEST_FIELD_SIZE (CSFV, cbSize, 4)
+ TEST_FIELD_ALIGN (CSFV, cbSize, 4)
+ TEST_FIELD_OFFSET(CSFV, cbSize, 0)
+ TEST_FIELD_SIZE (CSFV, pshf, 8)
+ TEST_FIELD_ALIGN (CSFV, pshf, 8)
+ TEST_FIELD_OFFSET(CSFV, pshf, 8)
+ TEST_FIELD_SIZE (CSFV, psvOuter, 8)
+ TEST_FIELD_ALIGN (CSFV, psvOuter, 8)
+ TEST_FIELD_OFFSET(CSFV, psvOuter, 16)
+ TEST_FIELD_SIZE (CSFV, pidl, 8)
+ TEST_FIELD_ALIGN (CSFV, pidl, 8)
+ TEST_FIELD_OFFSET(CSFV, pidl, 24)
+ TEST_FIELD_SIZE (CSFV, lEvents, 4)
+ TEST_FIELD_ALIGN (CSFV, lEvents, 4)
+ TEST_FIELD_OFFSET(CSFV, lEvents, 32)
+ TEST_FIELD_SIZE (CSFV, pfnCallback, 8)
+ TEST_FIELD_ALIGN (CSFV, pfnCallback, 8)
+ TEST_FIELD_OFFSET(CSFV, pfnCallback, 40)
+}
+
+static void test_pack_DROPFILES(void)
+{
+ /* DROPFILES (pack 1) */
+ TEST_TYPE_SIZE (DROPFILES, 20)
+ TEST_TYPE_ALIGN (DROPFILES, 1)
+ TEST_FIELD_SIZE (DROPFILES, pFiles, 4)
+ TEST_FIELD_ALIGN (DROPFILES, pFiles, 1)
+ TEST_FIELD_OFFSET(DROPFILES, pFiles, 0)
+ TEST_FIELD_SIZE (DROPFILES, pt, 8)
+ TEST_FIELD_ALIGN (DROPFILES, pt, 1)
+ TEST_FIELD_OFFSET(DROPFILES, pt, 4)
+ TEST_FIELD_SIZE (DROPFILES, fNC, 4)
+ TEST_FIELD_ALIGN (DROPFILES, fNC, 1)
+ TEST_FIELD_OFFSET(DROPFILES, fNC, 12)
+ TEST_FIELD_SIZE (DROPFILES, fWide, 4)
+ TEST_FIELD_ALIGN (DROPFILES, fWide, 1)
+ TEST_FIELD_OFFSET(DROPFILES, fWide, 16)
+}
+
+static void test_pack_FILEDESCRIPTORA(void)
+{
+ /* FILEDESCRIPTORA (pack 1) */
+ TEST_TYPE_SIZE (FILEDESCRIPTORA, 332)
+ TEST_TYPE_ALIGN (FILEDESCRIPTORA, 1)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, dwFlags, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, dwFlags, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, dwFlags, 0)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, clsid, 16)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, clsid, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, clsid, 4)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, sizel, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, sizel, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, sizel, 20)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, pointl, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, pointl, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, pointl, 28)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, dwFileAttributes, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, dwFileAttributes, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, dwFileAttributes, 36)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, ftCreationTime, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, ftCreationTime, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, ftCreationTime, 40)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, ftLastAccessTime, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, ftLastAccessTime, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, ftLastAccessTime, 48)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, ftLastWriteTime, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, ftLastWriteTime, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, ftLastWriteTime, 56)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, nFileSizeHigh, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, nFileSizeHigh, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, nFileSizeHigh, 64)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, nFileSizeLow, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, nFileSizeLow, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, nFileSizeLow, 68)
+ TEST_FIELD_SIZE (FILEDESCRIPTORA, cFileName, 260)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORA, cFileName, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORA, cFileName, 72)
+}
+
+static void test_pack_FILEDESCRIPTORW(void)
+{
+ /* FILEDESCRIPTORW (pack 1) */
+ TEST_TYPE_SIZE (FILEDESCRIPTORW, 592)
+ TEST_TYPE_ALIGN (FILEDESCRIPTORW, 1)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, dwFlags, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, dwFlags, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, dwFlags, 0)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, clsid, 16)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, clsid, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, clsid, 4)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, sizel, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, sizel, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, sizel, 20)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, pointl, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, pointl, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, pointl, 28)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, dwFileAttributes, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, dwFileAttributes, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, dwFileAttributes, 36)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, ftCreationTime, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, ftCreationTime, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, ftCreationTime, 40)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, ftLastAccessTime, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, ftLastAccessTime, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, ftLastAccessTime, 48)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, ftLastWriteTime, 8)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, ftLastWriteTime, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, ftLastWriteTime, 56)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, nFileSizeHigh, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, nFileSizeHigh, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, nFileSizeHigh, 64)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, nFileSizeLow, 4)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, nFileSizeLow, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, nFileSizeLow, 68)
+ TEST_FIELD_SIZE (FILEDESCRIPTORW, cFileName, 520)
+ TEST_FIELD_ALIGN (FILEDESCRIPTORW, cFileName, 1)
+ TEST_FIELD_OFFSET(FILEDESCRIPTORW, cFileName, 72)
+}
+
+static void test_pack_FILEGROUPDESCRIPTORA(void)
+{
+ /* FILEGROUPDESCRIPTORA (pack 1) */
+ TEST_TYPE_SIZE (FILEGROUPDESCRIPTORA, 336)
+ TEST_TYPE_ALIGN (FILEGROUPDESCRIPTORA, 1)
+ TEST_FIELD_SIZE (FILEGROUPDESCRIPTORA, cItems, 4)
+ TEST_FIELD_ALIGN (FILEGROUPDESCRIPTORA, cItems, 1)
+ TEST_FIELD_OFFSET(FILEGROUPDESCRIPTORA, cItems, 0)
+ TEST_FIELD_SIZE (FILEGROUPDESCRIPTORA, fgd, 332)
+ TEST_FIELD_ALIGN (FILEGROUPDESCRIPTORA, fgd, 1)
+ TEST_FIELD_OFFSET(FILEGROUPDESCRIPTORA, fgd, 4)
+}
+
+static void test_pack_FILEGROUPDESCRIPTORW(void)
+{
+ /* FILEGROUPDESCRIPTORW (pack 1) */
+ TEST_TYPE_SIZE (FILEGROUPDESCRIPTORW, 596)
+ TEST_TYPE_ALIGN (FILEGROUPDESCRIPTORW, 1)
+ TEST_FIELD_SIZE (FILEGROUPDESCRIPTORW, cItems, 4)
+ TEST_FIELD_ALIGN (FILEGROUPDESCRIPTORW, cItems, 1)
+ TEST_FIELD_OFFSET(FILEGROUPDESCRIPTORW, cItems, 0)
+ TEST_FIELD_SIZE (FILEGROUPDESCRIPTORW, fgd, 592)
+ TEST_FIELD_ALIGN (FILEGROUPDESCRIPTORW, fgd, 1)
+ TEST_FIELD_OFFSET(FILEGROUPDESCRIPTORW, fgd, 4)
+}
+
+static void test_pack_ITEMSPACING(void)
+{
+ /* ITEMSPACING (pack 8) */
+ TEST_TYPE_SIZE (ITEMSPACING, 16)
+ TEST_TYPE_ALIGN (ITEMSPACING, 4)
+ TEST_FIELD_SIZE (ITEMSPACING, cxSmall, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cxSmall, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cxSmall, 0)
+ TEST_FIELD_SIZE (ITEMSPACING, cySmall, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cySmall, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cySmall, 4)
+ TEST_FIELD_SIZE (ITEMSPACING, cxLarge, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cxLarge, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cxLarge, 8)
+ TEST_FIELD_SIZE (ITEMSPACING, cyLarge, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cyLarge, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cyLarge, 12)
+}
+
+static void test_pack_LPBROWSEINFOA(void)
+{
+ /* LPBROWSEINFOA */
+ TEST_TYPE_SIZE (LPBROWSEINFOA, 8)
+ TEST_TYPE_ALIGN (LPBROWSEINFOA, 8)
+ TEST_TARGET_SIZE (LPBROWSEINFOA, 64)
+ TEST_TARGET_ALIGN(LPBROWSEINFOA, 8)
+}
+
+static void test_pack_LPBROWSEINFOW(void)
+{
+ /* LPBROWSEINFOW */
+ TEST_TYPE_SIZE (LPBROWSEINFOW, 8)
+ TEST_TYPE_ALIGN (LPBROWSEINFOW, 8)
+ TEST_TARGET_SIZE (LPBROWSEINFOW, 64)
+ TEST_TARGET_ALIGN(LPBROWSEINFOW, 8)
+}
+
+static void test_pack_LPCABINETSTATE(void)
+{
+ /* LPCABINETSTATE */
+ TEST_TYPE_SIZE (LPCABINETSTATE, 8)
+ TEST_TYPE_ALIGN (LPCABINETSTATE, 8)
+ TEST_TARGET_SIZE (LPCABINETSTATE, 12)
+ TEST_TARGET_ALIGN(LPCABINETSTATE, 1)
+}
+
+static void test_pack_LPCSFV(void)
+{
+ /* LPCSFV */
+ TEST_TYPE_SIZE (LPCSFV, 8)
+ TEST_TYPE_ALIGN (LPCSFV, 8)
+}
+
+static void test_pack_LPDROPFILES(void)
+{
+ /* LPDROPFILES */
+ TEST_TYPE_SIZE (LPDROPFILES, 8)
+ TEST_TYPE_ALIGN (LPDROPFILES, 8)
+ TEST_TARGET_SIZE (LPDROPFILES, 20)
+ TEST_TARGET_ALIGN(LPDROPFILES, 1)
+}
+
+static void test_pack_LPFILEDESCRIPTORA(void)
+{
+ /* LPFILEDESCRIPTORA */
+ TEST_TYPE_SIZE (LPFILEDESCRIPTORA, 8)
+ TEST_TYPE_ALIGN (LPFILEDESCRIPTORA, 8)
+ TEST_TARGET_SIZE (LPFILEDESCRIPTORA, 332)
+ TEST_TARGET_ALIGN(LPFILEDESCRIPTORA, 1)
+}
-#else
+static void test_pack_LPFILEDESCRIPTORW(void)
+{
+ /* LPFILEDESCRIPTORW */
+ TEST_TYPE_SIZE (LPFILEDESCRIPTORW, 8)
+ TEST_TYPE_ALIGN (LPFILEDESCRIPTORW, 8)
+ TEST_TARGET_SIZE (LPFILEDESCRIPTORW, 592)
+ TEST_TARGET_ALIGN(LPFILEDESCRIPTORW, 1)
+}
+
+static void test_pack_LPFILEGROUPDESCRIPTORA(void)
+{
+ /* LPFILEGROUPDESCRIPTORA */
+ TEST_TYPE_SIZE (LPFILEGROUPDESCRIPTORA, 8)
+ TEST_TYPE_ALIGN (LPFILEGROUPDESCRIPTORA, 8)
+ TEST_TARGET_SIZE (LPFILEGROUPDESCRIPTORA, 336)
+ TEST_TARGET_ALIGN(LPFILEGROUPDESCRIPTORA, 1)
+}
-# define TEST_TYPE_SIZE(type, size) C_ASSERT(sizeof(type) == size);
+static void test_pack_LPFILEGROUPDESCRIPTORW(void)
+{
+ /* LPFILEGROUPDESCRIPTORW */
+ TEST_TYPE_SIZE (LPFILEGROUPDESCRIPTORW, 8)
+ TEST_TYPE_ALIGN (LPFILEGROUPDESCRIPTORW, 8)
+ TEST_TARGET_SIZE (LPFILEGROUPDESCRIPTORW, 596)
+ TEST_TARGET_ALIGN(LPFILEGROUPDESCRIPTORW, 1)
+}
-# ifdef TYPE_ALIGNMENT
-# define TEST_TYPE_ALIGN(type, align) C_ASSERT(TYPE_ALIGNMENT(type) == align);
-# else
-# define TEST_TYPE_ALIGN(type, align)
-# endif
+static void test_pack_LPFNVIEWCALLBACK(void)
+{
+ /* LPFNVIEWCALLBACK */
+ TEST_TYPE_SIZE (LPFNVIEWCALLBACK, 8)
+ TEST_TYPE_ALIGN (LPFNVIEWCALLBACK, 8)
+}
-# ifdef _TYPE_ALIGNMENT
-# define TEST_TARGET_ALIGN(type, align) C_ASSERT(_TYPE_ALIGNMENT(*(type)0) == align);
-# define TEST_FIELD_ALIGN(type, field, align) C_ASSERT(_TYPE_ALIGNMENT(((type*)0)->field) == align);
-# else
-# define TEST_TARGET_ALIGN(type, align)
-# define TEST_FIELD_ALIGN(type, field, align)
-# endif
+static void test_pack_LPIDA(void)
+{
+ /* LPIDA */
+ TEST_TYPE_SIZE (LPIDA, 8)
+ TEST_TYPE_ALIGN (LPIDA, 8)
+ TEST_TARGET_SIZE (LPIDA, 8)
+ TEST_TARGET_ALIGN(LPIDA, 1)
+}
-# define TEST_FIELD_OFFSET(type, field, offset) C_ASSERT(FIELD_OFFSET(type, field) == offset);
+static void test_pack_LPQCMINFO(void)
+{
+ /* LPQCMINFO */
+ TEST_TYPE_SIZE (LPQCMINFO, 8)
+ TEST_TYPE_ALIGN (LPQCMINFO, 8)
+ TEST_TARGET_SIZE (LPQCMINFO, 32)
+ TEST_TARGET_ALIGN(LPQCMINFO, 8)
+}
-#endif
+static void test_pack_LPSHChangeDWORDAsIDList(void)
+{
+ /* LPSHChangeDWORDAsIDList */
+ TEST_TYPE_SIZE (LPSHChangeDWORDAsIDList, 8)
+ TEST_TYPE_ALIGN (LPSHChangeDWORDAsIDList, 8)
+ TEST_TARGET_SIZE (LPSHChangeDWORDAsIDList, 12)
+ TEST_TARGET_ALIGN(LPSHChangeDWORDAsIDList, 1)
+}
-#define TEST_TARGET_SIZE(type, size) TEST_TYPE_SIZE(*(type)0, size)
-#define TEST_FIELD_SIZE(type, field, size) TEST_TYPE_SIZE((((type*)0)->field), size)
-#define TEST_TYPE_SIGNED(type) C_ASSERT((type) -1 < 0);
-#define TEST_TYPE_UNSIGNED(type) C_ASSERT((type) -1 > 0);
+static void test_pack_LPSHChangeProductKeyAsIDList(void)
+{
+ /* LPSHChangeProductKeyAsIDList */
+ TEST_TYPE_SIZE (LPSHChangeProductKeyAsIDList, 8)
+ TEST_TYPE_ALIGN (LPSHChangeProductKeyAsIDList, 8)
+ TEST_TARGET_SIZE (LPSHChangeProductKeyAsIDList, 82)
+ TEST_TARGET_ALIGN(LPSHChangeProductKeyAsIDList, 1)
+}
+
+static void test_pack_LPSHDESCRIPTIONID(void)
+{
+ /* LPSHDESCRIPTIONID */
+ TEST_TYPE_SIZE (LPSHDESCRIPTIONID, 8)
+ TEST_TYPE_ALIGN (LPSHDESCRIPTIONID, 8)
+ TEST_TARGET_SIZE (LPSHDESCRIPTIONID, 20)
+ TEST_TARGET_ALIGN(LPSHDESCRIPTIONID, 4)
+}
+
+static void test_pack_LPSHELLFLAGSTATE(void)
+{
+ /* LPSHELLFLAGSTATE */
+ TEST_TYPE_SIZE (LPSHELLFLAGSTATE, 8)
+ TEST_TYPE_ALIGN (LPSHELLFLAGSTATE, 8)
+ TEST_TARGET_SIZE (LPSHELLFLAGSTATE, 4)
+ TEST_TARGET_ALIGN(LPSHELLFLAGSTATE, 1)
+}
+
+static void test_pack_LPSHELLSTATE(void)
+{
+ /* LPSHELLSTATE */
+ TEST_TYPE_SIZE (LPSHELLSTATE, 8)
+ TEST_TYPE_ALIGN (LPSHELLSTATE, 8)
+ TEST_TARGET_SIZE (LPSHELLSTATE, 32)
+ TEST_TARGET_ALIGN(LPSHELLSTATE, 1)
+}
+
+static void test_pack_LPTBINFO(void)
+{
+ /* LPTBINFO */
+ TEST_TYPE_SIZE (LPTBINFO, 8)
+ TEST_TYPE_ALIGN (LPTBINFO, 8)
+ TEST_TARGET_SIZE (LPTBINFO, 8)
+ TEST_TARGET_ALIGN(LPTBINFO, 4)
+}
+
+static void test_pack_PBROWSEINFOA(void)
+{
+ /* PBROWSEINFOA */
+ TEST_TYPE_SIZE (PBROWSEINFOA, 8)
+ TEST_TYPE_ALIGN (PBROWSEINFOA, 8)
+ TEST_TARGET_SIZE (PBROWSEINFOA, 64)
+ TEST_TARGET_ALIGN(PBROWSEINFOA, 8)
+}
+
+static void test_pack_PBROWSEINFOW(void)
+{
+ /* PBROWSEINFOW */
+ TEST_TYPE_SIZE (PBROWSEINFOW, 8)
+ TEST_TYPE_ALIGN (PBROWSEINFOW, 8)
+ TEST_TARGET_SIZE (PBROWSEINFOW, 64)
+ TEST_TARGET_ALIGN(PBROWSEINFOW, 8)
+}
+
+static void test_pack_QCMINFO(void)
+{
+ /* QCMINFO (pack 8) */
+ TEST_TYPE_SIZE (QCMINFO, 32)
+ TEST_TYPE_ALIGN (QCMINFO, 8)
+ TEST_FIELD_SIZE (QCMINFO, hmenu, 8)
+ TEST_FIELD_ALIGN (QCMINFO, hmenu, 8)
+ TEST_FIELD_OFFSET(QCMINFO, hmenu, 0)
+ TEST_FIELD_SIZE (QCMINFO, indexMenu, 4)
+ TEST_FIELD_ALIGN (QCMINFO, indexMenu, 4)
+ TEST_FIELD_OFFSET(QCMINFO, indexMenu, 8)
+ TEST_FIELD_SIZE (QCMINFO, idCmdFirst, 4)
+ TEST_FIELD_ALIGN (QCMINFO, idCmdFirst, 4)
+ TEST_FIELD_OFFSET(QCMINFO, idCmdFirst, 12)
+ TEST_FIELD_SIZE (QCMINFO, idCmdLast, 4)
+ TEST_FIELD_ALIGN (QCMINFO, idCmdLast, 4)
+ TEST_FIELD_OFFSET(QCMINFO, idCmdLast, 16)
+ TEST_FIELD_SIZE (QCMINFO, pIdMap, 8)
+ TEST_FIELD_ALIGN (QCMINFO, pIdMap, 8)
+ TEST_FIELD_OFFSET(QCMINFO, pIdMap, 24)
+}
+
+static void test_pack_QCMINFO_IDMAP(void)
+{
+ /* QCMINFO_IDMAP (pack 8) */
+ TEST_TYPE_SIZE (QCMINFO_IDMAP, 12)
+ TEST_TYPE_ALIGN (QCMINFO_IDMAP, 4)
+ TEST_FIELD_SIZE (QCMINFO_IDMAP, nMaxIds, 4)
+ TEST_FIELD_ALIGN (QCMINFO_IDMAP, nMaxIds, 4)
+ TEST_FIELD_OFFSET(QCMINFO_IDMAP, nMaxIds, 0)
+ TEST_FIELD_SIZE (QCMINFO_IDMAP, pIdList, 8)
+ TEST_FIELD_ALIGN (QCMINFO_IDMAP, pIdList, 4)
+ TEST_FIELD_OFFSET(QCMINFO_IDMAP, pIdList, 4)
+}
+
+static void test_pack_QCMINFO_IDMAP_PLACEMENT(void)
+{
+ /* QCMINFO_IDMAP_PLACEMENT (pack 8) */
+ TEST_TYPE_SIZE (QCMINFO_IDMAP_PLACEMENT, 8)
+ TEST_TYPE_ALIGN (QCMINFO_IDMAP_PLACEMENT, 4)
+ TEST_FIELD_SIZE (QCMINFO_IDMAP_PLACEMENT, id, 4)
+ TEST_FIELD_ALIGN (QCMINFO_IDMAP_PLACEMENT, id, 4)
+ TEST_FIELD_OFFSET(QCMINFO_IDMAP_PLACEMENT, id, 0)
+ TEST_FIELD_SIZE (QCMINFO_IDMAP_PLACEMENT, fFlags, 4)
+ TEST_FIELD_ALIGN (QCMINFO_IDMAP_PLACEMENT, fFlags, 4)
+ TEST_FIELD_OFFSET(QCMINFO_IDMAP_PLACEMENT, fFlags, 4)
+}
+
+static void test_pack_SFV_CREATE(void)
+{
+ /* SFV_CREATE (pack 8) */
+ TEST_TYPE_SIZE (SFV_CREATE, 32)
+ TEST_TYPE_ALIGN (SFV_CREATE, 8)
+ TEST_FIELD_SIZE (SFV_CREATE, cbSize, 4)
+ TEST_FIELD_ALIGN (SFV_CREATE, cbSize, 4)
+ TEST_FIELD_OFFSET(SFV_CREATE, cbSize, 0)
+ TEST_FIELD_SIZE (SFV_CREATE, pshf, 8)
+ TEST_FIELD_ALIGN (SFV_CREATE, pshf, 8)
+ TEST_FIELD_OFFSET(SFV_CREATE, pshf, 8)
+ TEST_FIELD_SIZE (SFV_CREATE, psvOuter, 8)
+ TEST_FIELD_ALIGN (SFV_CREATE, psvOuter, 8)
+ TEST_FIELD_OFFSET(SFV_CREATE, psvOuter, 16)
+ TEST_FIELD_SIZE (SFV_CREATE, psfvcb, 8)
+ TEST_FIELD_ALIGN (SFV_CREATE, psfvcb, 8)
+ TEST_FIELD_OFFSET(SFV_CREATE, psfvcb, 24)
+}
+
+static void test_pack_SHChangeDWORDAsIDList(void)
+{
+ /* SHChangeDWORDAsIDList (pack 1) */
+ TEST_TYPE_SIZE (SHChangeDWORDAsIDList, 12)
+ TEST_TYPE_ALIGN (SHChangeDWORDAsIDList, 1)
+ TEST_FIELD_SIZE (SHChangeDWORDAsIDList, cb, 2)
+ TEST_FIELD_ALIGN (SHChangeDWORDAsIDList, cb, 1)
+ TEST_FIELD_OFFSET(SHChangeDWORDAsIDList, cb, 0)
+ TEST_FIELD_SIZE (SHChangeDWORDAsIDList, dwItem1, 4)
+ TEST_FIELD_ALIGN (SHChangeDWORDAsIDList, dwItem1, 1)
+ TEST_FIELD_OFFSET(SHChangeDWORDAsIDList, dwItem1, 2)
+ TEST_FIELD_SIZE (SHChangeDWORDAsIDList, dwItem2, 4)
+ TEST_FIELD_ALIGN (SHChangeDWORDAsIDList, dwItem2, 1)
+ TEST_FIELD_OFFSET(SHChangeDWORDAsIDList, dwItem2, 6)
+ TEST_FIELD_SIZE (SHChangeDWORDAsIDList, cbZero, 2)
+ TEST_FIELD_ALIGN (SHChangeDWORDAsIDList, cbZero, 1)
+ TEST_FIELD_OFFSET(SHChangeDWORDAsIDList, cbZero, 10)
+}
+
+static void test_pack_SHChangeNotifyEntry(void)
+{
+ /* SHChangeNotifyEntry (pack 1) */
+ TEST_TYPE_SIZE (SHChangeNotifyEntry, 12)
+ TEST_TYPE_ALIGN (SHChangeNotifyEntry, 1)
+ TEST_FIELD_SIZE (SHChangeNotifyEntry, pidl, 8)
+ TEST_FIELD_ALIGN (SHChangeNotifyEntry, pidl, 1)
+ TEST_FIELD_OFFSET(SHChangeNotifyEntry, pidl, 0)
+ TEST_FIELD_SIZE (SHChangeNotifyEntry, fRecursive, 4)
+ TEST_FIELD_ALIGN (SHChangeNotifyEntry, fRecursive, 1)
+ TEST_FIELD_OFFSET(SHChangeNotifyEntry, fRecursive, 8)
+}
+
+static void test_pack_SHChangeProductKeyAsIDList(void)
+{
+ /* SHChangeProductKeyAsIDList (pack 1) */
+ TEST_TYPE_SIZE (SHChangeProductKeyAsIDList, 82)
+ TEST_TYPE_ALIGN (SHChangeProductKeyAsIDList, 1)
+ TEST_FIELD_SIZE (SHChangeProductKeyAsIDList, cb, 2)
+ TEST_FIELD_ALIGN (SHChangeProductKeyAsIDList, cb, 1)
+ TEST_FIELD_OFFSET(SHChangeProductKeyAsIDList, cb, 0)
+ TEST_FIELD_SIZE (SHChangeProductKeyAsIDList, wszProductKey, 78)
+ TEST_FIELD_ALIGN (SHChangeProductKeyAsIDList, wszProductKey, 1)
+ TEST_FIELD_OFFSET(SHChangeProductKeyAsIDList, wszProductKey, 2)
+ TEST_FIELD_SIZE (SHChangeProductKeyAsIDList, cbZero, 2)
+ TEST_FIELD_ALIGN (SHChangeProductKeyAsIDList, cbZero, 1)
+ TEST_FIELD_OFFSET(SHChangeProductKeyAsIDList, cbZero, 80)
+}
+
+static void test_pack_SHDESCRIPTIONID(void)
+{
+ /* SHDESCRIPTIONID (pack 8) */
+ TEST_TYPE_SIZE (SHDESCRIPTIONID, 20)
+ TEST_TYPE_ALIGN (SHDESCRIPTIONID, 4)
+ TEST_FIELD_SIZE (SHDESCRIPTIONID, dwDescriptionId, 4)
+ TEST_FIELD_ALIGN (SHDESCRIPTIONID, dwDescriptionId, 4)
+ TEST_FIELD_OFFSET(SHDESCRIPTIONID, dwDescriptionId, 0)
+ TEST_FIELD_SIZE (SHDESCRIPTIONID, clsid, 16)
+ TEST_FIELD_ALIGN (SHDESCRIPTIONID, clsid, 4)
+ TEST_FIELD_OFFSET(SHDESCRIPTIONID, clsid, 4)
+}
+
+static void test_pack_SHELLFLAGSTATE(void)
+{
+ /* SHELLFLAGSTATE (pack 1) */
+ TEST_TYPE_SIZE (SHELLFLAGSTATE, 4)
+ TEST_TYPE_ALIGN (SHELLFLAGSTATE, 1)
+}
+
+static void test_pack_SHELLSTATE(void)
+{
+ /* SHELLSTATE (pack 1) */
+ TEST_TYPE_SIZE (SHELLSTATE, 32)
+ TEST_TYPE_ALIGN (SHELLSTATE, 1)
+ TEST_FIELD_SIZE (SHELLSTATE, dwWin95Unused, 4)
+ TEST_FIELD_ALIGN (SHELLSTATE, dwWin95Unused, 1)
+ TEST_FIELD_OFFSET(SHELLSTATE, dwWin95Unused, 4)
+ TEST_FIELD_SIZE (SHELLSTATE, uWin95Unused, 4)
+ TEST_FIELD_ALIGN (SHELLSTATE, uWin95Unused, 1)
+ TEST_FIELD_OFFSET(SHELLSTATE, uWin95Unused, 8)
+ TEST_FIELD_SIZE (SHELLSTATE, lParamSort, 4)
+ TEST_FIELD_ALIGN (SHELLSTATE, lParamSort, 1)
+ TEST_FIELD_OFFSET(SHELLSTATE, lParamSort, 12)
+ TEST_FIELD_SIZE (SHELLSTATE, iSortDirection, 4)
+ TEST_FIELD_ALIGN (SHELLSTATE, iSortDirection, 1)
+ TEST_FIELD_OFFSET(SHELLSTATE, iSortDirection, 16)
+ TEST_FIELD_SIZE (SHELLSTATE, version, 4)
+ TEST_FIELD_ALIGN (SHELLSTATE, version, 1)
+ TEST_FIELD_OFFSET(SHELLSTATE, version, 20)
+ TEST_FIELD_SIZE (SHELLSTATE, uNotUsed, 4)
+ TEST_FIELD_ALIGN (SHELLSTATE, uNotUsed, 1)
+ TEST_FIELD_OFFSET(SHELLSTATE, uNotUsed, 24)
+}
+
+static void test_pack_TBINFO(void)
+{
+ /* TBINFO (pack 8) */
+ TEST_TYPE_SIZE (TBINFO, 8)
+ TEST_TYPE_ALIGN (TBINFO, 4)
+ TEST_FIELD_SIZE (TBINFO, cbuttons, 4)
+ TEST_FIELD_ALIGN (TBINFO, cbuttons, 4)
+ TEST_FIELD_OFFSET(TBINFO, cbuttons, 0)
+ TEST_FIELD_SIZE (TBINFO, uFlags, 4)
+ TEST_FIELD_ALIGN (TBINFO, uFlags, 4)
+ TEST_FIELD_OFFSET(TBINFO, uFlags, 4)
+}
+#else /* _WIN64 */
static void test_pack_BLOB(void)
{
- /* BLOB (pack 4) */
+ /* BLOB */
TEST_TYPE_SIZE (BLOB, 8)
TEST_TYPE_ALIGN (BLOB, 4)
TEST_FIELD_SIZE (BLOB, cbSize, 4)
static void test_pack_BSTRBLOB(void)
{
- /* BSTRBLOB (pack 4) */
+ /* BSTRBLOB */
TEST_TYPE_SIZE (BSTRBLOB, 8)
TEST_TYPE_ALIGN (BSTRBLOB, 4)
TEST_FIELD_SIZE (BSTRBLOB, cbSize, 4)
static void test_pack_BYTE_BLOB(void)
{
- /* BYTE_BLOB (pack 4) */
+ /* BYTE_BLOB */
TEST_TYPE_SIZE (BYTE_BLOB, 8)
TEST_TYPE_ALIGN (BYTE_BLOB, 4)
TEST_FIELD_SIZE (BYTE_BLOB, clSize, 4)
static void test_pack_BYTE_SIZEDARR(void)
{
- /* BYTE_SIZEDARR (pack 4) */
+ /* BYTE_SIZEDARR */
TEST_TYPE_SIZE (BYTE_SIZEDARR, 8)
TEST_TYPE_ALIGN (BYTE_SIZEDARR, 4)
TEST_FIELD_SIZE (BYTE_SIZEDARR, clSize, 4)
static void test_pack_CLIPDATA(void)
{
- /* CLIPDATA (pack 4) */
+ /* CLIPDATA */
TEST_TYPE_SIZE (CLIPDATA, 12)
TEST_TYPE_ALIGN (CLIPDATA, 4)
TEST_FIELD_SIZE (CLIPDATA, cbSize, 4)
static void test_pack_COAUTHIDENTITY(void)
{
- /* COAUTHIDENTITY (pack 4) */
+ /* COAUTHIDENTITY */
TEST_TYPE_SIZE (COAUTHIDENTITY, 28)
TEST_TYPE_ALIGN (COAUTHIDENTITY, 4)
TEST_FIELD_SIZE (COAUTHIDENTITY, User, 4)
static void test_pack_COAUTHINFO(void)
{
- /* COAUTHINFO (pack 4) */
+ /* COAUTHINFO */
TEST_TYPE_SIZE (COAUTHINFO, 28)
TEST_TYPE_ALIGN (COAUTHINFO, 4)
TEST_FIELD_SIZE (COAUTHINFO, dwAuthnSvc, 4)
static void test_pack_DWORD_SIZEDARR(void)
{
- /* DWORD_SIZEDARR (pack 4) */
+ /* DWORD_SIZEDARR */
TEST_TYPE_SIZE (DWORD_SIZEDARR, 8)
TEST_TYPE_ALIGN (DWORD_SIZEDARR, 4)
TEST_FIELD_SIZE (DWORD_SIZEDARR, clSize, 4)
static void test_pack_FLAGGED_BYTE_BLOB(void)
{
- /* FLAGGED_BYTE_BLOB (pack 4) */
+ /* FLAGGED_BYTE_BLOB */
TEST_TYPE_SIZE (FLAGGED_BYTE_BLOB, 12)
TEST_TYPE_ALIGN (FLAGGED_BYTE_BLOB, 4)
TEST_FIELD_SIZE (FLAGGED_BYTE_BLOB, fFlags, 4)
static void test_pack_FLAGGED_WORD_BLOB(void)
{
- /* FLAGGED_WORD_BLOB (pack 4) */
+ /* FLAGGED_WORD_BLOB */
TEST_TYPE_SIZE (FLAGGED_WORD_BLOB, 12)
TEST_TYPE_ALIGN (FLAGGED_WORD_BLOB, 4)
TEST_FIELD_SIZE (FLAGGED_WORD_BLOB, fFlags, 4)
static void test_pack_HYPER_SIZEDARR(void)
{
- /* HYPER_SIZEDARR (pack 4) */
+ /* HYPER_SIZEDARR */
TEST_TYPE_SIZE (HYPER_SIZEDARR, 8)
TEST_TYPE_ALIGN (HYPER_SIZEDARR, 4)
TEST_FIELD_SIZE (HYPER_SIZEDARR, clSize, 4)
static void test_pack_RemHBITMAP(void)
{
- /* RemHBITMAP (pack 4) */
+ /* RemHBITMAP */
TEST_TYPE_SIZE (RemHBITMAP, 8)
TEST_TYPE_ALIGN (RemHBITMAP, 4)
TEST_FIELD_SIZE (RemHBITMAP, cbData, 4)
static void test_pack_RemHENHMETAFILE(void)
{
- /* RemHENHMETAFILE (pack 4) */
+ /* RemHENHMETAFILE */
TEST_TYPE_SIZE (RemHENHMETAFILE, 8)
TEST_TYPE_ALIGN (RemHENHMETAFILE, 4)
TEST_FIELD_SIZE (RemHENHMETAFILE, cbData, 4)
static void test_pack_RemHGLOBAL(void)
{
- /* RemHGLOBAL (pack 4) */
+ /* RemHGLOBAL */
TEST_TYPE_SIZE (RemHGLOBAL, 12)
TEST_TYPE_ALIGN (RemHGLOBAL, 4)
TEST_FIELD_SIZE (RemHGLOBAL, fNullHGlobal, 4)
static void test_pack_RemHMETAFILEPICT(void)
{
- /* RemHMETAFILEPICT (pack 4) */
+ /* RemHMETAFILEPICT */
TEST_TYPE_SIZE (RemHMETAFILEPICT, 20)
TEST_TYPE_ALIGN (RemHMETAFILEPICT, 4)
TEST_FIELD_SIZE (RemHMETAFILEPICT, mm, 4)
static void test_pack_RemHPALETTE(void)
{
- /* RemHPALETTE (pack 4) */
+ /* RemHPALETTE */
TEST_TYPE_SIZE (RemHPALETTE, 8)
TEST_TYPE_ALIGN (RemHPALETTE, 4)
TEST_FIELD_SIZE (RemHPALETTE, cbData, 4)
static void test_pack_WORD_SIZEDARR(void)
{
- /* WORD_SIZEDARR (pack 4) */
+ /* WORD_SIZEDARR */
TEST_TYPE_SIZE (WORD_SIZEDARR, 8)
TEST_TYPE_ALIGN (WORD_SIZEDARR, 4)
TEST_FIELD_SIZE (WORD_SIZEDARR, clSize, 4)
static void test_pack_remoteMETAFILEPICT(void)
{
- /* remoteMETAFILEPICT (pack 4) */
+ /* remoteMETAFILEPICT */
TEST_TYPE_SIZE (remoteMETAFILEPICT, 16)
TEST_TYPE_ALIGN (remoteMETAFILEPICT, 4)
TEST_FIELD_SIZE (remoteMETAFILEPICT, mm, 4)
static void test_pack_userBITMAP(void)
{
- /* userBITMAP (pack 4) */
+ /* userBITMAP */
TEST_TYPE_SIZE (userBITMAP, 28)
TEST_TYPE_ALIGN (userBITMAP, 4)
TEST_FIELD_SIZE (userBITMAP, bmType, 4)
static void test_pack_userCLIPFORMAT(void)
{
- /* userCLIPFORMAT (pack 4) */
+ /* userCLIPFORMAT */
TEST_FIELD_SIZE (userCLIPFORMAT, fContext, 4)
TEST_FIELD_ALIGN (userCLIPFORMAT, fContext, 4)
TEST_FIELD_OFFSET(userCLIPFORMAT, fContext, 0)
static void test_pack_userHBITMAP(void)
{
- /* userHBITMAP (pack 4) */
+ /* userHBITMAP */
TEST_FIELD_SIZE (userHBITMAP, fContext, 4)
TEST_FIELD_ALIGN (userHBITMAP, fContext, 4)
TEST_FIELD_OFFSET(userHBITMAP, fContext, 0)
static void test_pack_userHENHMETAFILE(void)
{
- /* userHENHMETAFILE (pack 4) */
+ /* userHENHMETAFILE */
TEST_FIELD_SIZE (userHENHMETAFILE, fContext, 4)
TEST_FIELD_ALIGN (userHENHMETAFILE, fContext, 4)
TEST_FIELD_OFFSET(userHENHMETAFILE, fContext, 0)
static void test_pack_userHGLOBAL(void)
{
- /* userHGLOBAL (pack 4) */
+ /* userHGLOBAL */
TEST_FIELD_SIZE (userHGLOBAL, fContext, 4)
TEST_FIELD_ALIGN (userHGLOBAL, fContext, 4)
TEST_FIELD_OFFSET(userHGLOBAL, fContext, 0)
static void test_pack_userHMETAFILE(void)
{
- /* userHMETAFILE (pack 4) */
+ /* userHMETAFILE */
TEST_FIELD_SIZE (userHMETAFILE, fContext, 4)
TEST_FIELD_ALIGN (userHMETAFILE, fContext, 4)
TEST_FIELD_OFFSET(userHMETAFILE, fContext, 0)
static void test_pack_userHMETAFILEPICT(void)
{
- /* userHMETAFILEPICT (pack 4) */
+ /* userHMETAFILEPICT */
TEST_FIELD_SIZE (userHMETAFILEPICT, fContext, 4)
TEST_FIELD_ALIGN (userHMETAFILEPICT, fContext, 4)
TEST_FIELD_OFFSET(userHMETAFILEPICT, fContext, 0)
static void test_pack_userHPALETTE(void)
{
- /* userHPALETTE (pack 4) */
+ /* userHPALETTE */
TEST_FIELD_SIZE (userHPALETTE, fContext, 4)
TEST_FIELD_ALIGN (userHPALETTE, fContext, 4)
TEST_FIELD_OFFSET(userHPALETTE, fContext, 0)
static void test_pack_STRRET(void)
{
- /* STRRET (pack 4) */
+ /* STRRET (pack 8) */
TEST_FIELD_SIZE (STRRET, uType, 4)
TEST_FIELD_ALIGN (STRRET, uType, 4)
TEST_FIELD_OFFSET(STRRET, uType, 0)
static void test_pack_CSFV(void)
{
- /* CSFV (pack 1) */
+ /* CSFV (pack 8) */
TEST_FIELD_SIZE (CSFV, cbSize, 4)
- TEST_FIELD_ALIGN (CSFV, cbSize, 1)
+ TEST_FIELD_ALIGN (CSFV, cbSize, 4)
TEST_FIELD_OFFSET(CSFV, cbSize, 0)
TEST_FIELD_SIZE (CSFV, pshf, 4)
- TEST_FIELD_ALIGN (CSFV, pshf, 1)
+ TEST_FIELD_ALIGN (CSFV, pshf, 4)
TEST_FIELD_OFFSET(CSFV, pshf, 4)
TEST_FIELD_SIZE (CSFV, psvOuter, 4)
- TEST_FIELD_ALIGN (CSFV, psvOuter, 1)
+ TEST_FIELD_ALIGN (CSFV, psvOuter, 4)
TEST_FIELD_OFFSET(CSFV, psvOuter, 8)
TEST_FIELD_SIZE (CSFV, pidl, 4)
- TEST_FIELD_ALIGN (CSFV, pidl, 1)
+ TEST_FIELD_ALIGN (CSFV, pidl, 4)
TEST_FIELD_OFFSET(CSFV, pidl, 12)
TEST_FIELD_SIZE (CSFV, lEvents, 4)
- TEST_FIELD_ALIGN (CSFV, lEvents, 1)
+ TEST_FIELD_ALIGN (CSFV, lEvents, 4)
TEST_FIELD_OFFSET(CSFV, lEvents, 16)
TEST_FIELD_SIZE (CSFV, pfnCallback, 4)
- TEST_FIELD_ALIGN (CSFV, pfnCallback, 1)
+ TEST_FIELD_ALIGN (CSFV, pfnCallback, 4)
TEST_FIELD_OFFSET(CSFV, pfnCallback, 20)
}
TEST_FIELD_OFFSET(FILEGROUPDESCRIPTORW, fgd, 4)
}
+static void test_pack_ITEMSPACING(void)
+{
+ /* ITEMSPACING (pack 8) */
+ TEST_TYPE_SIZE (ITEMSPACING, 16)
+ TEST_TYPE_ALIGN (ITEMSPACING, 4)
+ TEST_FIELD_SIZE (ITEMSPACING, cxSmall, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cxSmall, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cxSmall, 0)
+ TEST_FIELD_SIZE (ITEMSPACING, cySmall, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cySmall, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cySmall, 4)
+ TEST_FIELD_SIZE (ITEMSPACING, cxLarge, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cxLarge, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cxLarge, 8)
+ TEST_FIELD_SIZE (ITEMSPACING, cyLarge, 4)
+ TEST_FIELD_ALIGN (ITEMSPACING, cyLarge, 4)
+ TEST_FIELD_OFFSET(ITEMSPACING, cyLarge, 12)
+}
+
static void test_pack_LPBROWSEINFOA(void)
{
/* LPBROWSEINFOA */
TEST_FIELD_OFFSET(QCMINFO_IDMAP_PLACEMENT, fFlags, 4)
}
+static void test_pack_SFV_CREATE(void)
+{
+ /* SFV_CREATE (pack 8) */
+ TEST_TYPE_SIZE (SFV_CREATE, 16)
+ TEST_TYPE_ALIGN (SFV_CREATE, 4)
+ TEST_FIELD_SIZE (SFV_CREATE, cbSize, 4)
+ TEST_FIELD_ALIGN (SFV_CREATE, cbSize, 4)
+ TEST_FIELD_OFFSET(SFV_CREATE, cbSize, 0)
+ TEST_FIELD_SIZE (SFV_CREATE, pshf, 4)
+ TEST_FIELD_ALIGN (SFV_CREATE, pshf, 4)
+ TEST_FIELD_OFFSET(SFV_CREATE, pshf, 4)
+ TEST_FIELD_SIZE (SFV_CREATE, psvOuter, 4)
+ TEST_FIELD_ALIGN (SFV_CREATE, psvOuter, 4)
+ TEST_FIELD_OFFSET(SFV_CREATE, psvOuter, 8)
+ TEST_FIELD_SIZE (SFV_CREATE, psfvcb, 4)
+ TEST_FIELD_ALIGN (SFV_CREATE, psfvcb, 4)
+ TEST_FIELD_OFFSET(SFV_CREATE, psfvcb, 12)
+}
+
static void test_pack_SHChangeDWORDAsIDList(void)
{
/* SHChangeDWORDAsIDList (pack 1) */
TEST_FIELD_OFFSET(TBINFO, uFlags, 4)
}
+#endif /* _WIN64 */
+
static void test_pack(void)
{
test_pack_APPBARDATA();
test_pack_HYPER_SIZEDARR();
test_pack_IID();
test_pack_ITEMIDLIST();
+ test_pack_ITEMSPACING();
test_pack_LPBLOB();
test_pack_LPBROWSEINFOA();
test_pack_LPBROWSEINFOW();
test_pack_RemHMETAFILEPICT();
test_pack_RemHPALETTE();
test_pack_SCODE();
+ test_pack_SFV_CREATE();
test_pack_SHChangeDWORDAsIDList();
test_pack_SHChangeNotifyEntry();
test_pack_SHChangeProductKeyAsIDList();
START_TEST(generated)
{
-#ifdef _WIN64
- ok(0, "The type size / alignment tests don't support Win64 yet\n");
-#else
test_pack();
-#endif
}
--- /dev/null
+/* Message Sequence Testing Code
+ *
+ * Copyright (C) 2007 James Hawkins
+ * Copyright (C) 2007 Lei Zhang
+ *
+ * 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
+ */
+
+#include <assert.h>
+#include <windows.h>
+#include "wine/test.h"
+
+/* undocumented SWP flags - from SDK 3.1 */
+#define SWP_NOCLIENTSIZE 0x0800
+#define SWP_NOCLIENTMOVE 0x1000
+
+typedef enum
+{
+ sent = 0x1,
+ posted = 0x2,
+ parent = 0x4,
+ wparam = 0x8,
+ lparam = 0x10,
+ defwinproc = 0x20,
+ beginpaint = 0x40,
+ optional = 0x80,
+ hook = 0x100,
+ winevent_hook =0x200,
+ id = 0x400
+} msg_flags_t;
+
+struct message
+{
+ UINT message; /* the WM_* code */
+ msg_flags_t flags; /* message props */
+ WPARAM wParam; /* expected value of wParam */
+ LPARAM lParam; /* expected value of lParam */
+ UINT id; /* extra message data: id of the window,
+ notify code etc. */
+};
+
+struct msg_sequence
+{
+ int count;
+ int size;
+ struct message *sequence;
+};
+
+static void add_message(struct msg_sequence **seq, int sequence_index,
+ const struct message *msg)
+{
+ struct msg_sequence *msg_seq = seq[sequence_index];
+
+ if (!msg_seq->sequence)
+ {
+ msg_seq->size = 10;
+ msg_seq->sequence = HeapAlloc(GetProcessHeap(), 0,
+ msg_seq->size * sizeof (struct message));
+ }
+
+ if (msg_seq->count == msg_seq->size)
+ {
+ msg_seq->size *= 2;
+ msg_seq->sequence = HeapReAlloc(GetProcessHeap(), 0,
+ msg_seq->sequence,
+ msg_seq->size * sizeof (struct message));
+ }
+
+ assert(msg_seq->sequence);
+
+ msg_seq->sequence[msg_seq->count].message = msg->message;
+ msg_seq->sequence[msg_seq->count].flags = msg->flags;
+ msg_seq->sequence[msg_seq->count].wParam = msg->wParam;
+ msg_seq->sequence[msg_seq->count].lParam = msg->lParam;
+ msg_seq->sequence[msg_seq->count].id = msg->id;
+
+ msg_seq->count++;
+}
+
+static void flush_sequence(struct msg_sequence **seg, int sequence_index)
+{
+ struct msg_sequence *msg_seq = seg[sequence_index];
+ HeapFree(GetProcessHeap(), 0, msg_seq->sequence);
+ msg_seq->sequence = NULL;
+ msg_seq->count = msg_seq->size = 0;
+}
+
+static void flush_sequences(struct msg_sequence **seq, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ flush_sequence(seq, i);
+}
+
+static void ok_sequence_(struct msg_sequence **seq, int sequence_index,
+ const struct message *expected, const char *context, int todo,
+ const char *file, int line)
+{
+ struct msg_sequence *msg_seq = seq[sequence_index];
+ static const struct message end_of_sequence = {0, 0, 0, 0};
+ const struct message *actual, *sequence;
+ int failcount = 0;
+
+ add_message(seq, sequence_index, &end_of_sequence);
+
+ sequence = msg_seq->sequence;
+ actual = sequence;
+
+ while (expected->message && actual->message)
+ {
+ trace_( file, line)("expected %04x - actual %04x\n", expected->message, actual->message);
+
+ if (expected->message == actual->message)
+ {
+ if (expected->flags & wparam)
+ {
+ if (expected->wParam != actual->wParam && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ ok_(file, line) (FALSE,
+ "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
+ context, expected->message, expected->wParam, actual->wParam);
+ }
+ }
+ else
+ {
+ ok_(file, line) (expected->wParam == actual->wParam,
+ "%s: in msg 0x%04x expecting wParam 0x%lx got 0x%lx\n",
+ context, expected->message, expected->wParam, actual->wParam);
+ }
+ }
+
+ if (expected->flags & lparam)
+ {
+ if (expected->lParam != actual->lParam && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ ok_(file, line) (FALSE,
+ "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
+ context, expected->message, expected->lParam, actual->lParam);
+ }
+ }
+ else
+ {
+ ok_(file, line) (expected->lParam == actual->lParam,
+ "%s: in msg 0x%04x expecting lParam 0x%lx got 0x%lx\n",
+ context, expected->message, expected->lParam, actual->lParam);
+ }
+ }
+
+ if (expected->flags & id)
+ {
+ if (expected->id != actual->id && expected->flags & optional)
+ {
+ expected++;
+ continue;
+ }
+ if (expected->id != actual->id && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ ok_(file, line) (FALSE,
+ "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
+ context, expected->message, expected->id, actual->id);
+ }
+ }
+ else
+ {
+ ok_(file, line) (expected->id == actual->id,
+ "%s: in msg 0x%04x expecting id 0x%x got 0x%x\n",
+ context, expected->message, expected->id, actual->id);
+ }
+ }
+
+ if ((expected->flags & defwinproc) != (actual->flags & defwinproc) && todo)
+ {
+ todo_wine
+ {
+ failcount++;
+ ok_(file, line) (FALSE,
+ "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
+ context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
+ }
+ }
+ else
+ {
+ ok_(file, line) ((expected->flags & defwinproc) == (actual->flags & defwinproc),
+ "%s: the msg 0x%04x should %shave been sent by DefWindowProc\n",
+ context, expected->message, (expected->flags & defwinproc) ? "" : "NOT ");
+ }
+
+ ok_(file, line) ((expected->flags & beginpaint) == (actual->flags & beginpaint),
+ "%s: the msg 0x%04x should %shave been sent by BeginPaint\n",
+ context, expected->message, (expected->flags & beginpaint) ? "" : "NOT ");
+ ok_(file, line) ((expected->flags & (sent|posted)) == (actual->flags & (sent|posted)),
+ "%s: the msg 0x%04x should have been %s\n",
+ context, expected->message, (expected->flags & posted) ? "posted" : "sent");
+ ok_(file, line) ((expected->flags & parent) == (actual->flags & parent),
+ "%s: the msg 0x%04x was expected in %s\n",
+ context, expected->message, (expected->flags & parent) ? "parent" : "child");
+ ok_(file, line) ((expected->flags & hook) == (actual->flags & hook),
+ "%s: the msg 0x%04x should have been sent by a hook\n",
+ context, expected->message);
+ ok_(file, line) ((expected->flags & winevent_hook) == (actual->flags & winevent_hook),
+ "%s: the msg 0x%04x should have been sent by a winevent hook\n",
+ context, expected->message);
+ expected++;
+ actual++;
+ }
+ else if (expected->flags & optional)
+ expected++;
+ else if (todo)
+ {
+ failcount++;
+ todo_wine
+ {
+ ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
+ context, expected->message, actual->message);
+ }
+
+ flush_sequence(seq, sequence_index);
+ return;
+ }
+ else
+ {
+ ok_(file, line) (FALSE, "%s: the msg 0x%04x was expected, but got msg 0x%04x instead\n",
+ context, expected->message, actual->message);
+ expected++;
+ actual++;
+ }
+ }
+
+ /* skip all optional trailing messages */
+ while (expected->message && ((expected->flags & optional)))
+ expected++;
+
+ if (todo)
+ {
+ todo_wine
+ {
+ if (expected->message || actual->message)
+ {
+ failcount++;
+ ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
+ context, expected->message, actual->message);
+ }
+ }
+ }
+ else if (expected->message || actual->message)
+ {
+ ok_(file, line) (FALSE, "%s: the msg sequence is not complete: expected %04x - actual %04x\n",
+ context, expected->message, actual->message);
+ }
+
+ if(todo && !failcount) /* succeeded yet marked todo */
+ {
+ todo_wine
+ {
+ ok_(file, line)(TRUE, "%s: marked \"todo_wine\" but succeeds\n", context);
+ }
+ }
+
+ flush_sequence(seq, sequence_index);
+}
+
+#define ok_sequence(seq, index, exp, contx, todo) \
+ ok_sequence_(seq, index, (exp), (contx), (todo), __FILE__, __LINE__)
+
+
+static void init_msg_sequences(struct msg_sequence **seq, int n)
+{
+ int i;
+
+ for (i = 0; i < n; i++)
+ seq[i] = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct msg_sequence));
+}
{
HKEY key;
DWORD size;
- LONG res;
/* Older Win9x and NT4 */
RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &key);
size = sizeof(commonprograms);
- res = RegQueryValueExA(key, "Common Programs", NULL, NULL, (LPBYTE)&commonprograms, &size);
+ RegQueryValueExA(key, "Common Programs", NULL, NULL, (LPBYTE)&commonprograms, &size);
RegCloseKey(key);
}
<file>shlexec.c</file>
<file>shlfileop.c</file>
<file>shlfolder.c</file>
+ <file>shlview.c</file>
<file>string.c</file>
<file>systray.c</file>
<file>testlist.c</file>
- <file>shfldr_netplaces.c</file>
<file>shfldr_special.c</file>
<file>rsrc.rc</file>
</module>
MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, len);
r=pSHILCreateFromPath(pathW, &pidl, NULL);
- ok(SUCCEEDED(r), "SHILCreateFromPath failed (0x%08x)\n", r);
+ ok(r == S_OK, "SHILCreateFromPath failed (0x%08x)\n", r);
HeapFree(GetProcessHeap(), 0, pathW);
}
return pidl;
r = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLinkA, (LPVOID*)&sl);
- ok(SUCCEEDED(r), "no IID_IShellLinkA (0x%08x)\n", r);
- if (FAILED(r))
+ ok(r == S_OK, "no IID_IShellLinkA (0x%08x)\n", r);
+ if (r != S_OK)
return;
/* Test Getting / Setting the description */
strcpy(buffer,"garbage");
r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetDescription failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetDescription returned '%s'\n", buffer);
str="Some description";
r = IShellLinkA_SetDescription(sl, str);
- ok(SUCCEEDED(r), "SetDescription failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetDescription failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetDescription failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
ok(lstrcmp(buffer,str)==0, "GetDescription returned '%s'\n", buffer);
+ r = IShellLinkA_SetDescription(sl, NULL);
+ ok(r == S_OK, "SetDescription failed (0x%08x)\n", r);
+
+ strcpy(buffer,"garbage");
+ r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
+ ok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
+ ok(*buffer=='\0' || broken(lstrcmp(buffer,str)==0), "GetDescription returned '%s'\n", buffer); /* NT4 */
+
+
/* Test Getting / Setting the work directory */
strcpy(buffer,"garbage");
r = IShellLinkA_GetWorkingDirectory(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetWorkingDirectory failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetWorkingDirectory failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetWorkingDirectory returned '%s'\n", buffer);
str="c:\\nonexistent\\directory";
r = IShellLinkA_SetWorkingDirectory(sl, str);
- ok(SUCCEEDED(r), "SetWorkingDirectory failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetWorkingDirectory failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetWorkingDirectory(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetWorkingDirectory failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetWorkingDirectory failed (0x%08x)\n", r);
ok(lstrcmpi(buffer,str)==0, "GetWorkingDirectory returned '%s'\n", buffer);
/* Test Getting / Setting the path */
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
- ok(SUCCEEDED(r), "GetPath failed (0x%08x)\n", r);
+ todo_wine ok(r == S_FALSE || broken(r == S_OK) /* NT4/W2K */, "GetPath failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetPath returned '%s'\n", buffer);
CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
- ok(SUCCEEDED(r), "GetPath failed (0x%08x)\n", r);
+ todo_wine ok(r == S_FALSE, "GetPath failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetPath returned '%s'\n", buffer);
/* Win98 returns S_FALSE, but WinXP returns S_OK */
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
- ok(SUCCEEDED(r), "GetPath failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetPath failed (0x%08x)\n", r);
ok(lstrcmpi(buffer,str)==0, "GetPath returned '%s'\n", buffer);
/* Get some real path to play with */
/* Test the interaction of SetPath and SetIDList */
tmp_pidl=NULL;
r = IShellLinkA_GetIDList(sl, &tmp_pidl);
- ok(SUCCEEDED(r), "GetIDList failed (0x%08x)\n", r);
- if (SUCCEEDED(r))
+ todo_wine ok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
+ if (r == S_OK)
{
BOOL ret;
LPITEMIDLIST second_pidl;
r = IShellLinkA_SetIDList(sl, pidl);
- ok(SUCCEEDED(r), "SetIDList failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetIDList failed (0x%08x)\n", r);
tmp_pidl=NULL;
r = IShellLinkA_GetIDList(sl, &tmp_pidl);
- ok(SUCCEEDED(r), "GetIDList failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
ok(tmp_pidl && pILIsEqual(pidl, tmp_pidl),
"GetIDList returned an incorrect pidl\n");
r = IShellLinkA_GetIDList(sl, &second_pidl);
- ok(SUCCEEDED(r), "GetIDList failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
ok(second_pidl && pILIsEqual(pidl, second_pidl),
"GetIDList returned an incorrect pidl\n");
ok(second_pidl != tmp_pidl, "pidls are the same\n");
strcpy(buffer,"garbage");
r = IShellLinkA_GetPath(sl, buffer, sizeof(buffer), NULL, SLGP_RAWPATH);
- ok(SUCCEEDED(r), "GetPath failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetPath failed (0x%08x)\n", r);
todo_wine
ok(lstrcmpi(buffer, mypath)==0, "GetPath returned '%s'\n", buffer);
/* Test Getting / Setting the arguments */
strcpy(buffer,"garbage");
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(*buffer=='\0', "GetArguments returned '%s'\n", buffer);
str="param1 \"spaced param2\"";
r = IShellLinkA_SetArguments(sl, str);
- ok(SUCCEEDED(r), "SetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
strcpy(buffer,"garbage");
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(lstrcmp(buffer,str)==0, "GetArguments returned '%s'\n", buffer);
strcpy(buffer,"garbage");
r = IShellLinkA_SetArguments(sl, NULL);
- ok(SUCCEEDED(r), "SetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(!buffer[0] || lstrcmp(buffer,str)==0, "GetArguments returned '%s'\n", buffer);
strcpy(buffer,"garbage");
r = IShellLinkA_SetArguments(sl, "");
- ok(SUCCEEDED(r), "SetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
r = IShellLinkA_GetArguments(sl, buffer, sizeof(buffer));
- ok(SUCCEEDED(r), "GetArguments failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetArguments failed (0x%08x)\n", r);
ok(!buffer[0], "GetArguments returned '%s'\n", buffer);
/* Test Getting / Setting showcmd */
i=0xdeadbeef;
r = IShellLinkA_GetShowCmd(sl, &i);
- ok(SUCCEEDED(r), "GetShowCmd failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetShowCmd failed (0x%08x)\n", r);
ok(i==SW_SHOWNORMAL, "GetShowCmd returned %d\n", i);
r = IShellLinkA_SetShowCmd(sl, SW_SHOWMAXIMIZED);
- ok(SUCCEEDED(r), "SetShowCmd failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetShowCmd failed (0x%08x)\n", r);
i=0xdeadbeef;
r = IShellLinkA_GetShowCmd(sl, &i);
- ok(SUCCEEDED(r), "GetShowCmd failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetShowCmd failed (0x%08x)\n", r);
ok(i==SW_SHOWMAXIMIZED, "GetShowCmd returned %d'\n", i);
/* Test Getting / Setting the icon */
strcpy(buffer,"garbage");
r = IShellLinkA_GetIconLocation(sl, buffer, sizeof(buffer), &i);
todo_wine {
- ok(SUCCEEDED(r), "GetIconLocation failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetIconLocation failed (0x%08x)\n", r);
}
ok(*buffer=='\0', "GetIconLocation returned '%s'\n", buffer);
ok(i==0, "GetIconLocation returned %d\n", i);
str="c:\\nonexistent\\file";
r = IShellLinkA_SetIconLocation(sl, str, 0xbabecafe);
- ok(SUCCEEDED(r), "SetIconLocation failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetIconLocation failed (0x%08x)\n", r);
i=0xdeadbeef;
r = IShellLinkA_GetIconLocation(sl, buffer, sizeof(buffer), &i);
- ok(SUCCEEDED(r), "GetIconLocation failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetIconLocation failed (0x%08x)\n", r);
ok(lstrcmpi(buffer,str)==0, "GetIconLocation returned '%s'\n", buffer);
ok(i==0xbabecafe, "GetIconLocation returned %d'\n", i);
/* Test Getting / Setting the hot key */
w=0xbeef;
r = IShellLinkA_GetHotkey(sl, &w);
- ok(SUCCEEDED(r), "GetHotkey failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetHotkey failed (0x%08x)\n", r);
ok(w==0, "GetHotkey returned %d\n", w);
r = IShellLinkA_SetHotkey(sl, 0x5678);
- ok(SUCCEEDED(r), "SetHotkey failed (0x%08x)\n", r);
+ ok(r == S_OK, "SetHotkey failed (0x%08x)\n", r);
w=0xbeef;
r = IShellLinkA_GetHotkey(sl, &w);
- ok(SUCCEEDED(r), "GetHotkey failed (0x%08x)\n", r);
+ ok(r == S_OK, "GetHotkey failed (0x%08x)\n", r);
ok(w==0x5678, "GetHotkey returned %d'\n", w);
IShellLinkA_Release(sl);
r = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLinkA, (LPVOID*)&sl);
- lok(SUCCEEDED(r), "no IID_IShellLinkA (0x%08x)\n", r);
- if (FAILED(r))
+ lok(r == S_OK, "no IID_IShellLinkA (0x%08x)\n", r);
+ if (r != S_OK)
return;
if (desc->description)
{
r = IShellLinkA_SetDescription(sl, desc->description);
- lok(SUCCEEDED(r), "SetDescription failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetDescription failed (0x%08x)\n", r);
}
if (desc->workdir)
{
r = IShellLinkA_SetWorkingDirectory(sl, desc->workdir);
- lok(SUCCEEDED(r), "SetWorkingDirectory failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetWorkingDirectory failed (0x%08x)\n", r);
}
if (desc->path)
{
if (desc->pidl)
{
r = IShellLinkA_SetIDList(sl, desc->pidl);
- lok(SUCCEEDED(r), "SetIDList failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetIDList failed (0x%08x)\n", r);
}
if (desc->arguments)
{
r = IShellLinkA_SetArguments(sl, desc->arguments);
- lok(SUCCEEDED(r), "SetArguments failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetArguments failed (0x%08x)\n", r);
}
if (desc->showcmd)
{
r = IShellLinkA_SetShowCmd(sl, desc->showcmd);
- lok(SUCCEEDED(r), "SetShowCmd failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetShowCmd failed (0x%08x)\n", r);
}
if (desc->icon)
{
r = IShellLinkA_SetIconLocation(sl, desc->icon, desc->icon_id);
- lok(SUCCEEDED(r), "SetIconLocation failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetIconLocation failed (0x%08x)\n", r);
}
if (desc->hotkey)
{
r = IShellLinkA_SetHotkey(sl, desc->hotkey);
- lok(SUCCEEDED(r), "SetHotkey failed (0x%08x)\n", r);
+ lok(r == S_OK, "SetHotkey failed (0x%08x)\n", r);
}
r = IShellLinkW_QueryInterface(sl, &IID_IPersistFile, (LPVOID*)&pf);
- lok(SUCCEEDED(r), "no IID_IPersistFile (0x%08x)\n", r);
- if (SUCCEEDED(r))
+ lok(r == S_OK, "no IID_IPersistFile (0x%08x)\n", r);
+ if (r == S_OK)
+ {
+ LPOLESTR str;
+
+ if (0)
{
+ /* crashes on XP */
+ r = IPersistFile_GetCurFile(pf, NULL);
+ }
+
+ /* test GetCurFile before ::Save */
+ str = (LPWSTR)0xdeadbeef;
+ r = IPersistFile_GetCurFile(pf, &str);
+ lok(r == S_FALSE ||
+ broken(r == S_OK), /* shell32 < 5.0 */
+ "got 0x%08x\n", r);
+ lok(str == NULL, "got %p\n", str);
+
r = IPersistFile_Save(pf, path, TRUE);
if (save_fails)
{
todo_wine {
- lok(SUCCEEDED(r), "save failed (0x%08x)\n", r);
+ lok(r == S_OK, "save failed (0x%08x)\n", r);
}
}
else
{
- lok(SUCCEEDED(r), "save failed (0x%08x)\n", r);
+ lok(r == S_OK, "save failed (0x%08x)\n", r);
}
+
+ /* test GetCurFile after ::Save */
+ r = IPersistFile_GetCurFile(pf, &str);
+ lok(r == S_OK, "got 0x%08x\n", r);
+ lok(str != NULL ||
+ broken(str == NULL), /* shell32 < 5.0 */
+ "Didn't expect NULL\n");
+ if (str != NULL)
+ {
+ IMalloc *pmalloc;
+
+ lok(!winetest_strcmpW(path, str), "Expected %s, got %s\n",
+ wine_dbgstr_w(path), wine_dbgstr_w(str));
+
+ SHGetMalloc(&pmalloc);
+ IMalloc_Free(pmalloc, str);
+ }
+ else
+ win_skip("GetCurFile fails on shell32 < 5.0\n");
+
IPersistFile_Release(pf);
}
IShellLinkA *sl;
IPersistFile *pf;
char buffer[INFOTIPSIZE];
+ LPOLESTR str;
r = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellLinkA, (LPVOID*)&sl);
- lok(SUCCEEDED(r), "no IID_IShellLinkA (0x%08x)\n", r);
- if (FAILED(r))
+ lok(r == S_OK, "no IID_IShellLinkA (0x%08x)\n", r);
+ if (r != S_OK)
return;
r = IShellLinkA_QueryInterface(sl, &IID_IPersistFile, (LPVOID*)&pf);
- lok(SUCCEEDED(r), "no IID_IPersistFile (0x%08x)\n", r);
- if (FAILED(r))
+ lok(r == S_OK, "no IID_IPersistFile (0x%08x)\n", r);
+ if (r != S_OK)
{
IShellLinkA_Release(sl);
return;
}
+ /* test GetCurFile before ::Load */
+ str = (LPWSTR)0xdeadbeef;
+ r = IPersistFile_GetCurFile(pf, &str);
+ lok(r == S_FALSE ||
+ broken(r == S_OK), /* shell32 < 5.0 */
+ "got 0x%08x\n", r);
+ lok(str == NULL, "got %p\n", str);
+
r = IPersistFile_Load(pf, path, STGM_READ);
- lok(SUCCEEDED(r), "load failed (0x%08x)\n", r);
+ lok(r == S_OK, "load failed (0x%08x)\n", r);
+
+ /* test GetCurFile after ::Save */
+ r = IPersistFile_GetCurFile(pf, &str);
+ lok(r == S_OK, "got 0x%08x\n", r);
+ lok(str != NULL ||
+ broken(str == NULL), /* shell32 < 5.0 */
+ "Didn't expect NULL\n");
+ if (str != NULL)
+ {
+ IMalloc *pmalloc;
+
+ lok(!winetest_strcmpW(path, str), "Expected %s, got %s\n",
+ wine_dbgstr_w(path), wine_dbgstr_w(str));
+
+ SHGetMalloc(&pmalloc);
+ IMalloc_Free(pmalloc, str);
+ }
+ else
+ win_skip("GetCurFile fails on shell32 < 5.0\n");
+
IPersistFile_Release(pf);
- if (FAILED(r))
+ if (r != S_OK)
{
IShellLinkA_Release(sl);
return;
{
strcpy(buffer,"garbage");
r = IShellLinkA_GetDescription(sl, buffer, sizeof(buffer));
- lok(SUCCEEDED(r), "GetDescription failed (0x%08x)\n", r);
+ lok(r == S_OK, "GetDescription failed (0x%08x)\n", r);
lok_todo_4(0x1, lstrcmp(buffer, desc->description)==0,
"GetDescription returned '%s' instead of '%s'\n",
buffer, desc->description);
{
strcpy(buffer,"garbage");
r = IShellLinkA_GetWorkingDirectory(sl, buffer, sizeof(buffer));
- lok(SUCCEEDED(r), "GetWorkingDirectory failed (0x%08x)\n", r);
+ lok(r == S_OK, "GetWorkingDirectory failed (0x%08x)\n", r);
lok_todo_4(0x2, lstrcmpi(buffer, desc->workdir)==0,
"GetWorkingDirectory returned '%s' instead of '%s'\n",
buffer, desc->workdir);
{
LPITEMIDLIST pidl=NULL;
r = IShellLinkA_GetIDList(sl, &pidl);
- lok(SUCCEEDED(r), "GetIDList failed (0x%08x)\n", r);
+ lok(r == S_OK, "GetIDList failed (0x%08x)\n", r);
lok_todo_2(0x8, pILIsEqual(pidl, desc->pidl),
"GetIDList returned an incorrect pidl\n");
}
{
int i=0xdeadbeef;
r = IShellLinkA_GetShowCmd(sl, &i);
- lok(SUCCEEDED(r), "GetShowCmd failed (0x%08x)\n", r);
+ lok(r == S_OK, "GetShowCmd failed (0x%08x)\n", r);
lok_todo_4(0x10, i==desc->showcmd,
"GetShowCmd returned 0x%0x instead of 0x%0x\n",
i, desc->showcmd);
int i=0xdeadbeef;
strcpy(buffer,"garbage");
r = IShellLinkA_GetIconLocation(sl, buffer, sizeof(buffer), &i);
- lok(SUCCEEDED(r), "GetIconLocation failed (0x%08x)\n", r);
+ lok(r == S_OK, "GetIconLocation failed (0x%08x)\n", r);
lok_todo_4(0x20, lstrcmpi(buffer, desc->icon)==0,
"GetIconLocation returned '%s' instead of '%s'\n",
buffer, desc->icon);
{
WORD i=0xbeef;
r = IShellLinkA_GetHotkey(sl, &i);
- lok(SUCCEEDED(r), "GetHotkey failed (0x%08x)\n", r);
+ lok(r == S_OK, "GetHotkey failed (0x%08x)\n", r);
lok_todo_4(0x40, i==desc->hotkey,
"GetHotkey returned 0x%04x instead of 0x%04x\n",
i, desc->hotkey);
r = IShellLinkW_SetPath(sl, lnk);
ok(r == S_OK, "set path failed\n");
- /*
- * The following crashes:
- * r = IShellLinkDataList_GetFlags( dl, NULL );
- */
+if (0)
+{
+ /* the following crashes */
+ r = IShellLinkDataList_GetFlags( dl, NULL );
+}
flags = 0;
r = IShellLinkDataList_GetFlags( dl, &flags );
pGetShortPathNameA = (void *)GetProcAddress(hkernel32, "GetShortPathNameA");
r = CoInitialize(NULL);
- ok(SUCCEEDED(r), "CoInitialize failed (0x%08x)\n", r);
- if (FAILED(r))
+ ok(r == S_OK, "CoInitialize failed (0x%08x)\n", r);
+ if (r != S_OK)
return;
test_get_set();
{
HRESULT hr = pSHGetMalloc(&pMalloc);
- ok(SUCCEEDED(hr), "SHGetMalloc failed: 0x%08x\n", hr);
+ ok(hr == S_OK, "SHGetMalloc failed: 0x%08x\n", hr);
ok(pMalloc != NULL, "SHGetMalloc returned a NULL IMalloc\n");
}
return guidSTR;
}
-static void testSHGetFolderLocationInvalidArgs(void)
-{
- LPITEMIDLIST pidl;
- HRESULT hr;
-
- if (!pSHGetFolderLocation) return;
-
- /* check a bogus CSIDL: */
- pidl = NULL;
- hr = pSHGetFolderLocation(NULL, 0xeeee, NULL, 0, &pidl);
- ok(hr == E_INVALIDARG,
- "SHGetFolderLocation(NULL, 0xeeee, NULL, 0, &pidl) returned 0x%08x, expected E_INVALIDARG\n", hr);
- if (SUCCEEDED(hr))
- IMalloc_Free(pMalloc, pidl);
- /* check a bogus user token: */
- pidl = NULL;
- hr = pSHGetFolderLocation(NULL, CSIDL_FAVORITES, (HANDLE)2, 0, &pidl);
- ok(hr == E_FAIL || hr == E_HANDLE,
- "SHGetFolderLocation(NULL, CSIDL_FAVORITES, 2, 0, &pidl) returned 0x%08x, expected E_FAIL or E_HANDLE\n", hr);
- if (SUCCEEDED(hr))
- IMalloc_Free(pMalloc, pidl);
- /* a NULL pidl pointer crashes, so don't test it */
-}
-
-static void testSHGetSpecialFolderLocationInvalidArgs(void)
+static void test_parameters(void)
{
LPITEMIDLIST pidl = NULL;
+ char path[MAX_PATH];
HRESULT hr;
- if (!pSHGetSpecialFolderLocation) return;
+ if (pSHGetFolderLocation)
+ {
+ /* check a bogus CSIDL: */
+ pidl = NULL;
+ hr = pSHGetFolderLocation(NULL, 0xeeee, NULL, 0, &pidl);
+ ok(hr == E_INVALIDARG, "got 0x%08x, expected E_INVALIDARG\n", hr);
+ if (hr == S_OK) IMalloc_Free(pMalloc, pidl);
+
+ /* check a bogus user token: */
+ pidl = NULL;
+ hr = pSHGetFolderLocation(NULL, CSIDL_FAVORITES, (HANDLE)2, 0, &pidl);
+ ok(hr == E_FAIL || hr == E_HANDLE, "got 0x%08x, expected E_FAIL or E_HANDLE\n", hr);
+ if (hr == S_OK) IMalloc_Free(pMalloc, pidl);
+
+ /* a NULL pidl pointer crashes, so don't test it */
+ }
- /* SHGetSpecialFolderLocation(NULL, 0, NULL) crashes */
- hr = pSHGetSpecialFolderLocation(NULL, 0xeeee, &pidl);
- ok(hr == E_INVALIDARG,
- "SHGetSpecialFolderLocation(NULL, 0xeeee, &pidl) returned 0x%08x, "
- "expected E_INVALIDARG\n", hr);
-}
+ if (pSHGetSpecialFolderLocation)
+ {
+ if (0)
+ /* crashes */
+ SHGetSpecialFolderLocation(NULL, 0, NULL);
-static void testSHGetFolderPathInvalidArgs(void)
-{
- char path[MAX_PATH];
- HRESULT hr;
+ hr = pSHGetSpecialFolderLocation(NULL, 0xeeee, &pidl);
+ ok(hr == E_INVALIDARG, "got returned 0x%08x\n", hr);
+ }
- if (!pSHGetFolderPathA) return;
+ if (pSHGetFolderPathA)
+ {
+ /* expect 2's a bogus handle, especially since we didn't open it */
+ hr = pSHGetFolderPathA(NULL, CSIDL_DESKTOP, (HANDLE)2, SHGFP_TYPE_DEFAULT, path);
+ ok(hr == E_FAIL || hr == E_HANDLE || /* Vista and 2k8 */
+ broken(hr == S_OK), /* W2k and Me */ "got 0x%08x, expected E_FAIL\n", hr);
- /* expect 2's a bogus handle, especially since we didn't open it */
- hr = pSHGetFolderPathA(NULL, CSIDL_DESKTOP, (HANDLE)2,
- SHGFP_TYPE_DEFAULT, path);
- ok(hr == E_FAIL ||
- hr == E_HANDLE || /* Windows Vista and 2008 */
- broken(hr == S_OK), /* Windows 2000 and Me */
- "SHGetFolderPathA(NULL, CSIDL_DESKTOP, 2, SHGFP_TYPE_DEFAULT, path) returned 0x%08x, expected E_FAIL\n", hr);
- hr = pSHGetFolderPathA(NULL, 0xeeee, NULL, SHGFP_TYPE_DEFAULT, path);
- ok(hr == E_INVALIDARG,
- "SHGetFolderPathA(NULL, 0xeeee, NULL, SHGFP_TYPE_DEFAULT, path) returned 0x%08x, expected E_INVALIDARG\n", hr);
-}
+ hr = pSHGetFolderPathA(NULL, 0xeeee, NULL, SHGFP_TYPE_DEFAULT, path);
+ ok(hr == E_INVALIDARG, "got 0x%08x, expected E_INVALIDARG\n", hr);
+ }
-static void testSHGetSpecialFolderPathInvalidArgs(void)
-{
- char path[MAX_PATH];
- BOOL ret;
+ if (pSHGetSpecialFolderPathA)
+ {
+ BOOL ret;
- if (!pSHGetSpecialFolderPathA) return;
+ if (0)
+ ret = pSHGetSpecialFolderPathA(NULL, NULL, CSIDL_BITBUCKET, FALSE);
-#if 0
- ret = pSHGetSpecialFolderPathA(NULL, NULL, CSIDL_BITBUCKET, FALSE);
- ok(!ret,
- "SHGetSpecialFolderPathA(NULL, NULL, CSIDL_BITBUCKET, FALSE) returned TRUE, expected FALSE\n");
-#endif
- /* odd but true: calling with a NULL path still succeeds if it's a real
- * dir (on some windows platform). on winME it generates exception.
- */
- ret = pSHGetSpecialFolderPathA(NULL, path, CSIDL_PROGRAMS, FALSE);
- ok(ret,
- "SHGetSpecialFolderPathA(NULL, path, CSIDL_PROGRAMS, FALSE) returned FALSE, expected TRUE\n");
- ret = pSHGetSpecialFolderPathA(NULL, path, 0xeeee, FALSE);
- ok(!ret,
- "SHGetSpecialFolderPathA(NULL, path, 0xeeee, FALSE) returned TRUE, expected FALSE\n");
-}
+ /* odd but true: calling with a NULL path still succeeds if it's a real
+ * dir (on some windows platform). on winME it generates exception.
+ */
+ ret = pSHGetSpecialFolderPathA(NULL, path, CSIDL_PROGRAMS, FALSE);
+ ok(ret, "got %d\n", ret);
-static void testApiParameters(void)
-{
- testSHGetFolderLocationInvalidArgs();
- testSHGetSpecialFolderLocationInvalidArgs();
- testSHGetFolderPathInvalidArgs();
- testSHGetSpecialFolderPathInvalidArgs();
+ ret = pSHGetSpecialFolderPathA(NULL, path, 0xeeee, FALSE);
+ ok(!ret, "got %d\n", ret);
+ }
}
/* Returns the folder's PIDL type, or 0xff if one can't be found. */
pidl = NULL;
hr = pSHGetFolderLocation(NULL, folder, NULL, 0, &pidl);
- if (SUCCEEDED(hr))
+ if (hr == S_OK)
{
if (pidl)
{
pidl = NULL;
hr = pSHGetSpecialFolderLocation(NULL, folder, &pidl);
- if (SUCCEEDED(hr))
+ if (hr == S_OK)
{
if (pidl)
{
return ret;
}
-static void testSHGetFolderPath(BOOL optional, int folder)
+static void test_SHGetFolderPath(BOOL optional, int folder)
{
char path[MAX_PATH];
HRESULT hr;
if (!pSHGetFolderPathA) return;
hr = pSHGetFolderPathA(NULL, folder, NULL, SHGFP_TYPE_CURRENT, path);
- ok(SUCCEEDED(hr) || optional,
+ ok(hr == S_OK || optional,
"SHGetFolderPathA(NULL, %s, NULL, SHGFP_TYPE_CURRENT, path) failed: 0x%08x\n", getFolderName(folder), hr);
}
-static void testSHGetSpecialFolderPath(BOOL optional, int folder)
+static void test_SHGetSpecialFolderPath(BOOL optional, int folder)
{
char path[MAX_PATH];
BOOL ret;
getFolderName(folder));
}
-static void testShellValues(const struct shellExpectedValues testEntries[],
+static void test_ShellValues(const struct shellExpectedValues testEntries[],
int numEntries, BOOL optional)
{
int i;
case PT_DRIVE:
case PT_DRIVE2:
case PT_IESPECIAL2:
- testSHGetFolderPath(optional, testEntries[i].folder);
- testSHGetSpecialFolderPath(optional, testEntries[i].folder);
+ test_SHGetFolderPath(optional, testEntries[i].folder);
+ test_SHGetSpecialFolderPath(optional, testEntries[i].folder);
break;
}
}
pidl = NULL;
hr = pSHGetFolderLocation(NULL, folder, NULL, 0, &pidl);
- if (SUCCEEDED(hr))
+ if (hr == S_OK)
{
LPITEMIDLIST pidlLast = pILFindLastID(pidl);
}
}
-static void testDesktop(void)
-{
- testSHGetFolderPath(FALSE, CSIDL_DESKTOP);
- testSHGetSpecialFolderPath(FALSE, CSIDL_DESKTOP);
-}
-
/* Checks the PIDL type of all the known values. */
-static void testPidlTypes(void)
+static void test_PidlTypes(void)
{
- testDesktop();
- testShellValues(requiredShellValues, ARRAY_SIZE(requiredShellValues),
- FALSE);
- testShellValues(optionalShellValues, ARRAY_SIZE(optionalShellValues),
- TRUE);
+ /* Desktop */
+ test_SHGetFolderPath(FALSE, CSIDL_DESKTOP);
+ test_SHGetSpecialFolderPath(FALSE, CSIDL_DESKTOP);
+
+ test_ShellValues(requiredShellValues, ARRAY_SIZE(requiredShellValues), FALSE);
+ test_ShellValues(optionalShellValues, ARRAY_SIZE(optionalShellValues), TRUE);
}
/* FIXME: Should be in shobjidl.idl */
DEFINE_GUID(CLSID_NetworkExplorerFolder, 0xF02C1A0D, 0xBE21, 0x4350, 0x88, 0xB0, 0x73, 0x67, 0xFC, 0x96, 0xEF, 0x3C);
/* Verifies various shell virtual folders have the correct well-known GUIDs. */
-static void testGUIDs(void)
+static void test_GUIDs(void)
{
matchGUID(CSIDL_BITBUCKET, &CLSID_RecycleBin, NULL);
matchGUID(CSIDL_CONTROLS, &CLSID_ControlPanel, NULL);
matchGUID(CSIDL_NETWORK, &CLSID_NetworkPlaces, &CLSID_NetworkExplorerFolder); /* Vista and higher */
matchGUID(CSIDL_PERSONAL, &CLSID_MyDocuments, NULL);
matchGUID(CSIDL_COMMON_DOCUMENTS, &CLSID_CommonDocuments, NULL);
+ matchGUID(CSIDL_PRINTERS, &CLSID_Printers, NULL);
}
/* Verifies various shell paths match the environment variables to which they
* correspond.
*/
-static void testEnvVars(void)
+static void test_EnvVars(void)
{
matchSpecialFolderPathToEnv(CSIDL_PROGRAM_FILES, "ProgramFiles");
matchSpecialFolderPathToEnv(CSIDL_APPDATA, "APPDATA");
matchSpecialFolderPathToEnv(CSIDL_PROFILE, "USERPROFILE");
matchSpecialFolderPathToEnv(CSIDL_WINDOWS, "SystemRoot");
matchSpecialFolderPathToEnv(CSIDL_WINDOWS, "windir");
- matchSpecialFolderPathToEnv(CSIDL_PROGRAM_FILES_COMMON,
- "CommonProgramFiles");
+ matchSpecialFolderPathToEnv(CSIDL_PROGRAM_FILES_COMMON, "CommonProgramFiles");
/* this is only set on Wine, but can't hurt to verify it: */
matchSpecialFolderPathToEnv(CSIDL_SYSTEM, "winsysdir");
}
return 1;
}
-/* Subprocess helper 1: test what happens when CSIDL_FAVORITES is set to a
- * nonexistent directory.
- */
-static void testNonExistentPath1(void)
+static void doChild(const char *arg)
{
+ char path[MAX_PATH];
HRESULT hr;
- LPITEMIDLIST pidl;
- char *p, path[MAX_PATH];
- /* test some failure cases first: */
- hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES, NULL,
- SHGFP_TYPE_CURRENT, path);
- ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
- "SHGetFolderPath returned 0x%08x, expected 0x80070002\n", hr);
- pidl = NULL;
- hr = pSHGetFolderLocation(NULL, CSIDL_FAVORITES, NULL, 0,
- &pidl);
- ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
- "SHGetFolderLocation returned 0x%08x\n", hr);
- if (SUCCEEDED(hr) && pidl)
- IMalloc_Free(pMalloc, pidl);
- ok(!pSHGetSpecialFolderPathA(NULL, path, CSIDL_FAVORITES, FALSE),
- "SHGetSpecialFolderPath succeeded, expected failure\n");
- pidl = NULL;
- hr = pSHGetSpecialFolderLocation(NULL, CSIDL_FAVORITES, &pidl);
- ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
- "SHGetFolderLocation returned 0x%08x\n", hr);
- if (SUCCEEDED(hr) && pidl)
- IMalloc_Free(pMalloc, pidl);
- /* now test success: */
- hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, NULL,
- SHGFP_TYPE_CURRENT, path);
- if (SUCCEEDED(hr))
+ if (arg[0] == '1')
{
- BOOL ret;
+ LPITEMIDLIST pidl;
+ char *p;
- trace("CSIDL_FAVORITES was changed to %s\n", path);
- ret = CreateDirectoryA(path, NULL);
- ok(!ret,
- "CreateDirectoryA succeeded but should have failed "
- "with ERROR_ALREADY_EXISTS\n");
- if (!ret)
- ok(GetLastError() == ERROR_ALREADY_EXISTS,
- "CreateDirectoryA failed with %d, "
- "expected ERROR_ALREADY_EXISTS\n",
- GetLastError());
- p = path + strlen(path);
- strcpy(p, "\\desktop.ini");
- DeleteFileA(path);
- *p = 0;
- SetFileAttributesA( path, FILE_ATTRIBUTE_NORMAL );
- ret = RemoveDirectoryA(path);
- ok( ret, "failed to remove %s error %u\n", path, GetLastError() );
- }
- ok(SUCCEEDED(hr),
- "SHGetFolderPath(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, "
- "NULL, SHGFP_TYPE_CURRENT, path) failed: 0x%08x\n", hr);
-}
+ /* test what happens when CSIDL_FAVORITES is set to a nonexistent directory */
-/* Subprocess helper 2: make sure SHGetFolderPath still succeeds when the
- * original value of CSIDL_FAVORITES is restored.
- */
-static void testNonExistentPath2(void)
-{
- HRESULT hr;
- char path[MAX_PATH];
+ /* test some failure cases first: */
+ hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES, NULL, SHGFP_TYPE_CURRENT, path);
+ ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
+ "SHGetFolderPath returned 0x%08x, expected 0x80070002\n", hr);
- hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, NULL,
- SHGFP_TYPE_CURRENT, path);
- ok(SUCCEEDED(hr), "SHGetFolderPath failed: 0x%08x\n", hr);
-}
+ pidl = NULL;
+ hr = pSHGetFolderLocation(NULL, CSIDL_FAVORITES, NULL, 0, &pidl);
+ ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
+ "SHGetFolderLocation returned 0x%08x\n", hr);
+ if (hr == S_OK && pidl) IMalloc_Free(pMalloc, pidl);
-static void doChild(const char *arg)
-{
- if (arg[0] == '1')
- testNonExistentPath1();
+ ok(!pSHGetSpecialFolderPathA(NULL, path, CSIDL_FAVORITES, FALSE),
+ "SHGetSpecialFolderPath succeeded, expected failure\n");
+
+ pidl = NULL;
+ hr = pSHGetSpecialFolderLocation(NULL, CSIDL_FAVORITES, &pidl);
+ ok(hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
+ "SHGetFolderLocation returned 0x%08x\n", hr);
+
+ if (hr == S_OK && pidl) IMalloc_Free(pMalloc, pidl);
+
+ /* now test success: */
+ hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, NULL,
+ SHGFP_TYPE_CURRENT, path);
+ ok (hr == S_OK, "got 0x%08x\n", hr);
+ if (hr == S_OK)
+ {
+ BOOL ret;
+
+ trace("CSIDL_FAVORITES was changed to %s\n", path);
+ ret = CreateDirectoryA(path, NULL);
+ ok(!ret, "expected failure with ERROR_ALREADY_EXISTS\n");
+ if (!ret)
+ ok(GetLastError() == ERROR_ALREADY_EXISTS,
+ "got %d, expected ERROR_ALREADY_EXISTS\n", GetLastError());
+
+ p = path + strlen(path);
+ strcpy(p, "\\desktop.ini");
+ DeleteFileA(path);
+ *p = 0;
+ SetFileAttributesA( path, FILE_ATTRIBUTE_NORMAL );
+ ret = RemoveDirectoryA(path);
+ ok( ret, "failed to remove %s error %u\n", path, GetLastError() );
+ }
+ }
else if (arg[0] == '2')
- testNonExistentPath2();
+ {
+ /* make sure SHGetFolderPath still succeeds when the
+ original value of CSIDL_FAVORITES is restored. */
+ hr = pSHGetFolderPathA(NULL, CSIDL_FAVORITES | CSIDL_FLAG_CREATE, NULL,
+ SHGFP_TYPE_CURRENT, path);
+ ok(hr == S_OK, "SHGetFolderPath failed: 0x%08x\n", hr);
+ }
}
/* Tests the return values from the various shell functions both with and
* covered by other unit tests; I just print out something about failure to
* help trace what's going on.
*/
-static void testNonExistentPath(void)
+static void test_NonExistentPath(void)
{
static const char userShellFolders[] =
"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders";
loadShell32();
pGetSystemWow64DirectoryA = (void *)GetProcAddress( GetModuleHandleA("kernel32.dll"),
"GetSystemWow64DirectoryA" );
-
if (myARGC >= 3)
doChild(myARGV[2]);
else
win_skip("SHGetFolderLocation is not available\n");
/* first test various combinations of parameters: */
- testApiParameters();
+ test_parameters();
/* check known values: */
- testPidlTypes();
- testGUIDs();
- testEnvVars();
+ test_PidlTypes();
+ test_GUIDs();
+ test_EnvVars();
testWinDir();
testSystemDir();
- testNonExistentPath();
+ test_NonExistentPath();
}
}
+++ /dev/null
-/*
- * Tests for My Network Places shell folder
- *
- * Copyright 2008 Robert Shearman 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
- */
-
-#include <stdarg.h>
-#include <stdio.h>
-
-#define COBJMACROS
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include "shellapi.h"
-#include "shlobj.h"
-
-#include "wine/test.h"
-
-static void test_parse_for_entire_network(void)
-{
- static const WCHAR entire_network_path[] = {
- ':',':','{','2','0','8','D','2','C','6','0','-','3','A','E','A','-',
- '1','0','6','9','-','A','2','D','7','-','0','8','0','0','2','B','3','0','3','0','9','D',
- '}','\\','E','n','t','i','r','e','N','e','t','w','o','r','k',0 };
- IShellFolder *psfDesktop;
- HRESULT hr;
- DWORD eaten = 0xdeadbeef;
- LPITEMIDLIST pidl;
- DWORD attr = ~0;
- DWORD expected_attr;
-
- hr = SHGetDesktopFolder(&psfDesktop);
- ok(hr == S_OK, "SHGetDesktopFolder failed with error 0x%x\n", hr);
-
- hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, (LPWSTR)entire_network_path, &eaten, &pidl, &attr);
- ok(hr == S_OK, "IShellFolder_ParseDisplayName failed with error 0x%x\n", hr);
- todo_wine
- ok(eaten == 0xdeadbeef, "eaten should not have been set to %u\n", eaten);
- expected_attr = SFGAO_HASSUBFOLDER|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR|SFGAO_STORAGEANCESTOR|SFGAO_HASPROPSHEET|SFGAO_CANLINK;
- todo_wine
- ok(attr == expected_attr, "attr should be 0x%x, not 0x%x\n", expected_attr, attr);
-
- ILFree(pidl);
-}
-
-
-START_TEST(shfldr_netplaces)
-{
- test_parse_for_entire_network();
-}
#include <stdio.h>
#define COBJMACROS
+#define NONAMELESSUNION
+#define NONAMELESSSTRUCT
+
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "shellapi.h"
#include "wine/test.h"
+static inline BOOL SHELL_OsIsUnicode(void)
+{
+ return !(GetVersion() & 0x80000000);
+}
+
/* Tests for My Network Places */
static void test_parse_for_entire_network(void)
{
ILFree(pidl);
}
+static void test_printers_folder(void)
+{
+ IShellFolder2 *folder;
+ IPersistFolder2 *pf;
+ SHELLDETAILS details;
+ SHCOLSTATEF state;
+ LPITEMIDLIST pidl1, pidl2;
+ HRESULT hr;
+ INT i;
+
+ CoInitialize( NULL );
+
+ hr = CoCreateInstance(&CLSID_Printers, NULL, CLSCTX_INPROC_SERVER, &IID_IShellFolder2, (void**)&folder);
+ if (hr != S_OK)
+ {
+ win_skip("Failed to created IShellFolder2 for Printers folder\n");
+ CoUninitialize();
+ return;
+ }
+
+if (0)
+{
+ /* crashes on XP */
+ hr = IShellFolder2_GetDetailsOf(folder, NULL, 0, NULL);
+ hr = IShellFolder2_GetDefaultColumnState(folder, 0, NULL);
+ hr = IPersistFolder2_GetCurFolder(pf, NULL);
+}
+
+ /* 5 columns defined */
+ hr = IShellFolder2_GetDetailsOf(folder, NULL, 6, &details);
+ ok(hr == E_NOTIMPL, "got 0x%08x\n", hr);
+
+ hr = IShellFolder2_GetDefaultColumnState(folder, 6, &state);
+ ok(broken(hr == E_NOTIMPL) || hr == E_INVALIDARG /* Win7 */, "got 0x%08x\n", hr);
+
+ hr = IShellFolder2_GetDetailsOf(folder, NULL, 0, &details);
+ ok(hr == S_OK || broken(E_NOTIMPL) /* W2K */, "got 0x%08x\n", hr);
+ /* test every column if method is implemented */
+ if (hr == S_OK)
+ {
+ ok(details.str.uType == STRRET_WSTR, "got %d\n", details.str.uType);
+
+ for(i = 0; i < 6; i++)
+ {
+ hr = IShellFolder2_GetDetailsOf(folder, NULL, i, &details);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ /* all columns are left-aligned */
+ ok(details.fmt == LVCFMT_LEFT, "got 0x%x\n", details.fmt);
+ /* can't be on w9x at this point, IShellFolder2 unsupported there,
+ check present for running Wine with w9x setup */
+ if (SHELL_OsIsUnicode()) SHFree(details.str.u.pOleStr);
+
+ hr = IShellFolder2_GetDefaultColumnState(folder, i, &state);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+ /* all columns are string except document count */
+ if (i == 1)
+ ok(state == (SHCOLSTATE_TYPE_INT | SHCOLSTATE_ONBYDEFAULT), "got 0x%x\n", state);
+ else
+ ok(state == (SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT), "got 0x%x\n", state);
+ }
+ }
+
+ /* default pidl */
+ hr = IShellFolder2_QueryInterface(folder, &IID_IPersistFolder2, (void**)&pf);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ /* not initialized */
+ pidl1 = (void*)0xdeadbeef;
+ hr = IPersistFolder2_GetCurFolder(pf, &pidl1);
+ ok(hr == S_FALSE, "got 0x%08x\n", hr);
+ ok(pidl1 == NULL, "got %p\n", pidl1);
+
+ hr = SHGetSpecialFolderLocation(NULL, CSIDL_PRINTERS, &pidl2);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IPersistFolder2_Initialize(pf, pidl2);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ hr = IPersistFolder2_GetCurFolder(pf, &pidl1);
+ ok(hr == S_OK, "got 0x%08x\n", hr);
+
+ ok(ILIsEqual(pidl1, pidl2), "expected same PIDL\n");
+ IPersistFolder2_Release(pf);
+
+ ILFree(pidl1);
+ ILFree(pidl2);
+ IShellFolder2_Release(folder);
+
+ CoUninitialize();
+}
START_TEST(shfldr_special)
{
test_parse_for_entire_network();
test_parse_for_control_panel();
+ test_printers_folder();
}
"%s\\test file.sde",
"%s\\test file.exe",
"%s\\test2.exe",
+ "%s\\simple.shlexec",
+ "%s\\drawback_file.noassoc",
+ "%s\\drawback_file.noassoc foo.shlexec",
+ "%s\\drawback_nonexist.noassoc foo.shlexec",
NULL
};
{NULL, NULL, 0}
};
+static void test_lpFile_parsed(void)
+{
+ /* basename tmpdir */
+ const char* shorttmpdir;
+
+ const char *testfile;
+ char fileA[MAX_PATH];
+
+ int rc;
+
+ GetTempPathA(sizeof(fileA), fileA);
+ shorttmpdir = tmpdir + strlen(fileA);
+
+ /* ensure tmpdir is in %TEMP%: GetTempPath() can succeed even if TEMP is undefined */
+ SetEnvironmentVariableA("TEMP", fileA);
+
+ /* existing "drawback_file.noassoc" prevents finding "drawback_file.noassoc foo.shlexec" on wine */
+ testfile = "%s\\drawback_file.noassoc foo.shlexec";
+ sprintf(fileA, testfile, tmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ todo_wine {
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ }
+
+ /* if quoted, existing "drawback_file.noassoc" not prevents finding "drawback_file.noassoc foo.shlexec" on wine */
+ testfile = "\"%s\\drawback_file.noassoc foo.shlexec\"";
+ sprintf(fileA, testfile, tmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ ok(rc>32 || broken(rc == 2) /* Win95/NT4 */,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+
+ /* error should be 2, not 31 */
+ testfile = "\"%s\\drawback_file.noassoc\" foo.shlexec";
+ sprintf(fileA, testfile, tmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ ok(rc==2,
+ "expected failure (2), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+
+ /* ""command"" not works on wine (and real win9x and w2k) */
+ testfile = "\"\"%s\\simple.shlexec\"\"";
+ sprintf(fileA, testfile, tmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ todo_wine {
+ ok(rc>32 || broken(rc == 2) /* Win9x/2000 */,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ }
+
+ /* nonexisting "drawback_nonexist.noassoc" not prevents finding "drawback_nonexist.noassoc foo.shlexec" on wine */
+ testfile = "%s\\drawback_nonexist.noassoc foo.shlexec";
+ sprintf(fileA, testfile, tmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+
+ /* is SEE_MASK_DOENVSUBST default flag? Should only be when XP emulates 9x (XP bug or real 95 or ME behavior ?) */
+ testfile = "%%TEMP%%\\%s\\simple.shlexec";
+ sprintf(fileA, testfile, shorttmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ todo_wine {
+ ok(rc==2,
+ "expected failure (2), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ }
+
+ /* quoted */
+ testfile = "\"%%TEMP%%\\%s\\simple.shlexec\"";
+ sprintf(fileA, testfile, shorttmpdir);
+ rc=shell_execute(NULL, fileA, NULL, NULL);
+ todo_wine {
+ ok(rc==2,
+ "expected failure (2), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ }
+
+ /* test SEE_MASK_DOENVSUBST works */
+ testfile = "%%TEMP%%\\%s\\simple.shlexec";
+ sprintf(fileA, testfile, shorttmpdir);
+ rc=shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI, NULL, fileA, NULL, NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+
+ /* quoted lpFile not works only on real win95 and nt4 */
+ testfile = "\"%%TEMP%%\\%s\\simple.shlexec\"";
+ sprintf(fileA, testfile, shorttmpdir);
+ rc=shell_execute_ex(SEE_MASK_DOENVSUBST | SEE_MASK_FLAG_NO_UI, NULL, fileA, NULL, NULL);
+ ok(rc>32 || broken(rc == 2) /* Win95/NT4 */,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+
+}
+
+static void test_argify(void)
+{
+ char fileA[MAX_PATH];
+
+ int rc;
+
+ sprintf(fileA, "%s\\test file.shlexec", tmpdir);
+
+ /* %2 */
+ rc=shell_execute("NoQuotesParam2", fileA, "a b", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ okChildInt("argcA", 5);
+ okChildString("argvA4", "a");
+ }
+
+ /* %2 */
+ /* '"a"""' -> 'a"' */
+ rc=shell_execute("NoQuotesParam2", fileA, "\"a:\"\"some string\"\"\"", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ okChildInt("argcA", 5);
+ todo_wine {
+ okChildString("argvA4", "a:some string");
+ }
+ }
+
+ /* %2 */
+ /* backslash isn't escape char
+ * '"a\""' -> '"a\""' */
+ rc=shell_execute("NoQuotesParam2", fileA, "\"a:\\\"some string\\\"\"", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ okChildInt("argcA", 5);
+ todo_wine {
+ okChildString("argvA4", "a:\\");
+ }
+ }
+
+ /* "%2" */
+ /* \t isn't whitespace */
+ rc=shell_execute("QuotedParam2", fileA, "a\tb c", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ okChildInt("argcA", 5);
+ todo_wine {
+ okChildString("argvA4", "a\tb");
+ }
+ }
+
+ /* %* */
+ rc=shell_execute("NoQuotesAllParams", fileA, "a b c d e f g h", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ todo_wine {
+ okChildInt("argcA", 12);
+ okChildString("argvA4", "a");
+ okChildString("argvA11", "h");
+ }
+ }
+
+ /* %* can sometimes contain only whitespaces and no args */
+ rc=shell_execute("QuotedAllParams", fileA, " ", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ todo_wine {
+ okChildInt("argcA", 5);
+ okChildString("argvA4", " ");
+ }
+ }
+
+ /* %~3 */
+ rc=shell_execute("NoQuotesParams345etc", fileA, "a b c d e f g h", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ todo_wine {
+ okChildInt("argcA", 11);
+ okChildString("argvA4", "b");
+ okChildString("argvA10", "h");
+ }
+ }
+
+ /* %~3 is rest of command line starting with whitespaces after 2nd arg */
+ rc=shell_execute("QuotedParams345etc", fileA, "a ", NULL);
+ ok(rc>32,
+ "expected success (33), got %s (%d), lpFile: %s\n",
+ rc > 32 ? "success" : "failure", rc, fileA
+ );
+ if (rc>32)
+ {
+ okChildInt("argcA", 5);
+ todo_wine {
+ okChildString("argvA4", " ");
+ }
+ }
+
+}
+
static void test_filename(void)
{
char filename[MAX_PATH];
}
r = CoInitialize(NULL);
- ok(SUCCEEDED(r), "CoInitialize failed (0x%08x)\n", r);
+ ok(r == S_OK, "CoInitialize failed (0x%08x)\n", r);
if (FAILED(r))
exit(1);
create_test_verb(".shlexec", "QuotedLowerL", 0, "QuotedLowerL \"%l\"");
create_test_verb(".shlexec", "UpperL", 0, "UpperL %L");
create_test_verb(".shlexec", "QuotedUpperL", 0, "QuotedUpperL \"%L\"");
+
+ create_test_verb(".shlexec", "NoQuotesParam2", 0, "NoQuotesParam2 %2");
+ create_test_verb(".shlexec", "QuotedParam2", 0, "QuotedParam2 \"%2\"");
+
+ create_test_verb(".shlexec", "NoQuotesAllParams", 0, "NoQuotesAllParams %*");
+ create_test_verb(".shlexec", "QuotedAllParams", 0, "QuotedAllParams \"%*\"");
+
+ create_test_verb(".shlexec", "NoQuotesParams345etc", 0, "NoQuotesParams345etc %~3");
+ create_test_verb(".shlexec", "QuotedParams345etc", 0, "QuotedParams345etc \"%~3\"");
}
static void cleanup_test(void)
init_test();
+ test_argify();
+ test_lpFile_parsed();
test_filename();
test_find_executable();
test_lnks();
{
HMODULE hmod;
HRESULT hr;
+ void *ptr;
hmod = GetModuleHandleA("shell32.dll");
MAKEFUNC_ORD(ILFree, 155);
#undef MAKEFUNC_ORD
+ /* test named exports */
+ ptr = GetProcAddress(hmod, "ILFree");
+ ok(broken(ptr == 0) || ptr != 0, "expected named export for ILFree\n");
+ if (ptr)
+ {
+#define TESTNAMED(f) \
+ ptr = (void*)GetProcAddress(hmod, #f); \
+ ok(ptr != 0, "expected named export for " #f "\n");
+
+ TESTNAMED(ILAppendID);
+ TESTNAMED(ILClone);
+ TESTNAMED(ILCloneFirst);
+ TESTNAMED(ILCombine);
+ TESTNAMED(ILCreateFromPath);
+ TESTNAMED(ILCreateFromPathA);
+ TESTNAMED(ILCreateFromPathW);
+ TESTNAMED(ILFindChild);
+ TESTNAMED(ILFindLastID);
+ TESTNAMED(ILGetNext);
+ TESTNAMED(ILGetSize);
+ TESTNAMED(ILIsEqual);
+ TESTNAMED(ILIsParent);
+ TESTNAMED(ILRemoveLastID);
+ TESTNAMED(ILSaveToStream);
+#undef TESTNAMED
+ }
+
hmod = GetModuleHandleA("shlwapi.dll");
pStrRetToBufW = (void*)GetProcAddress(hmod, "StrRetToBufW");
BOOL bRes;
hr = SHGetDesktopFolder(&IDesktopFolder);
+ ok(hr == S_OK, "Expected SHGetDesktopFolder to return S_OK, got 0x%08x\n", hr);
if(hr != S_OK) return;
/* Tests crash on W2K and below (SHCreateShellItem available as of XP) */
MultiByteToWideChar(CP_ACP, 0, cInetTestA, -1, cTestDirW, MAX_PATH);
hr = IShellFolder_ParseDisplayName(IDesktopFolder,
NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
- todo_wine ok((SUCCEEDED(hr) || broken(hr == E_FAIL) /* NT4 */),
+ todo_wine ok(hr == S_OK || broken(hr == E_FAIL) /* NT4 */,
"ParseDisplayName returned %08x, expected SUCCESS or E_FAIL\n", hr);
- if (SUCCEEDED(hr))
+ if (hr == S_OK)
{
ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x61, "Last pidl should be of type "
"PT_IESPECIAL1, but is: %02x\n", pILFindLastID(newPIDL)->mkid.abID[0]);
MultiByteToWideChar(CP_ACP, 0, cInetTest2A, -1, cTestDirW, MAX_PATH);
hr = IShellFolder_ParseDisplayName(IDesktopFolder,
NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
- todo_wine ok((SUCCEEDED(hr) || broken(hr == E_FAIL) /* NT4 */),
+ todo_wine ok(hr == S_OK || broken(hr == E_FAIL) /* NT4 */,
"ParseDisplayName returned %08x, expected SUCCESS or E_FAIL\n", hr);
- if (SUCCEEDED(hr))
+ if (hr == S_OK)
{
ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x61, "Last pidl should be of type "
"PT_IESPECIAL1, but is: %02x\n", pILFindLastID(newPIDL)->mkid.abID[0]);
}
res = GetFileAttributesA(cNonExistDir1A);
- if(res != INVALID_FILE_ATTRIBUTES) return;
+ if(res != INVALID_FILE_ATTRIBUTES)
+ {
+ skip("Test directory unexpectedly exists\n");
+ goto finished;
+ }
MultiByteToWideChar(CP_ACP, 0, cNonExistDir1A, -1, cTestDirW, MAX_PATH);
hr = IShellFolder_ParseDisplayName(IDesktopFolder,
"ParseDisplayName returned %08x, expected 80070002 or E_FAIL\n", hr);
res = GetFileAttributesA(cNonExistDir2A);
- if(res != INVALID_FILE_ATTRIBUTES) return;
+ if(res != INVALID_FILE_ATTRIBUTES)
+ {
+ skip("Test directory unexpectedly exists\n");
+ goto finished;
+ }
MultiByteToWideChar(CP_ACP, 0, cNonExistDir2A, -1, cTestDirW, MAX_PATH);
hr = IShellFolder_ParseDisplayName(IDesktopFolder,
/* I thought that perhaps the DesktopFolder's ParseDisplayName would recognize the
* path corresponding to CSIDL_PERSONAL and return a CLSID_MyDocuments PIDL. Turns
* out it doesn't. The magic seems to happen in the file dialogs, then. */
- if (!pSHGetSpecialFolderPathW || !pILFindLastID) goto finished;
-
+ if (!pSHGetSpecialFolderPathW || !pILFindLastID)
+ {
+ win_skip("SHGetSpecialFolderPathW and/or ILFindLastID are not available\n");
+ goto finished;
+ }
+
bRes = pSHGetSpecialFolderPathW(NULL, cTestDirW, CSIDL_PERSONAL, FALSE);
ok(bRes, "SHGetSpecialFolderPath(CSIDL_PERSONAL) failed! %u\n", GetLastError());
if (!bRes) goto finished;
hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
- ok(SUCCEEDED(hr), "DesktopFolder->ParseDisplayName failed. hr = %08x.\n", hr);
- if (FAILED(hr)) goto finished;
+ ok(hr == S_OK, "DesktopFolder->ParseDisplayName failed. hr = %08x.\n", hr);
+ if (hr != S_OK) goto finished;
ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x31 ||
pILFindLastID(newPIDL)->mkid.abID[0] == 0xb1, /* Win98 */
* with an empty pidl. This is tested for Desktop, MyComputer and the FS ShellFolder
*/
hr = SHGetDesktopFolder(&psfDesktop);
- ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
hr = IShellFolder_BindToObject(psfDesktop, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
- ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
- ok (SUCCEEDED(hr), "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
IShellFolder_Release(psfDesktop);
IMalloc_Free(ppM, pidlMyComputer);
- if (FAILED(hr)) return;
+ if (hr != S_OK) return;
hr = IShellFolder_BindToObject(psfMyComputer, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszSystemDir, MAX_PATH);
hr = IShellFolder_ParseDisplayName(psfMyComputer, NULL, NULL, wszSystemDir, NULL, &pidlSystemDir, NULL);
- ok (SUCCEEDED(hr), "MyComputers's ParseDisplayName failed to parse the SystemDirectory! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "MyComputers's ParseDisplayName failed to parse the SystemDirectory! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfMyComputer);
return;
}
hr = IShellFolder_BindToObject(psfMyComputer, pidlSystemDir, NULL, &IID_IShellFolder, (LPVOID*)&psfSystemDir);
- ok (SUCCEEDED(hr), "MyComputer failed to bind to a FileSystem ShellFolder! hr = %08x\n", hr);
+ ok (hr == S_OK, "MyComputer failed to bind to a FileSystem ShellFolder! hr = %08x\n", hr);
IShellFolder_Release(psfMyComputer);
IMalloc_Free(ppM, pidlSystemDir);
- if (FAILED(hr)) return;
+ if (hr != S_OK) return;
hr = IShellFolder_BindToObject(psfSystemDir, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
ok (hr == E_INVALIDARG,
/* Getting an itemidlist for the file. */
hr = SHGetDesktopFolder(&psfDesktop);
- ok(SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok(hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
MultiByteToWideChar(CP_ACP, 0, szTestFile, -1, wszTestFile, MAX_PATH);
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
- ok(SUCCEEDED(hr), "Desktop->ParseDisplayName failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok(hr == S_OK, "Desktop->ParseDisplayName failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
todo_wine
ok (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
hr == E_NOTIMPL || /* Vista */
- broken(SUCCEEDED(hr)), /* Win9x, W2K */
+ broken(hr == S_OK), /* Win9x, W2K */
"hr = %08x\n", hr);
- if (SUCCEEDED(hr)) {
+ if (hr == S_OK) {
IShellFolder_Release(psfFile);
}
if (pSHGetFolderPathAndSubDirA)
{
hr = pSHBindToParent(pidlTestFile, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
- ok(SUCCEEDED(hr), "SHBindToParent failed! hr = %08x\n", hr);
- if (SUCCEEDED(hr)) {
+ ok(hr == S_OK, "SHBindToParent failed! hr = %08x\n", hr);
+ if (hr == S_OK) {
/* It's ok to use this fixed path. Call will fail anyway. */
WCHAR wszAbsoluteFilename[] = { 'C',':','\\','w','i','n','e','t','e','s','t', 0 };
LPITEMIDLIST pidlNew;
/* The pidl returned through the last parameter of SetNameOf is a simple one. */
hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlLast, wszDirName, SHGDN_NORMAL, &pidlNew);
- ok (SUCCEEDED(hr), "SetNameOf failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "SetNameOf failed! hr = %08x\n", hr);
if (hr == S_OK)
{
ok (((LPITEMIDLIST)((LPBYTE)pidlNew+pidlNew->mkid.cb))->mkid.cb == 0,
/* Rename the file back to its original name. SetNameOf ignores the fact, that the
* SHGDN flags specify an absolute path. */
hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszFileName, SHGDN_FORPARSING, NULL);
- ok (SUCCEEDED(hr), "SetNameOf failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "SetNameOf failed! hr = %08x\n", hr);
pILFree(pidlNew);
}
/* SHBindToParent fails, if called with a NULL PIDL. */
hr = pSHBindToParent(NULL, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
- ok (FAILED(hr), "SHBindToParent(NULL) should fail!\n");
+ ok (hr != S_OK, "SHBindToParent(NULL) should fail!\n");
/* But it succeeds with an empty PIDL. */
hr = pSHBindToParent(pidlEmpty, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
- ok (SUCCEEDED(hr), "SHBindToParent(empty PIDL) should succeed! hr = %08x\n", hr);
+ ok (hr == S_OK, "SHBindToParent(empty PIDL) should succeed! hr = %08x\n", hr);
ok (pidlLast == pidlEmpty, "The last element of an empty PIDL should be the PIDL itself!\n");
- if (SUCCEEDED(hr))
+ if (hr == S_OK)
IShellFolder_Release(psfPersonal);
/* Binding to the folder and querying the display name of the file also works. */
hr = pSHBindToParent(pidlTestFile, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
- ok (SUCCEEDED(hr), "SHBindToParent failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "SHBindToParent failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
"SHBindToParent doesn't return the last id of the pidl param!\n");
hr = IShellFolder_GetDisplayNameOf(psfPersonal, pidlLast, SHGDN_FORPARSING, &strret);
- ok (SUCCEEDED(hr), "Personal->GetDisplayNameOf failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "Personal->GetDisplayNameOf failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
IShellFolder_Release(psfPersonal);
return;
if (pStrRetToBufW)
{
hr = pStrRetToBufW(&strret, pidlLast, wszTestFile2, MAX_PATH);
- ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
ok (!lstrcmpiW(wszTestFile, wszTestFile2), "GetDisplayNameOf returns incorrect path!\n");
}
* on MSDN. This test is meant to document the observed behaviour on WinXP SP2.
*/
hr = SHGetDesktopFolder(&psfDesktop);
- ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyDocuments, NULL,
&pidlMyDocuments, NULL);
- ok (SUCCEEDED(hr) ||
+ ok (hr == S_OK ||
broken(hr == E_INVALIDARG), /* Win95, NT4 */
"Desktop's ParseDisplayName failed to parse MyDocuments's CLSID! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
dwAttributes = 0xffffffff;
hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
(LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
/* We need the following setup (as observed on WinXP SP2), for the tests to make sense. */
ok (dwAttributes & SFGAO_FILESYSTEM, "SFGAO_FILESYSTEM attribute is not set for MyDocuments!\n");
dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED|SFGAO_FILESYSTEM;
hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
(LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
- if (SUCCEEDED(hr))
+ ok (hr == S_OK, "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
+ if (hr == S_OK)
ok (dwAttributes == SFGAO_FILESYSTEM,
"Desktop->GetAttributes(MyDocuments) returned unexpected attributes: %08x\n",
dwAttributes);
BOOL foundFlagsMatch;
hr = SHGetDesktopFolder(&psfDesktop);
- ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
/* The Desktop attributes can be queried with a single empty itemidlist, .. */
dwFlags = 0xffffffff;
hr = IShellFolder_GetAttributesOf(psfDesktop, 1, &pidlEmpty, &dwFlags);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(empty pidl) failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop->GetAttributesOf(empty pidl) failed! hr = %08x\n", hr);
for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
i < sizeof(desktopFlags) / sizeof(desktopFlags[0]); i++)
{
/* .. or with no itemidlist at all. */
dwFlags = 0xffffffff;
hr = IShellFolder_GetAttributesOf(psfDesktop, 0, NULL, &dwFlags);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
i < sizeof(desktopFlags) / sizeof(desktopFlags[0]); i++)
{
/* Testing the attributes of the MyComputer shellfolder */
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
- ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
*/
dwFlags = 0xffffffff;
hr = IShellFolder_GetAttributesOf(psfDesktop, 1, (LPCITEMIDLIST*)&pidlMyComputer, &dwFlags);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(MyComputer) failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop->GetAttributesOf(MyComputer) failed! hr = %08x\n", hr);
for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
i < sizeof(myComputerFlags) / sizeof(myComputerFlags[0]); i++)
{
ok (foundFlagsMatch, "Wrong MyComputer attributes: %08x\n", dwFlags);
hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
- ok (SUCCEEDED(hr), "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
IShellFolder_Release(psfDesktop);
IMalloc_Free(ppM, pidlMyComputer);
- if (FAILED(hr)) return;
+ if (hr != S_OK) return;
hr = IShellFolder_GetAttributesOf(psfMyComputer, 1, &pidlEmpty, &dwFlags);
todo_wine
ok (hr == E_INVALIDARG ||
- broken(SUCCEEDED(hr)), /* W2K and earlier */
+ broken(hr == S_OK), /* W2K and earlier */
"MyComputer->GetAttributesOf(emtpy pidl) should fail! hr = %08x\n", hr);
dwFlags = 0xffffffff;
hr = IShellFolder_GetAttributesOf(psfMyComputer, 0, NULL, &dwFlags);
- ok (SUCCEEDED(hr), "MyComputer->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "MyComputer->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
i < sizeof(myComputerFlags) / sizeof(myComputerFlags[0]); i++)
{
/* test the shell attributes of the test directory using the relative PIDL */
dwFlags = SFGAO_FOLDER;
hr = IShellFolder_GetAttributesOf(testIShellFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for relative PIDL: %08x\n", dwFlags);
/* free memory */
/* test the shell attributes of the test directory using the absolute PIDL */
dwFlags = SFGAO_FOLDER;
hr = IShellFolder_GetAttributesOf(IDesktopFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
- ok (SUCCEEDED(hr), "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for absolute PIDL: %08x\n", dwFlags);
/* free memory */
/* MyComputer does not map to a filesystem path. SHGetPathFromIDListW should fail. */
hr = SHGetDesktopFolder(&psfDesktop);
- ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
- ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
CloseHandle(hTestFile);
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
- ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse filename hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse filename hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
DeleteFileW(wszFileName);
IMalloc_Free(ppM, pidlTestFile);
/* This test is to show that the Desktop shellfolder prepends the CSIDL_DESKTOPDIRECTORY
* path for files placed on the desktop, if called with SHGDN_FORPARSING. */
hr = IShellFolder_GetDisplayNameOf(psfDesktop, pidlTestFile, SHGDN_FORPARSING, &strret);
- ok (SUCCEEDED(hr), "Desktop's GetDisplayNamfOf failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "Desktop's GetDisplayNamfOf failed! hr = %08x\n", hr);
IShellFolder_Release(psfDesktop);
DeleteFileW(wszFileName);
- if (FAILED(hr)) {
+ if (hr != S_OK) {
IMalloc_Free(ppM, pidlTestFile);
return;
}
pSHGetSpecialFolderLocation = (void *)GetProcAddress(hShell32, "SHGetSpecialFolderLocation");
hr = pSHGetSpecialFolderLocation(NULL, CSIDL_PROGRAM_FILES, &pidlPrograms);
- ok(SUCCEEDED(hr), "SHGetFolderLocation failed: 0x%08x\n", hr);
+ ok(hr == S_OK, "SHGetFolderLocation failed: 0x%08x\n", hr);
SetLastError(0xdeadbeef);
result = pSHGetPathFromIDListW(pidlPrograms, wszPath);
win_skip("CLSID_FolderShortcut is not implemented\n");
return;
}
- ok (SUCCEEDED(hr), "CoCreateInstance failed! hr = 0x%08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "CoCreateInstance failed! hr = 0x%08x\n", hr);
+ if (hr != S_OK) return;
hr = IPersistPropertyBag_Load(pPersistPropertyBag, &InitPropertyBag, NULL);
- ok(SUCCEEDED(hr), "IPersistPropertyBag_Load failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok(hr == S_OK, "IPersistPropertyBag_Load failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IPersistPropertyBag_Release(pPersistPropertyBag);
return;
}
hr = IPersistPropertyBag_QueryInterface(pPersistPropertyBag, &IID_IShellFolder,
(LPVOID*)&pShellFolder);
IPersistPropertyBag_Release(pPersistPropertyBag);
- ok(SUCCEEDED(hr), "IPersistPropertyBag_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok(hr == S_OK, "IPersistPropertyBag_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
- ok(SUCCEEDED(hr), "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok(hr == S_OK, "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(pShellFolder);
return;
}
hr = IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder3, (LPVOID*)&pPersistFolder3);
IShellFolder_Release(pShellFolder);
- ok(SUCCEEDED(hr), "IShellFolder_QueryInterface(IID_IPersistFolder3 failed! hr = 0x%08x\n", hr);
- if (FAILED(hr)) return;
+ ok(hr == S_OK, "IShellFolder_QueryInterface(IID_IPersistFolder3 failed! hr = 0x%08x\n", hr);
+ if (hr != S_OK) return;
hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
- ok(SUCCEEDED(hr), "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
+ ok(hr == S_OK, "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
ok(IsEqualCLSID(&clsid, &CLSID_FolderShortcut), "Unexpected CLSID!\n");
hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
- ok(SUCCEEDED(hr), "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
+ todo_wine ok(hr == S_FALSE, "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
ok(!pidlCurrentFolder, "IPersistFolder3_GetCurFolder should return a NULL pidl!\n");
/* For FolderShortcut objects, the Initialize method initialized the folder's position in the
* itemidlist, but GetDisplayNameOf still returns the path from above.
*/
hr = SHGetDesktopFolder(&pDesktopFolder);
- ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
/* Temporarily register WineTestFolder as a shell namespace extension at the Desktop.
* Otherwise ParseDisplayName fails on WinXP with E_INVALIDARG */
&pidlWineTestFolder, NULL);
RegDeleteKeyW(HKEY_CURRENT_USER, wszShellExtKey);
IShellFolder_Release(pDesktopFolder);
- ok (SUCCEEDED(hr), "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok (hr == S_OK, "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
hr = IPersistFolder3_Initialize(pPersistFolder3, pidlWineTestFolder);
- ok (SUCCEEDED(hr), "IPersistFolder3::Initialize failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "IPersistFolder3::Initialize failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IPersistFolder3_Release(pPersistFolder3);
pILFree(pidlWineTestFolder);
return;
}
hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
- ok(SUCCEEDED(hr), "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
+ ok(hr == S_OK, "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
ok(pILIsEqual(pidlCurrentFolder, pidlWineTestFolder),
"IPersistFolder3_GetCurFolder should return pidlWineTestFolder!\n");
pILFree(pidlCurrentFolder);
hr = IPersistFolder3_QueryInterface(pPersistFolder3, &IID_IShellFolder, (LPVOID*)&pShellFolder);
IPersistFolder3_Release(pPersistFolder3);
- ok(SUCCEEDED(hr), "IPersistFolder3_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok(hr == S_OK, "IPersistFolder3_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
- ok(SUCCEEDED(hr), "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok(hr == S_OK, "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(pShellFolder);
return;
}
hr = IShellFolder_ParseDisplayName(pShellFolder, NULL, NULL, wszSomeSubFolder, NULL,
&pidlSubFolder, NULL);
RemoveDirectoryW(wszDesktopPath);
- ok (SUCCEEDED(hr), "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok (hr == S_OK, "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(pShellFolder);
return;
}
(LPVOID*)&pPersistFolder3);
IShellFolder_Release(pShellFolder);
pILFree(pidlSubFolder);
- ok (SUCCEEDED(hr), "IShellFolder::BindToObject failed! hr = %08x\n", hr);
- if (FAILED(hr))
+ ok (hr == S_OK, "IShellFolder::BindToObject failed! hr = %08x\n", hr);
+ if (hr != S_OK)
return;
/* On windows, we expect CLSID_ShellFSFolder. On wine we relax this constraint
* a little bit and also allow CLSID_UnixDosFolder. */
hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
- ok(SUCCEEDED(hr), "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
+ ok(hr == S_OK, "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
ok(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder) || IsEqualCLSID(&clsid, &CLSID_UnixDosFolder),
"IPersistFolder3::GetClassID returned unexpected CLSID!\n");
if (!bResult) return;
hr = SHGetDesktopFolder(&psfDesktop);
- ok(SUCCEEDED(hr), "SHGetDesktopFolder failed! hr: %08x\n", hr);
- if (FAILED(hr)) return;
+ ok(hr == S_OK, "SHGetDesktopFolder failed! hr: %08x\n", hr);
+ if (hr != S_OK) return;
hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszPersonal, NULL, &pidlPersonal, NULL);
- ok(SUCCEEDED(hr), "psfDesktop->ParseDisplayName failed! hr = %08x\n", hr);
- if (FAILED(hr)) {
+ ok(hr == S_OK, "psfDesktop->ParseDisplayName failed! hr = %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfDesktop);
return;
}
(LPVOID*)&psfPersonal);
IShellFolder_Release(psfDesktop);
pILFree(pidlPersonal);
- ok(SUCCEEDED(hr), "psfDesktop->BindToObject failed! hr = %08x\n", hr);
- if (FAILED(hr)) return;
+ ok(hr == S_OK, "psfDesktop->BindToObject failed! hr = %08x\n", hr);
+ if (hr != S_OK) return;
for (i=0; i<3; i++) {
CHAR szFile[MAX_PATH];
hr = IShellFolder_ParseDisplayName(psfPersonal, NULL, NULL, wszFile[i], NULL, &pidlFile, NULL);
DeleteFileW(wszFile[i]);
- ok(SUCCEEDED(hr), "psfPersonal->ParseDisplayName failed! hr: %08x\n", hr);
- if (FAILED(hr)) {
+ ok(hr == S_OK, "psfPersonal->ParseDisplayName failed! hr: %08x\n", hr);
+ if (hr != S_OK) {
IShellFolder_Release(psfPersonal);
return;
}
hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER, &strret);
ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
- if (SUCCEEDED(hr) && pStrRetToBufW)
+ if (hr == S_OK && pStrRetToBufW)
{
hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
- ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
todo_wine
ok (!lstrcmpiW(tempbufW, folderdisplayW) ||
broken(!lstrcmpiW(tempbufW, foldernameW)), /* W2K */
hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FOREDITING, &strret);
ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
- if (SUCCEEDED(hr) && pStrRetToBufW)
+ if (hr == S_OK && pStrRetToBufW)
{
hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
- ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
todo_wine
ok (!lstrcmpiW(tempbufW, folderdisplayW) ||
broken(!lstrcmpiW(tempbufW, foldernameW)), /* W2K */
hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FORPARSING, &strret);
ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
- if (SUCCEEDED(hr) && pStrRetToBufW)
+ if (hr == S_OK && pStrRetToBufW)
{
hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
- ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
+ ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
ok (!lstrcmpiW(tempbufW, foldernameW), "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
}
static void test_SHParseDisplayName(void)
{
- static const WCHAR prefixW[] = {'w','t',0};
LPITEMIDLIST pidl1, pidl2;
IShellFolder *desktop;
WCHAR dirW[MAX_PATH];
pILFree(pidl2);
/* with path */
- GetTempPathW(sizeof(dirW)/sizeof(WCHAR), dirW);
- GetTempFileNameW(dirW, prefixW, 0, dirW);
- CreateFileW(dirW, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
+ GetWindowsDirectoryW( dirW, MAX_PATH );
hr = pSHParseDisplayName(dirW, NULL, &pidl1, 0, NULL);
ok(hr == S_OK, "failed %08x\n", hr);
pILFree(pidl1);
pILFree(pidl2);
- DeleteFileW(dirW);
+ IShellFolder_Release(desktop);
+}
+
+static void test_desktop_IPersist(void)
+{
+ IShellFolder *desktop;
+ IPersist *persist;
+ CLSID clsid;
+ HRESULT hr;
+
+ hr = SHGetDesktopFolder(&desktop);
+ ok(hr == S_OK, "failed %08x\n", hr);
+
+ hr = IShellFolder_QueryInterface(desktop, &IID_IPersist, (void**)&persist);
+ ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* NT4, W9X */, "failed %08x\n", hr);
+
+ if (hr == S_OK)
+ {
+ if (0)
+ {
+ /* crashes on native */
+ hr = IPersist_GetClassID(persist, NULL);
+ }
+ memset(&clsid, 0, sizeof(clsid));
+ hr = IPersist_GetClassID(persist, &clsid);
+ ok(hr == S_OK, "failed %08x\n", hr);
+ ok(IsEqualIID(&CLSID_ShellDesktop, &clsid), "Expected CLSID_ShellDesktop\n");
+ IPersist_Release(persist);
+ }
IShellFolder_Release(desktop);
}
test_SHGetFolderPathAndSubDirA();
test_LocalizedNames();
test_SHCreateShellItem();
+ test_desktop_IPersist();
OleUninitialize();
}
--- /dev/null
+/*
+ * Unit test of the IShellView
+ *
+ * Copyright 2010 Nikolay Sivov 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
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#define COBJMACROS
+#define CONST_VTABLE
+
+#include "windef.h"
+#include "winbase.h"
+#include "wtypes.h"
+#include "shellapi.h"
+
+#include "shlguid.h"
+#include "shlobj.h"
+#include "shobjidl.h"
+#include "shlwapi.h"
+#include "ocidl.h"
+#include "oleauto.h"
+
+#include "initguid.h"
+
+#include "wine/test.h"
+
+#include "msg.h"
+
+#define LISTVIEW_SEQ_INDEX 0
+#define NUM_MSG_SEQUENCES 1
+
+DEFINE_GUID(IID_IPersistHistory, 0x91a565c1, 0xe38f, 0x11d0, 0x94, 0xbf, 0x00, 0xa0, 0xc9, 0x05, 0x5c, 0xbf);
+
+static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
+
+static LRESULT WINAPI listview_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
+ static LONG defwndproc_counter = 0;
+ LRESULT ret;
+ struct message msg;
+
+ trace("listview: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
+
+ msg.message = message;
+ msg.flags = sent|wparam|lparam;
+ if (defwndproc_counter) msg.flags |= defwinproc;
+ msg.wParam = wParam;
+ msg.lParam = lParam;
+ add_message(sequences, LISTVIEW_SEQ_INDEX, &msg);
+
+ defwndproc_counter++;
+ ret = CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
+ defwndproc_counter--;
+ return ret;
+}
+
+static HWND subclass_listview(HWND hwnd)
+{
+ WNDPROC oldproc;
+ HWND listview;
+
+ /* listview is a first child */
+ listview = FindWindowExA(hwnd, NULL, WC_LISTVIEWA, NULL);
+
+ oldproc = (WNDPROC)SetWindowLongPtrA(listview, GWLP_WNDPROC,
+ (LONG_PTR)listview_subclass_proc);
+ SetWindowLongPtrA(listview, GWLP_USERDATA, (LONG_PTR)oldproc);
+
+ return listview;
+}
+
+/* dummy IDataObject implementation */
+typedef struct {
+ const IDataObjectVtbl *lpVtbl;
+ LONG ref;
+} IDataObjectImpl;
+
+static const IDataObjectVtbl IDataObjectImpl_Vtbl;
+
+static IDataObject* IDataObjectImpl_Construct(void)
+{
+ IDataObjectImpl *obj;
+
+ obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
+ obj->lpVtbl = &IDataObjectImpl_Vtbl;
+ obj->ref = 1;
+
+ return (IDataObject*)obj;
+}
+
+static HRESULT WINAPI IDataObjectImpl_QueryInterface(IDataObject *iface, REFIID riid, void **ppvObj)
+{
+ IDataObjectImpl *This = (IDataObjectImpl *)iface;
+
+ if (IsEqualIID(riid, &IID_IUnknown) ||
+ IsEqualIID(riid, &IID_IDataObject))
+ {
+ *ppvObj = This;
+ }
+
+ if(*ppvObj)
+ {
+ IUnknown_AddRef(iface);
+ return S_OK;
+ }
+
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI IDataObjectImpl_AddRef(IDataObject * iface)
+{
+ IDataObjectImpl *This = (IDataObjectImpl *)iface;
+ return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI IDataObjectImpl_Release(IDataObject * iface)
+{
+ IDataObjectImpl *This = (IDataObjectImpl *)iface;
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ if (!ref)
+ {
+ HeapFree(GetProcessHeap(), 0, This);
+ return 0;
+ }
+ return ref;
+}
+
+static HRESULT WINAPI IDataObjectImpl_GetData(IDataObject *iface, FORMATETC *pformat, STGMEDIUM *pmedium)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_GetDataHere(IDataObject *iface, FORMATETC *pformat, STGMEDIUM *pmedium)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_QueryGetData(IDataObject *iface, FORMATETC *pformat)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_GetCanonicalFormatEtc(
+ IDataObject *iface, FORMATETC *pformatIn, FORMATETC *pformatOut)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_SetData(
+ IDataObject *iface, FORMATETC *pformat, STGMEDIUM *pmedium, BOOL release)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_EnumFormatEtc(
+ IDataObject *iface, DWORD direction, IEnumFORMATETC **ppenumFormatEtc)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_DAdvise(
+ IDataObject *iface, FORMATETC *pformatetc, DWORD advf, IAdviseSink *pSink, DWORD *pConnection)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_DUnadvise(IDataObject *iface, DWORD connection)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IDataObjectImpl_EnumDAdvise(IDataObject *iface, IEnumSTATDATA **ppenumAdvise)
+{
+ return E_NOTIMPL;
+}
+
+static const IDataObjectVtbl IDataObjectImpl_Vtbl =
+{
+ IDataObjectImpl_QueryInterface,
+ IDataObjectImpl_AddRef,
+ IDataObjectImpl_Release,
+ IDataObjectImpl_GetData,
+ IDataObjectImpl_GetDataHere,
+ IDataObjectImpl_QueryGetData,
+ IDataObjectImpl_GetCanonicalFormatEtc,
+ IDataObjectImpl_SetData,
+ IDataObjectImpl_EnumFormatEtc,
+ IDataObjectImpl_DAdvise,
+ IDataObjectImpl_DUnadvise,
+ IDataObjectImpl_EnumDAdvise
+};
+
+/* dummy IShellBrowser implementation */
+typedef struct {
+ const IShellBrowserVtbl *lpVtbl;
+ LONG ref;
+} IShellBrowserImpl;
+
+static const IShellBrowserVtbl IShellBrowserImpl_Vtbl;
+
+static IShellBrowser* IShellBrowserImpl_Construct(void)
+{
+ IShellBrowserImpl *browser;
+
+ browser = HeapAlloc(GetProcessHeap(), 0, sizeof(*browser));
+ browser->lpVtbl = &IShellBrowserImpl_Vtbl;
+ browser->ref = 1;
+
+ return (IShellBrowser*)browser;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_QueryInterface(IShellBrowser *iface,
+ REFIID riid,
+ LPVOID *ppvObj)
+{
+ IShellBrowserImpl *This = (IShellBrowserImpl *)iface;
+
+ *ppvObj = NULL;
+
+ if(IsEqualIID(riid, &IID_IUnknown) ||
+ IsEqualIID(riid, &IID_IOleWindow) ||
+ IsEqualIID(riid, &IID_IShellBrowser))
+ {
+ *ppvObj = This;
+ }
+
+ if(*ppvObj)
+ {
+ IUnknown_AddRef(iface);
+ return S_OK;
+ }
+
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI IShellBrowserImpl_AddRef(IShellBrowser * iface)
+{
+ IShellBrowserImpl *This = (IShellBrowserImpl *)iface;
+ return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI IShellBrowserImpl_Release(IShellBrowser * iface)
+{
+ IShellBrowserImpl *This = (IShellBrowserImpl *)iface;
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ if (!ref)
+ {
+ HeapFree(GetProcessHeap(), 0, This);
+ return 0;
+ }
+ return ref;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_GetWindow(IShellBrowser *iface,
+ HWND *phwnd)
+{
+ if (phwnd) *phwnd = GetDesktopWindow();
+ return S_OK;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_ContextSensitiveHelp(IShellBrowser *iface,
+ BOOL fEnterMode)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_BrowseObject(IShellBrowser *iface,
+ LPCITEMIDLIST pidl,
+ UINT wFlags)
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_EnableModelessSB(IShellBrowser *iface,
+ BOOL fEnable)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_GetControlWindow(IShellBrowser *iface,
+ UINT id,
+ HWND *lphwnd)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_GetViewStateStream(IShellBrowser *iface,
+ DWORD mode,
+ LPSTREAM *pStrm)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_InsertMenusSB(IShellBrowser *iface,
+ HMENU hmenuShared,
+ LPOLEMENUGROUPWIDTHS lpMenuWidths)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_OnViewWindowActive(IShellBrowser *iface,
+ IShellView *ppshv)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_QueryActiveShellView(IShellBrowser *iface,
+ IShellView **ppshv)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_RemoveMenusSB(IShellBrowser *iface,
+ HMENU hmenuShared)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_SendControlMsg(IShellBrowser *iface,
+ UINT id,
+ UINT uMsg,
+ WPARAM wParam,
+ LPARAM lParam,
+ LRESULT *pret)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_SetMenuSB(IShellBrowser *iface,
+ HMENU hmenuShared,
+ HOLEMENU holemenuReserved,
+ HWND hwndActiveObject)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_SetStatusTextSB(IShellBrowser *iface,
+ LPCOLESTR lpszStatusText)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_SetToolbarItems(IShellBrowser *iface,
+ LPTBBUTTON lpButtons,
+ UINT nButtons,
+ UINT uFlags)
+
+{
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI IShellBrowserImpl_TranslateAcceleratorSB(IShellBrowser *iface,
+ LPMSG lpmsg,
+ WORD wID)
+
+{
+ return E_NOTIMPL;
+}
+
+static const IShellBrowserVtbl IShellBrowserImpl_Vtbl =
+{
+ IShellBrowserImpl_QueryInterface,
+ IShellBrowserImpl_AddRef,
+ IShellBrowserImpl_Release,
+ IShellBrowserImpl_GetWindow,
+ IShellBrowserImpl_ContextSensitiveHelp,
+ IShellBrowserImpl_InsertMenusSB,
+ IShellBrowserImpl_SetMenuSB,
+ IShellBrowserImpl_RemoveMenusSB,
+ IShellBrowserImpl_SetStatusTextSB,
+ IShellBrowserImpl_EnableModelessSB,
+ IShellBrowserImpl_TranslateAcceleratorSB,
+ IShellBrowserImpl_BrowseObject,
+ IShellBrowserImpl_GetViewStateStream,
+ IShellBrowserImpl_GetControlWindow,
+ IShellBrowserImpl_SendControlMsg,
+ IShellBrowserImpl_QueryActiveShellView,
+ IShellBrowserImpl_OnViewWindowActive,
+ IShellBrowserImpl_SetToolbarItems
+};
+
+static const struct message empty_seq[] = {
+ { 0 }
+};
+
+static const struct message folderview_getspacing_seq[] = {
+ { LVM_GETITEMSPACING, wparam|sent, FALSE },
+ { 0 }
+};
+
+static const struct message folderview_getselectionmarked_seq[] = {
+ { LVM_GETSELECTIONMARK, sent },
+ { 0 }
+};
+
+static const struct message folderview_getfocused_seq[] = {
+ { LVM_GETNEXTITEM, sent|wparam|lparam, -1, LVNI_FOCUSED },
+ { 0 }
+};
+
+static const struct message folderview_itemcount_seq[] = {
+ { LVM_GETITEMCOUNT, sent },
+ { 0 }
+};
+
+static void test_IShellView_CreateViewWindow(void)
+{
+ IShellFolder *desktop;
+ FOLDERSETTINGS settings;
+ IShellView *view;
+ IDropTarget *dt;
+ HWND hwnd_view;
+ HRESULT hr;
+ RECT r = {0};
+
+ hr = SHGetDesktopFolder(&desktop);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+if (0)
+{
+ /* crashes on native */
+ hr = IShellView_CreateViewWindow(view, NULL, &settings, NULL, NULL, NULL);
+}
+
+ settings.ViewMode = FVM_ICON;
+ settings.fFlags = 0;
+ hwnd_view = (HWND)0xdeadbeef;
+ hr = IShellView_CreateViewWindow(view, NULL, &settings, NULL, NULL, &hwnd_view);
+ ok(hr == E_UNEXPECTED, "got (0x%08x)\n", hr);
+ ok(hwnd_view == 0, "got %p\n", hwnd_view);
+
+ hwnd_view = (HWND)0xdeadbeef;
+ hr = IShellView_CreateViewWindow(view, NULL, &settings, NULL, &r, &hwnd_view);
+ ok(hr == E_UNEXPECTED, "got (0x%08x)\n", hr);
+ ok(hwnd_view == 0, "got %p\n", hwnd_view);
+
+ /* ::DragLeave without drag operation */
+ hr = IShellView_QueryInterface(view, &IID_IDropTarget, (void**)&dt);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ hr = IDropTarget_DragLeave(dt);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ IDropTarget_Release(dt);
+
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+}
+
+static void test_IFolderView(void)
+{
+ IShellFolder *desktop, *folder;
+ FOLDERSETTINGS settings;
+ IShellView *view;
+ IShellBrowser *browser;
+ IFolderView *fv;
+ HWND hwnd_view, hwnd_list;
+ PITEMID_CHILD pidl;
+ HRESULT hr;
+ INT ret;
+ POINT pt;
+ LONG ref1, ref2;
+ RECT r;
+
+ hr = SHGetDesktopFolder(&desktop);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellView_QueryInterface(view, &IID_IFolderView, (void**)&fv);
+ if (hr != S_OK)
+ {
+ win_skip("IFolderView not supported by desktop folder\n");
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+ return;
+ }
+
+ /* call methods before window creation */
+ hr = IFolderView_GetSpacing(fv, NULL);
+ ok(hr == S_FALSE || broken(hr == S_OK) /* win7 */, "got (0x%08x)\n", hr);
+
+ pidl = (void*)0xdeadbeef;
+ hr = IFolderView_Item(fv, 0, &pidl);
+ ok(hr == E_INVALIDARG || broken(hr == E_FAIL) /* < Vista */, "got (0x%08x)\n", hr);
+ ok(pidl == 0 || broken(pidl == (void*)0xdeadbeef) /* < Vista */, "got %p\n", pidl);
+
+if (0)
+{
+ /* crashes on Vista and Win2k8 - List not created yet case */
+ hr = IFolderView_GetSpacing(fv, &pt);
+
+ /* crashes on XP */
+ hr = IFolderView_GetSelectionMarkedItem(fv, NULL);
+ hr = IFolderView_GetFocusedItem(fv, NULL);
+
+ /* crashes on Vista+ */
+ hr = IFolderView_Item(fv, 0, NULL);
+}
+
+ browser = IShellBrowserImpl_Construct();
+
+ settings.ViewMode = FVM_ICON;
+ settings.fFlags = 0;
+ hwnd_view = (HWND)0xdeadbeef;
+ r.left = r.top = 0;
+ r.right = r.bottom = 100;
+ hr = IShellView_CreateViewWindow(view, NULL, &settings, browser, &r, &hwnd_view);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok(IsWindow(hwnd_view), "got %p\n", hwnd_view);
+
+ hwnd_list = subclass_listview(hwnd_view);
+ if (!hwnd_list)
+ {
+ win_skip("Failed to subclass ListView control\n");
+ IShellBrowser_Release(browser);
+ IFolderView_Release(fv);
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+ return;
+ }
+
+ /* IFolderView::GetSpacing */
+ flush_sequences(sequences, NUM_MSG_SEQUENCES);
+ hr = IFolderView_GetSpacing(fv, NULL);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok_sequence(sequences, LISTVIEW_SEQ_INDEX, empty_seq, "IFolderView::GetSpacing, empty", FALSE);
+
+ flush_sequences(sequences, NUM_MSG_SEQUENCES);
+ hr = IFolderView_GetSpacing(fv, &pt);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ /* fails with empty sequence on win7 for unknown reason */
+ if (sequences[LISTVIEW_SEQ_INDEX]->count)
+ {
+ ok_sequence(sequences, LISTVIEW_SEQ_INDEX, folderview_getspacing_seq, "IFolderView::GetSpacing", FALSE);
+ ok(pt.x > 0, "got %d\n", pt.x);
+ ok(pt.y > 0, "got %d\n", pt.y);
+ ret = SendMessageA(hwnd_list, LVM_GETITEMSPACING, 0, 0);
+ ok(pt.x == LOWORD(ret) && pt.y == HIWORD(ret), "got (%d, %d)\n", LOWORD(ret), HIWORD(ret));
+ }
+
+ /* IFolderView::GetSelectionMarkedItem */
+if (0)
+{
+ /* crashes on XP */
+ hr = IFolderView_GetSelectionMarkedItem(fv, NULL);
+}
+
+ flush_sequences(sequences, NUM_MSG_SEQUENCES);
+ hr = IFolderView_GetSelectionMarkedItem(fv, &ret);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok_sequence(sequences, LISTVIEW_SEQ_INDEX, folderview_getselectionmarked_seq,
+ "IFolderView::GetSelectionMarkedItem", FALSE);
+
+ /* IFolderView::GetFocusedItem */
+ flush_sequences(sequences, NUM_MSG_SEQUENCES);
+ hr = IFolderView_GetFocusedItem(fv, &ret);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok_sequence(sequences, LISTVIEW_SEQ_INDEX, folderview_getfocused_seq,
+ "IFolderView::GetFocusedItem", FALSE);
+
+ /* IFolderView::GetFolder, just return pointer */
+if (0)
+{
+ /* crashes on XP */
+ hr = IFolderView_GetFolder(fv, NULL, (void**)&folder);
+ hr = IFolderView_GetFolder(fv, NULL, NULL);
+}
+
+ hr = IFolderView_GetFolder(fv, &IID_IShellFolder, NULL);
+ ok(hr == E_POINTER, "got (0x%08x)\n", hr);
+
+ ref1 = IShellFolder_AddRef(desktop);
+ IShellFolder_Release(desktop);
+ hr = IFolderView_GetFolder(fv, &IID_IShellFolder, (void**)&folder);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ref2 = IShellFolder_AddRef(desktop);
+ IShellFolder_Release(desktop);
+ ok(ref1 == ref2, "expected same refcount, got %d\n", ref2);
+ ok(desktop == folder, "\n");
+
+ /* IFolderView::ItemCount */
+if (0)
+{
+ /* crashes on XP */
+ hr = IFolderView_ItemCount(fv, SVGIO_ALLVIEW, NULL);
+}
+
+ flush_sequences(sequences, NUM_MSG_SEQUENCES);
+ hr = IFolderView_ItemCount(fv, SVGIO_ALLVIEW, &ret);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok_sequence(sequences, LISTVIEW_SEQ_INDEX, folderview_itemcount_seq,
+ "IFolderView::ItemCount", FALSE);
+
+ IShellBrowser_Release(browser);
+ IFolderView_Release(fv);
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+}
+
+static void test_GetItemObject(void)
+{
+ IShellFolder *desktop;
+ IShellView *view;
+ IUnknown *unk;
+ HRESULT hr;
+
+ hr = SHGetDesktopFolder(&desktop);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ /* from documentation three interfaces are supported for SVGIO_BACKGROUND:
+ IContextMenu, IDispatch, IPersistHistory */
+ hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IContextMenu, (void**)&unk);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ IUnknown_Release(unk);
+
+ unk = NULL;
+ hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IDispatch, (void**)&unk);
+ todo_wine ok(hr == S_OK || broken(hr == E_NOTIMPL) /* NT4 */, "got (0x%08x)\n", hr);
+ if (unk) IUnknown_Release(unk);
+
+ unk = NULL;
+ hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IPersistHistory, (void**)&unk);
+ todo_wine ok(hr == S_OK || broken(hr == E_NOTIMPL) /* W9x, NT4 */, "got (0x%08x)\n", hr);
+ if (unk) IUnknown_Release(unk);
+
+ /* example of unsupported interface, base for IPersistHistory */
+ hr = IShellView_GetItemObject(view, SVGIO_BACKGROUND, &IID_IPersist, (void**)&unk);
+ ok(hr == E_NOINTERFACE || broken(hr == E_NOTIMPL) /* W2K */, "got (0x%08x)\n", hr);
+
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+}
+
+static void test_IShellFolderView(void)
+{
+ IShellFolderView *folderview;
+ IShellFolder *desktop;
+ IShellView *view;
+ IDataObject *obj;
+ UINT i;
+ HRESULT hr;
+
+ hr = SHGetDesktopFolder(&desktop);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellView_QueryInterface(view, &IID_IShellFolderView, (void**)&folderview);
+ if (hr != S_OK)
+ {
+ win_skip("IShellView doesn't provide IShellFolderView on this platform\n");
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+ return;
+ }
+
+ /* ::MoveIcons */
+ obj = IDataObjectImpl_Construct();
+ hr = IShellFolderView_MoveIcons(folderview, obj);
+ ok(hr == E_NOTIMPL || broken(hr == S_OK) /* W98 */, "got (0x%08x)\n", hr);
+ IDataObject_Release(obj);
+
+ /* ::SetRedraw without list created */
+ hr = IShellFolderView_SetRedraw(folderview, TRUE);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ /* ::QuerySupport */
+ hr = IShellFolderView_QuerySupport(folderview, NULL);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ i = 0xdeadbeef;
+ hr = IShellFolderView_QuerySupport(folderview, &i);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok(i == 0xdeadbeef, "got %d\n", i);
+
+ /* ::RemoveObject */
+ i = 0xdeadbeef;
+ hr = IShellFolderView_RemoveObject(folderview, NULL, &i);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+ ok(i == 0 || i == -1 /* Win7 */ || broken(i == 0xdeadbeef) /* Vista, 2k8 */,
+ "got %d\n", i);
+
+ IShellFolderView_Release(folderview);
+
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+}
+
+static void test_IOleWindow(void)
+{
+ IShellFolder *desktop;
+ IShellView *view;
+ HRESULT hr;
+
+ hr = SHGetDesktopFolder(&desktop);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ hr = IShellFolder_CreateViewObject(desktop, NULL, &IID_IShellView, (void**)&view);
+ ok(hr == S_OK, "got (0x%08x)\n", hr);
+
+ /* IShellView::ContextSensitiveHelp */
+ hr = IShellView_ContextSensitiveHelp(view, TRUE);
+ ok(hr == E_NOTIMPL, "got (0x%08x)\n", hr);
+ hr = IShellView_ContextSensitiveHelp(view, FALSE);
+ ok(hr == E_NOTIMPL, "got (0x%08x)\n", hr);
+
+ IShellView_Release(view);
+ IShellFolder_Release(desktop);
+}
+
+START_TEST(shlview)
+{
+ OleInitialize(NULL);
+
+ init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
+
+ test_IShellView_CreateViewWindow();
+ test_IFolderView();
+ test_GetItemObject();
+ test_IShellFolderView();
+ test_IOleWindow();
+
+ OleUninitialize();
+}
extern void func_progman_dde(void);
extern void func_shelllink(void);
extern void func_shellpath(void);
-extern void func_shfldr_netplaces(void);
extern void func_shfldr_special(void);
extern void func_shlexec(void);
extern void func_shlfileop(void);
extern void func_shlfolder(void);
+extern void func_shlview(void);
extern void func_string(void);
extern void func_systray(void);
{ "progman_dde", func_progman_dde },
{ "shelllink", func_shelllink },
{ "shellpath", func_shellpath },
- { "shfldr_netplaces", func_shfldr_netplaces },
{ "shfldr_special", func_shfldr_special },
{ "shlexec", func_shlexec },
{ "shlfileop", func_shlfileop },
{ "shlfolder", func_shlfolder },
+ { "shlview", func_shlview },
{ "string", func_string },
{ "systray", func_systray },
{ 0, 0 }
projects / reactos.git / commitdiff