ReactOS 0.4.15-dev-8127-g6338913
shlfolder.c File Reference
#include <stdarg.h>
#include <stdio.h>
#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 "wine/heap.h"
#include "wine/test.h"
#include <initguid.h>
#include "pshpack1.h"
#include "poppack.h"
Include dependency graph for shlfolder.c:

Go to the source code of this file.

Classes

struct  FileStructA
 
struct  FileStructW
 
struct  IUnknownImpl
 
struct  IUnknownImpl::if_count
 
struct  ChNotifyTest
 

Macros

#define COBJMACROS
 
#define CONST_VTABLE
 
#define MAKEFUNC(f)   (p##f = (void*)GetProcAddress(hmod, #f))
 
#define TESTNAMED(f)
 
#define SFGAO_testfor   SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_CAPABILITYMASK
 
#define SFGAO_VISTA   SFGAO_DROPTARGET | SFGAO_CANLINK | SFGAO_CANCOPY
 
#define verify_pidl(i, p)   r_verify_pidl(__LINE__, i, p)
 
#define WM_USER_NOTIFY   (WM_APP+1)
 

Functions

 DEFINE_GUID (IID_IParentAndItem, 0xB3A4B685, 0xB685, 0x4805, 0x99, 0xD9, 0x5D, 0xEA, 0xD2, 0x87, 0x32, 0x36)
 
 DEFINE_GUID (CLSID_ShellDocObjView, 0xe7e4bc40, 0xe76a, 0x11ce, 0xa9, 0xbb, 0x00, 0xaa, 0x00, 0x4a, 0xe8, 0x37)
 
static HRESULT (WINAPI *pSHCreateItemFromIDList)(PCIDLIST_ABSOLUTE pidl
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder LPCITEMIDLIST IShellItemArray **static PCIDLIST_ABSOLUTE IShellItemArray **static void **static void **static PWSTR *static PWSTR *static void **static PIDLIST_ABSOLUTE *static void **static BOOL (WINAPI *pIsWow64Process)(HANDLE
 
static WCHARmake_wstr (const char *str)
 
static int strcmp_wa (LPCWSTR strw, const char *stra)
 
static void init_function_pointers (void)
 
static LPWSTR myPathAddBackslashW (LPWSTR lpszPath)
 
static void test_ParseDisplayName (void)
 
static void CreateTestFile (const CHAR *name)
 
static void CreateFilesFolders (void)
 
static void Cleanup (void)
 
static void test_EnumObjects (IShellFolder *iFolder)
 
static void test_BindToObject (void)
 
static void test_GetDisplayName (void)
 
static void test_CallForAttributes (void)
 
static void test_GetAttributesOf (void)
 
static void test_SHGetPathFromIDList (void)
 
static void test_EnumObjects_and_CompareIDs (void)
 
static HRESULT WINAPI InitPropertyBag_IPropertyBag_QueryInterface (IPropertyBag *iface, REFIID riid, void **ppvObject)
 
static ULONG WINAPI InitPropertyBag_IPropertyBag_AddRef (IPropertyBag *iface)
 
static ULONG WINAPI InitPropertyBag_IPropertyBag_Release (IPropertyBag *iface)
 
static HRESULT WINAPI InitPropertyBag_IPropertyBag_Read (IPropertyBag *iface, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
 
static HRESULT WINAPI InitPropertyBag_IPropertyBag_Write (IPropertyBag *iface, LPCOLESTR pszPropName, VARIANT *pVar)
 
static void test_FolderShortcut (void)
 
static void test_ITEMIDLIST_format (void)
 
static void test_SHGetFolderPathA (void)
 
static void test_SHGetFolderPathAndSubDirA (void)
 
static void test_LocalizedNames (void)
 
static void test_SHCreateShellItem (void)
 
static void test_SHGetNameFromIDList (void)
 
static void test_SHGetItemFromDataObject (void)
 
static void test_ShellItemCompare (void)
 
static IUnknownImplimpl_from_IUnknown (IUnknown *iface)
 
static HRESULT WINAPI unk_fnQueryInterface (IUnknown *iunk, REFIID riid, void **punk)
 
static ULONG WINAPI unk_fnAddRef (IUnknown *iunk)
 
static ULONG WINAPI unk_fnRelease (IUnknown *iunk)
 
static void test_SHGetIDListFromObject (void)
 
static void test_SHGetItemFromObject (void)
 
static void test_SHCreateShellItemArray (void)
 
static void test_ShellItemArrayEnumItems (void)
 
static void test_ShellItemBindToHandler (void)
 
static void test_ShellItemGetAttributes (void)
 
static void test_ShellItemArrayGetAttributes (void)
 
static WCHARget_empty_cddrive (void)
 
static void test_SHParseDisplayName (void)
 
static void test_desktop_IPersist (void)
 
static void test_contextmenu_qi (IContextMenu *menu, BOOL todo)
 
static void test_contextmenu (IContextMenu *menu, BOOL background)
 
static void test_GetUIObject (void)
 
static void r_verify_pidl (unsigned l, LPCITEMIDLIST pidl, const WCHAR *path)
 
static void test_SHSimpleIDListFromPath (void)
 
static HRESULT WINAPI fsbd_QueryInterface (IFileSystemBindData *fsbd, REFIID riid, void **ppv)
 
static ULONG WINAPI fsbd_AddRef (IFileSystemBindData *fsbd)
 
static ULONG WINAPI fsbd_Release (IFileSystemBindData *fsbd)
 
static HRESULT WINAPI fsbd_SetFindData (IFileSystemBindData *fsbd, const WIN32_FIND_DATAW *pfd)
 
static HRESULT WINAPI fsbd_GetFindData_nul (IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
 
static HRESULT WINAPI fsbd_GetFindData_junk (IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
 
static HRESULT WINAPI fsbd_GetFindData_invalid (IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
 
static HRESULT WINAPI fsbd_GetFindData_valid (IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
 
static HRESULT WINAPI fsbd_GetFindData_fail (IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
 
static void test_ParseDisplayNamePBC (void)
 
static LRESULT CALLBACK testwindow_wndproc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
 
static void register_testwindow_class (void)
 
static void do_events (void)
 
static void test_SHChangeNotify (BOOL test_new_delivery)
 
static void test_SHCreateDefaultContextMenu (void)
 
static void test_DataObject (void)
 
static void test_GetDefaultColumn (void)
 
static void test_GetDefaultSearchGUID (void)
 
static void test_SHLimitInputEdit (void)
 
static void test_SHGetSetFolderCustomSettings (void)
 
 START_TEST (shlfolder)
 

Variables

static IMallocppM
 
static REFIID riid
 
static REFIID void ** ppv
 
static IBindCtx REFIID
 
static IBindCtx void **static PCWSTR
 
static IBindCtx void **static IBindCtx void **static DWORD
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder LPCITEMIDLIST
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder UINT
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder LPCITEMIDLIST IShellItemArray **static PCIDLIST_ABSOLUTE IShellItemArray **static void **static void **static HANDLE
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder LPCITEMIDLIST IShellItemArray **static PCIDLIST_ABSOLUTE IShellItemArray **static void **static void **static PWSTR *static SIGDN
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder LPCITEMIDLIST IShellItemArray **static PCIDLIST_ABSOLUTE IShellItemArray **static void **static void **static PWSTR *static PWSTR *static DATAOBJ_GET_ITEM_FLAGS
 
static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder LPCITEMIDLIST IShellItemArray **static PCIDLIST_ABSOLUTE IShellItemArray **static void **static void **static PWSTR *static PWSTR *static void **static PIDLIST_ABSOLUTE *static void **static PBOOL
 
static void **static WCHAR GPFIDL_FLAGS
 
struct {
   WCHAR   path [MAX_PATH]
 
   HRESULT   hr
 
   int   todo
 
parse_tests []
 
static const IPropertyBagVtbl InitPropertyBag_IPropertyBagVtbl
 
static struct IPropertyBag InitPropertyBag
 
static const IUnknownVtbl vt_IUnknown
 
static IFileSystemBindDataVtbl fsbdVtbl
 
static IFileSystemBindData fsbd = { &fsbdVtbl }
 
static const CHAR testwindow_class [] = "testwindow"
 
struct ChNotifyTest chnotify_tests []
 
struct ChNotifyTestexp_data
 
BOOL test_new_delivery_flag
 

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 24 of file shlfolder.c.

◆ CONST_VTABLE

#define CONST_VTABLE

Definition at line 25 of file shlfolder.c.

◆ MAKEFUNC

#define MAKEFUNC (   f)    (p##f = (void*)GetProcAddress(hmod, #f))

◆ SFGAO_testfor

#define SFGAO_testfor   SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_CAPABILITYMASK

◆ SFGAO_VISTA

#define SFGAO_VISTA   SFGAO_DROPTARGET | SFGAO_CANLINK | SFGAO_CANCOPY

◆ TESTNAMED

#define TESTNAMED (   f)
Value:
ptr = (void*)GetProcAddress(hmod, #f); \
ok(ptr != 0, "expected named export for " #f "\n");
#define GetProcAddress(x, y)
Definition: compat.h:753
GLfloat f
Definition: glext.h:7540
static PVOID ptr
Definition: dispmode.c:27
static PEXPLICIT_ACCESSW *static HMODULE hmod
Definition: security.c:143

◆ verify_pidl

#define verify_pidl (   i,
  p 
)    r_verify_pidl(__LINE__, i, p)

Definition at line 4526 of file shlfolder.c.

◆ WM_USER_NOTIFY

#define WM_USER_NOTIFY   (WM_APP+1)

Definition at line 4853 of file shlfolder.c.

Function Documentation

◆ BOOL()

static IBindCtx void **static IBindCtx void **static void **static IShellFolder IShellItem **static IShellFolder LPCITEMIDLIST IShellItemArray **static PCIDLIST_ABSOLUTE IShellItemArray **static void **static void **static PWSTR *static PWSTR *static void **static PIDLIST_ABSOLUTE *static void **static BOOL ( WINAPI pIsWow64Process)
static

◆ Cleanup()

static void Cleanup ( void  )
static

Definition at line 308 of file shlfolder.c.

309{
310 DeleteFileA(".\\testdir\\test1.txt");
311 DeleteFileA(".\\testdir\\test2.txt");
312 DeleteFileA(".\\testdir\\test3.txt");
313 RemoveDirectoryA(".\\testdir\\test.txt");
314 RemoveDirectoryA(".\\testdir\\testdir2\\subdir");
315 RemoveDirectoryA(".\\testdir\\testdir2");
316 RemoveDirectoryA(".\\testdir");
317}
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
BOOL WINAPI RemoveDirectoryA(IN LPCSTR lpPathName)
Definition: dir.c:714

Referenced by test_EnumObjects_and_CompareIDs(), test_GetAttributesOf(), test_GetUIObject(), test_SHCreateDefaultContextMenu(), test_SHCreateShellItemArray(), test_ShellItemArrayGetAttributes(), and test_ShellItemGetAttributes().

◆ CreateFilesFolders()

static void CreateFilesFolders ( void  )
static

Definition at line 296 of file shlfolder.c.

297{
298 CreateDirectoryA(".\\testdir", NULL);
299 CreateDirectoryA(".\\testdir\\test.txt", NULL);
300 CreateTestFile (".\\testdir\\test1.txt ");
301 CreateTestFile (".\\testdir\\test2.txt ");
302 CreateTestFile (".\\testdir\\test3.txt ");
303 CreateDirectoryA(".\\testdir\\testdir2 ", NULL);
304 CreateDirectoryA(".\\testdir\\testdir2\\subdir", NULL);
305}
#define NULL
Definition: types.h:112
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37
static void CreateTestFile(const CHAR *name)
Definition: shlfolder.c:280

Referenced by test_EnumObjects_and_CompareIDs(), test_GetAttributesOf(), test_GetUIObject(), test_SHCreateDefaultContextMenu(), test_SHCreateShellItemArray(), test_ShellItemArrayEnumItems(), test_ShellItemArrayGetAttributes(), and test_ShellItemGetAttributes().

◆ CreateTestFile()

static void CreateTestFile ( const CHAR name)
static

Definition at line 280 of file shlfolder.c.

281{
282 HANDLE file;
283 DWORD written;
284
287 {
288 WriteFile(file, name, strlen(name), &written, NULL);
289 WriteFile(file, "\n", strlen("\n"), &written, NULL);
291 }
292}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define CloseHandle
Definition: compat.h:739
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
unsigned long DWORD
Definition: ntddk_ex.h:95
#define CREATE_ALWAYS
Definition: disk.h:72
#define GENERIC_WRITE
Definition: nt_native.h:90
Definition: fci.c:127
Definition: name.c:39

Referenced by CreateFilesFolders(), test_SHCreateShellItem(), and test_ShellItemCompare().

◆ DEFINE_GUID() [1/2]

DEFINE_GUID ( CLSID_ShellDocObjView  ,
0xe7e4bc40  ,
0xe76a  ,
0x11ce  ,
0xa9  ,
0xbb  ,
0x00  ,
0xaa  ,
0x00  ,
0x4a  ,
0xe8  ,
0x37   
)

◆ DEFINE_GUID() [2/2]

DEFINE_GUID ( IID_IParentAndItem  ,
0xB3A4B685  ,
0xB685  ,
0x4805  ,
0x99  ,
0xD9  ,
0x5D  ,
0xEA  ,
0xD2  ,
0x87  ,
0x32  ,
0x36   
)

◆ do_events()

static void do_events ( void  )
static

Definition at line 4929 of file shlfolder.c.

4930{
4931 int c = 0;
4932 while (exp_data->missing_events && (c++ < 10)){
4933 MSG msg;
4934 while(PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)){
4937 }
4938 if(exp_data->missing_events)
4939 Sleep(500);
4940 }
4941 trace("%s: took %d tries\n", exp_data->id, c);
4942}
#define trace
Definition: atltest.h:70
#define msg(x)
Definition: auth_time.c:54
const GLubyte * c
Definition: glext.h:8905
struct ChNotifyTest * exp_data
Definition: shlfolder.c:4868
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
LRESULT WINAPI DispatchMessageA(_In_ const MSG *)
BOOL WINAPI TranslateMessage(_In_ const MSG *)
#define PM_REMOVE
Definition: winuser.h:1196
BOOL WINAPI PeekMessageA(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)

Referenced by test_SHChangeNotify().

◆ fsbd_AddRef()

static ULONG WINAPI fsbd_AddRef ( IFileSystemBindData fsbd)
static

Definition at line 4611 of file shlfolder.c.

4612{
4613 return 2;
4614}

◆ fsbd_GetFindData_fail()

static HRESULT WINAPI fsbd_GetFindData_fail ( IFileSystemBindData fsbd,
WIN32_FIND_DATAW pfd 
)
static

Definition at line 4660 of file shlfolder.c.

4662{
4663 return E_FAIL;
4664}
#define E_FAIL
Definition: ddrawi.h:102

Referenced by test_ParseDisplayNamePBC().

◆ fsbd_GetFindData_invalid()

static HRESULT WINAPI fsbd_GetFindData_invalid ( IFileSystemBindData fsbd,
WIN32_FIND_DATAW pfd 
)
static

Definition at line 4642 of file shlfolder.c.

4644{
4645 memset(pfd, 0, sizeof(WIN32_FIND_DATAW));
4646 *pfd->cFileName = 'a';
4647 *pfd->cAlternateFileName = 'a';
4648 return S_OK;
4649}
#define S_OK
Definition: intsafe.h:52
#define memset(x, y, z)
Definition: compat.h:39
static PIXELFORMATDESCRIPTOR pfd
Definition: ssstars.c:67

Referenced by test_ParseDisplayNamePBC().

◆ fsbd_GetFindData_junk()

static HRESULT WINAPI fsbd_GetFindData_junk ( IFileSystemBindData fsbd,
WIN32_FIND_DATAW pfd 
)
static

Definition at line 4635 of file shlfolder.c.

4637{
4638 memset(pfd, 0xef, sizeof(WIN32_FIND_DATAW));
4639 return S_OK;
4640}

Referenced by test_ParseDisplayNamePBC().

◆ fsbd_GetFindData_nul()

static HRESULT WINAPI fsbd_GetFindData_nul ( IFileSystemBindData fsbd,
WIN32_FIND_DATAW pfd 
)
static

Definition at line 4628 of file shlfolder.c.

4630{
4631 memset(pfd, 0, sizeof(WIN32_FIND_DATAW));
4632 return S_OK;
4633}

Referenced by test_ParseDisplayNamePBC().

◆ fsbd_GetFindData_valid()

static HRESULT WINAPI fsbd_GetFindData_valid ( IFileSystemBindData fsbd,
WIN32_FIND_DATAW pfd 
)
static

Definition at line 4651 of file shlfolder.c.

4653{
4654 static const WCHAR adirW[] = {'C',':','\\','f','s','b','d','d','i','r',0};
4655 HANDLE handle = FindFirstFileW(adirW, pfd);
4657 return S_OK;
4658}
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by test_ParseDisplayNamePBC().

◆ fsbd_QueryInterface()

static HRESULT WINAPI fsbd_QueryInterface ( IFileSystemBindData fsbd,
REFIID  riid,
void **  ppv 
)
static

Definition at line 4600 of file shlfolder.c.

4602{
4603 if(IsEqualIID(riid, &IID_IFileSystemBindData) ||
4605 *ppv = fsbd;
4606 return S_OK;
4607 }
4608 return E_NOINTERFACE;
4609}
const GUID IID_IUnknown
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
static IFileSystemBindData fsbd
Definition: shlfolder.c:4674
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ fsbd_Release()

static ULONG WINAPI fsbd_Release ( IFileSystemBindData fsbd)
static

Definition at line 4616 of file shlfolder.c.

4617{
4618 return 1;
4619}

◆ fsbd_SetFindData()

static HRESULT WINAPI fsbd_SetFindData ( IFileSystemBindData fsbd,
const WIN32_FIND_DATAW pfd 
)
static

Definition at line 4621 of file shlfolder.c.

4623{
4624 ok(0, "SetFindData called\n");
4625 return E_NOTIMPL;
4626}
#define ok(value,...)
Definition: atltest.h:57
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ get_empty_cddrive()

static WCHAR * get_empty_cddrive ( void  )
static

Definition at line 4220 of file shlfolder.c.

4221{
4222 static WCHAR cdrom_drive[] = {'A',':','\\',0};
4223 DWORD drives = GetLogicalDrives();
4224
4225 cdrom_drive[0] = 'A';
4226 while (drives)
4227 {
4228 if ((drives & 1) &&
4229 GetDriveTypeW(cdrom_drive) == DRIVE_CDROM &&
4231 {
4232 return cdrom_drive;
4233 }
4234
4235 drives = drives >> 1;
4236 cdrom_drive[0]++;
4237 }
4238 return NULL;
4239}
UINT WINAPI GetDriveTypeW(IN LPCWSTR lpRootPathName)
Definition: disk.c:497
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
#define DRIVE_CDROM
Definition: machpc98.h:119
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
DWORD WINAPI GetLogicalDrives(void)
Definition: disk.c:110

Referenced by test_SHParseDisplayName().

◆ HRESULT()

static HRESULT ( WINAPI pSHCreateItemFromIDList)
static

◆ impl_from_IUnknown()

static IUnknownImpl * impl_from_IUnknown ( IUnknown iface)
inlinestatic

Definition at line 2981 of file shlfolder.c.

2982{
2983 return CONTAINING_RECORD(iface, IUnknownImpl, IUnknown_iface);
2984}
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by unk_fnQueryInterface().

◆ init_function_pointers()

static void init_function_pointers ( void  )
static

Definition at line 98 of file shlfolder.c.

99{
101 HRESULT hr;
102 void *ptr;
103
104 hmod = GetModuleHandleA("shell32.dll");
105
106#define MAKEFUNC(f) (p##f = (void*)GetProcAddress(hmod, #f))
109 MAKEFUNC(SHCreateItemFromRelativeName);
110 MAKEFUNC(SHCreateItemInKnownFolder);
116 MAKEFUNC(SHGetKnownFolderPath);
122 MAKEFUNC(SHGetPathFromIDListEx);
123 MAKEFUNC(SHGetSetFolderCustomSettings);
124#undef MAKEFUNC
125
126 /* test named exports */
127 ptr = GetProcAddress(hmod, "ILFree");
128 ok(broken(ptr == 0) || ptr != 0, "expected named export for ILFree\n");
129 if (ptr)
130 {
131#define TESTNAMED(f) \
132 ptr = (void*)GetProcAddress(hmod, #f); \
133 ok(ptr != 0, "expected named export for " #f "\n");
134
150#undef TESTNAMED
151 }
152
153 hmod = GetModuleHandleA("kernel32.dll");
154 pIsWow64Process = (void*)GetProcAddress(hmod, "IsWow64Process");
155
156 hr = SHGetMalloc(&ppM);
157 ok(hr == S_OK, "SHGetMalloc failed %08x\n", hr);
158}
HRESULT WINAPI SHCreateDefaultContextMenu(const DEFCONTEXTMENU *pdcm, REFIID riid, void **ppv)
EXTERN_C HRESULT WINAPI SHCreateShellItem(PCIDLIST_ABSOLUTE pidlParent, IShellFolder *psfParent, PCUITEMID_CHILD pidl, IShellItem **ppsi)
Definition: CShellItem.cpp:264
#define broken(x)
Definition: _sntprintf.h:21
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
HRESULT WINAPI SHGetMalloc(LPMALLOC *lpmal)
Definition: shellole.c:285
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:237
LPITEMIDLIST WINAPI ILFindLastID(LPCITEMIDLIST pidl)
Definition: pidl.c:198
HRESULT WINAPI SHGetIDListFromObject(IUnknown *punk, PIDLIST_ABSOLUTE *ppidl)
Definition: pidl.c:1519
BOOL WINAPI ILIsParent(LPCITEMIDLIST pidlParent, LPCITEMIDLIST pidlChild, BOOL bImmediate)
Definition: pidl.c:605
HRESULT WINAPI SHGetNameFromIDList(PCIDLIST_ABSOLUTE pidl, SIGDN sigdnName, PWSTR *ppszName)
Definition: pidl.c:1456
LPITEMIDLIST WINAPI ILCombine(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:712
LPITEMIDLIST WINAPI ILCloneFirst(LPCITEMIDLIST pidl)
Definition: pidl.c:262
BOOL WINAPI ILRemoveLastID(LPITEMIDLIST pidl)
Definition: pidl.c:221
HRESULT WINAPI ILSaveToStream(IStream *pStream, LPCITEMIDLIST pPidl)
Definition: pidl.c:351
LPITEMIDLIST WINAPI ILAppendID(LPITEMIDLIST pidl, LPCSHITEMID item, BOOL bEnd)
Definition: pidl.c:900
LPITEMIDLIST WINAPI ILGetNext(LPCITEMIDLIST pidl)
Definition: pidl.c:866
PUIDLIST_RELATIVE WINAPI ILFindChild(PIDLIST_ABSOLUTE pidl1, PCIDLIST_ABSOLUTE pidl2)
Definition: pidl.c:654
LPITEMIDLIST WINAPI ILCreateFromPathW(LPCWSTR path)
Definition: pidl.c:997
LPITEMIDLIST WINAPI ILCreateFromPathA(LPCSTR path)
Definition: pidl.c:981
BOOL WINAPI ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
Definition: pidl.c:548
#define ILGetSize
Definition: shellclasses.h:638
#define MAKEFUNC(f)
static IMalloc * ppM
Definition: shlfolder.c:47
#define TESTNAMED(f)
HRESULT hr
Definition: shlfolder.c:183
#define ILCreateFromPath
Definition: shlobj.h:2492
HRESULT WINAPI SHCreateItemFromIDList(PCIDLIST_ABSOLUTE pidl, REFIID riid, void **ppv)
HRESULT WINAPI SHCreateItemFromParsingName(PCWSTR pszPath, IBindCtx *pbc, REFIID riid, void **ppv)
HRESULT WINAPI SHCreateShellItemArrayFromDataObject(IDataObject *pdo, REFIID riid, void **ppv)
HRESULT WINAPI SHCreateShellItemArrayFromIDLists(UINT cidl, PCIDLIST_ABSOLUTE_ARRAY pidl_array, IShellItemArray **psia)
HRESULT WINAPI SHCreateShellItemArray(PCIDLIST_ABSOLUTE pidlParent, IShellFolder *psf, UINT cidl, PCUITEMID_CHILD_ARRAY ppidl, IShellItemArray **ppsiItemArray)
HRESULT WINAPI SHGetItemFromDataObject(IDataObject *pdtobj, DATAOBJ_GET_ITEM_FLAGS dwFlags, REFIID riid, void **ppv)
HRESULT WINAPI SHCreateShellItemArrayFromShellItem(IShellItem *psi, REFIID riid, void **ppv)
HRESULT WINAPI SHGetItemFromObject(IUnknown *punk, REFIID riid, void **ppv)

Referenced by START_TEST().

◆ InitPropertyBag_IPropertyBag_AddRef()

static ULONG WINAPI InitPropertyBag_IPropertyBag_AddRef ( IPropertyBag iface)
static

Definition at line 1276 of file shlfolder.c.

1276 {
1277 return 2;
1278}

◆ InitPropertyBag_IPropertyBag_QueryInterface()

static HRESULT WINAPI InitPropertyBag_IPropertyBag_QueryInterface ( IPropertyBag iface,
REFIID  riid,
void **  ppvObject 
)
static

Definition at line 1259 of file shlfolder.c.

1261{
1262 if (!ppvObject)
1263 return E_INVALIDARG;
1264
1266 *ppvObject = iface;
1267 } else {
1268 ok (FALSE, "InitPropertyBag asked for unknown interface!\n");
1269 return E_NOINTERFACE;
1270 }
1271
1272 IPropertyBag_AddRef(iface);
1273 return S_OK;
1274}
#define E_INVALIDARG
Definition: ddrawi.h:101
#define FALSE
Definition: types.h:117
const GUID IID_IPropertyBag
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082

◆ InitPropertyBag_IPropertyBag_Read()

static HRESULT WINAPI InitPropertyBag_IPropertyBag_Read ( IPropertyBag iface,
LPCOLESTR  pszPropName,
VARIANT pVar,
IErrorLog pErrorLog 
)
static

Definition at line 1284 of file shlfolder.c.

1286{
1287 static const WCHAR wszTargetSpecialFolder[] = {
1288 'T','a','r','g','e','t','S','p','e','c','i','a','l','F','o','l','d','e','r',0 };
1289 static const WCHAR wszTarget[] = {
1290 'T','a','r','g','e','t',0 };
1291 static const WCHAR wszAttributes[] = {
1292 'A','t','t','r','i','b','u','t','e','s',0 };
1293 static const WCHAR wszResolveLinkFlags[] = {
1294 'R','e','s','o','l','v','e','L','i','n','k','F','l','a','g','s',0 };
1295 static const WCHAR wszTargetKnownFolder[] = {
1296 'T','a','r','g','e','t','K','n','o','w','n','F','o','l','d','e','r',0 };
1297 static const WCHAR wszCLSID[] = {
1298 'C','L','S','I','D',0 };
1299
1300 if (!lstrcmpW(pszPropName, wszTargetSpecialFolder)) {
1301 ok(V_VT(pVar) == VT_I4, "Wrong variant type for 'TargetSpecialFolder' property!\n");
1302 return E_INVALIDARG;
1303 }
1304
1305 if (!lstrcmpW(pszPropName, wszResolveLinkFlags))
1306 {
1307 ok(V_VT(pVar) == VT_UI4, "Wrong variant type for 'ResolveLinkFlags' property!\n");
1308 return E_INVALIDARG;
1309 }
1310
1311 if (!lstrcmpW(pszPropName, wszTarget)) {
1312 WCHAR wszPath[MAX_PATH];
1313 BOOL result;
1314
1315 ok(V_VT(pVar) == VT_BSTR, "Wrong variant type for 'Target' property!\n");
1316 if (V_VT(pVar) != VT_BSTR) return E_INVALIDARG;
1317
1319 ok(result, "SHGetSpecialFolderPathW(DESKTOPDIRECTORY) failed! %u\n", GetLastError());
1320 if (!result) return E_INVALIDARG;
1321
1322 V_BSTR(pVar) = SysAllocString(wszPath);
1323 return S_OK;
1324 }
1325
1326 if (!lstrcmpW(pszPropName, wszAttributes)) {
1327 ok(V_VT(pVar) == VT_UI4, "Wrong variant type for 'Attributes' property!\n");
1328 if (V_VT(pVar) != VT_UI4) return E_INVALIDARG;
1329 V_UI4(pVar) = SFGAO_FOLDER|SFGAO_HASSUBFOLDER|SFGAO_FILESYSANCESTOR|
1330 SFGAO_CANRENAME|SFGAO_FILESYSTEM;
1331 return S_OK;
1332 }
1333
1334 if (!lstrcmpW(pszPropName, wszTargetKnownFolder)) {
1335 ok(V_VT(pVar) == VT_BSTR, "Wrong variant type for 'TargetKnownFolder' property!\n");
1336 /* TODO */
1337 return E_INVALIDARG;
1338 }
1339
1340 if (!lstrcmpW(pszPropName, wszCLSID)) {
1341 ok(V_VT(pVar) == VT_EMPTY, "Wrong variant type for 'CLSID' property!\n");
1342 /* TODO */
1343 return E_INVALIDARG;
1344 }
1345
1346 ok(FALSE, "PropertyBag was asked for unknown property %s (vt=%d)!\n", wine_dbgstr_w(pszPropName), V_VT(pVar));
1347 return E_INVALIDARG;
1348}
#define MAX_PATH
Definition: compat.h:34
@ VT_BSTR
Definition: compat.h:2303
@ VT_I4
Definition: compat.h:2298
@ VT_UI4
Definition: compat.h:2313
@ VT_EMPTY
Definition: compat.h:2295
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4242
BOOL WINAPI SHGetSpecialFolderPathW(HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
Definition: shellpath.c:3092
unsigned int BOOL
Definition: ntddk_ex.h:94
GLuint64EXT * result
Definition: glext.h:11304
#define wine_dbgstr_w
Definition: kernel32.h:34
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
#define V_VT(A)
Definition: oleauto.h:211
#define V_BSTR(A)
Definition: oleauto.h:226
#define V_UI4(A)
Definition: oleauto.h:270
#define CSIDL_DESKTOPDIRECTORY
Definition: shlobj.h:2174
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

◆ InitPropertyBag_IPropertyBag_Release()

static ULONG WINAPI InitPropertyBag_IPropertyBag_Release ( IPropertyBag iface)
static

Definition at line 1280 of file shlfolder.c.

1280 {
1281 return 1;
1282}

◆ InitPropertyBag_IPropertyBag_Write()

static HRESULT WINAPI InitPropertyBag_IPropertyBag_Write ( IPropertyBag iface,
LPCOLESTR  pszPropName,
VARIANT pVar 
)
static

Definition at line 1350 of file shlfolder.c.

1352{
1353 ok(FALSE, "Unexpected call to IPropertyBag_Write\n");
1354 return E_NOTIMPL;
1355}

◆ make_wstr()

static WCHAR * make_wstr ( const char str)
static

Definition at line 71 of file shlfolder.c.

72{
73 WCHAR *ret;
74 int len;
75
76 if (!str || !str[0])
77 return NULL;
78
79 len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
80 if(!len || len < 0)
81 return NULL;
82
83 ret = heap_alloc(len * sizeof(WCHAR));
84 if(!ret)
85 return NULL;
86
88 return ret;
89}
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
GLenum GLsizei len
Definition: glext.h:6722
const WCHAR * str
int ret

Referenced by test_SHChangeNotify(), and testwindow_wndproc().

◆ myPathAddBackslashW()

static LPWSTR myPathAddBackslashW ( LPWSTR  lpszPath)
static

Definition at line 161 of file shlfolder.c.

162{
163 size_t iLen;
164
165 if (!lpszPath || (iLen = lstrlenW(lpszPath)) >= MAX_PATH)
166 return NULL;
167
168 if (iLen)
169 {
170 lpszPath += iLen;
171 if (lpszPath[-1] != '\\')
172 {
173 *lpszPath++ = '\\';
174 *lpszPath = '\0';
175 }
176 }
177 return lpszPath;
178}
#define lstrlenW
Definition: compat.h:750

Referenced by test_FolderShortcut(), test_SHCreateShellItem(), test_SHCreateShellItemArray(), test_ShellItemArrayEnumItems(), test_ShellItemArrayGetAttributes(), test_ShellItemGetAttributes(), and test_SHGetPathFromIDList().

◆ r_verify_pidl()

static void r_verify_pidl ( unsigned  l,
LPCITEMIDLIST  pidl,
const WCHAR path 
)
static

Definition at line 4527 of file shlfolder.c.

4528{
4532 HRESULT hr;
4533
4534 if(path){
4535 if(!pidl){
4536 ok_(__FILE__,l)(0, "didn't get expected path (%s), instead: NULL\n", wine_dbgstr_w(path));
4537 return;
4538 }
4539
4540 hr = SHBindToParent(pidl, &IID_IShellFolder, (void **)&parent, &child);
4541 ok_(__FILE__,l)(hr == S_OK, "SHBindToParent failed: 0x%08x\n", hr);
4542 if(FAILED(hr))
4543 return;
4544
4545 hr = IShellFolder_GetDisplayNameOf(parent, child, SHGDN_FORPARSING, &filename);
4546 ok_(__FILE__,l)(hr == S_OK, "GetDisplayNameOf failed: 0x%08x\n", hr);
4547 if(FAILED(hr)){
4548 IShellFolder_Release(parent);
4549 return;
4550 }
4551
4552 ok_(__FILE__,l)(filename.uType == STRRET_WSTR || filename.uType == STRRET_CSTR,
4553 "Got unexpected string type: %d\n", filename.uType);
4554 if(filename.uType == STRRET_WSTR){
4555 ok_(__FILE__,l)(lstrcmpW(path, U(filename).pOleStr) == 0,
4556 "didn't get expected path (%s), instead: %s\n",
4558 SHFree(U(filename).pOleStr);
4559 }else if(filename.uType == STRRET_CSTR){
4560 ok_(__FILE__,l)(strcmp_wa(path, U(filename).cStr) == 0,
4561 "didn't get expected path (%s), instead: %s\n",
4562 wine_dbgstr_w(path), U(filename).cStr);
4563 }
4564
4565 IShellFolder_Release(parent);
4566 }else
4567 ok_(__FILE__,l)(pidl == NULL, "Expected PIDL to be NULL\n");
4568}
#define ok_(x1, x2)
Definition: atltest.h:61
#define U(x)
Definition: wordpad.c:45
r l[0]
Definition: byte_order.h:168
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:326
#define IShellFolder_GetDisplayNameOf
Definition: utils.cpp:13
r parent
Definition: btrfs.c:3010
#define FAILED(hr)
Definition: intsafe.h:51
const char * filename
Definition: ioapi.h:137
static HWND child
Definition: cursoricon.c:298
HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
Definition: pidl.c:1350
static int strcmp_wa(LPCWSTR strw, const char *stra)
Definition: shlfolder.c:91
@ STRRET_CSTR
Definition: shtypes.idl:87
@ STRRET_WSTR
Definition: shtypes.idl:85
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42

◆ register_testwindow_class()

static void register_testwindow_class ( void  )
static

Definition at line 4910 of file shlfolder.c.

4911{
4912 WNDCLASSEXA cls;
4913 ATOM ret;
4914
4915 ZeroMemory(&cls, sizeof(cls));
4916 cls.cbSize = sizeof(cls);
4917 cls.style = 0;
4921
4922 SetLastError(0);
4923 ret = RegisterClassExA(&cls);
4924 ok(ret != 0, "RegisterClassExA failed: %d\n", GetLastError());
4925}
WORD ATOM
Definition: dimm.idl:113
#define SetLastError(x)
Definition: compat.h:752
static LRESULT CALLBACK testwindow_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
Definition: shlfolder.c:4871
static const CHAR testwindow_class[]
Definition: shlfolder.c:4852
HINSTANCE hInstance
Definition: winuser.h:3206
UINT style
Definition: winuser.h:3202
UINT cbSize
Definition: winuser.h:3201
WNDPROC lpfnWndProc
Definition: winuser.h:3203
LPCSTR lpszClassName
Definition: winuser.h:3211
#define ZeroMemory
Definition: winbase.h:1712
ATOM WINAPI RegisterClassExA(_In_ CONST WNDCLASSEXA *)

Referenced by test_SHChangeNotify().

◆ START_TEST()

START_TEST ( shlfolder  )

Definition at line 5340 of file shlfolder.c.

5341{
5343 /* if OleInitialize doesn't get called, ParseDisplayName returns
5344 CO_E_NOTINITIALIZED for malformed directory names */
5346
5383
5385}
#define TRUE
Definition: types.h:120
HRESULT WINAPI DECLSPEC_HOTPATCH OleInitialize(LPVOID reserved)
Definition: ole2.c:169
void WINAPI DECLSPEC_HOTPATCH OleUninitialize(void)
Definition: ole2.c:230
static void test_GetUIObject(void)
Definition: shlfolder.c:4478
static void test_SHLimitInputEdit(void)
Definition: shlfolder.c:5260
static void test_ShellItemArrayEnumItems(void)
Definition: shlfolder.c:3711
static void test_SHGetFolderPathA(void)
Definition: shlfolder.c:1712
static void test_SHCreateShellItemArray(void)
Definition: shlfolder.c:3264
static void test_ShellItemCompare(void)
Definition: shlfolder.c:2744
static void test_ParseDisplayName(void)
Definition: shlfolder.c:207
static void test_SHCreateShellItem(void)
Definition: shlfolder.c:1998
static void test_SHGetItemFromObject(void)
Definition: shlfolder.c:3189
static void test_LocalizedNames(void)
Definition: shlfolder.c:1896
static void init_function_pointers(void)
Definition: shlfolder.c:98
static void test_desktop_IPersist(void)
Definition: shlfolder.c:4325
static void test_GetDefaultColumn(void)
Definition: shlfolder.c:5159
static void test_SHGetItemFromDataObject(void)
Definition: shlfolder.c:2631
static void test_SHParseDisplayName(void)
Definition: shlfolder.c:4241
static void test_ShellItemArrayGetAttributes(void)
Definition: shlfolder.c:4123
static void test_ITEMIDLIST_format(void)
Definition: shlfolder.c:1562
static void test_SHCreateDefaultContextMenu(void)
Definition: shlfolder.c:5018
static void test_SHGetPathFromIDList(void)
Definition: shlfolder.c:1065
static void test_GetAttributesOf(void)
Definition: shlfolder.c:928
static void test_EnumObjects_and_CompareIDs(void)
Definition: shlfolder.c:1211
static void test_SHGetFolderPathAndSubDirA(void)
Definition: shlfolder.c:1794
static void test_SHChangeNotify(BOOL test_new_delivery)
Definition: shlfolder.c:4944
static void test_FolderShortcut(void)
Definition: shlfolder.c:1369
static void test_ParseDisplayNamePBC(void)
Definition: shlfolder.c:4676
static void test_SHGetIDListFromObject(void)
Definition: shlfolder.c:3021
static void test_BindToObject(void)
Definition: shlfolder.c:416
static void test_GetDisplayName(void)
Definition: shlfolder.c:639
static void test_ShellItemBindToHandler(void)
Definition: shlfolder.c:3867
static void test_SHSimpleIDListFromPath(void)
Definition: shlfolder.c:4570
static void test_SHGetNameFromIDList(void)
Definition: shlfolder.c:2486
static void test_ShellItemGetAttributes(void)
Definition: shlfolder.c:4031
static void test_CallForAttributes(void)
Definition: shlfolder.c:806
static void test_DataObject(void)
Definition: shlfolder.c:5102
static void test_SHGetSetFolderCustomSettings(void)
Definition: shlfolder.c:5288
static void test_GetDefaultSearchGUID(void)
Definition: shlfolder.c:5212

◆ strcmp_wa()

static int strcmp_wa ( LPCWSTR  strw,
const char stra 
)
static

Definition at line 91 of file shlfolder.c.

92{
93 CHAR buf[512];
94 WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
95 return lstrcmpA(stra, buf);
96}
#define WideCharToMultiByte
Definition: compat.h:111
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4194
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static const char * strw(LPCWSTR x)
Definition: actctx.c:49
char CHAR
Definition: xmlstorage.h:175

Referenced by r_verify_pidl().

◆ test_BindToObject()

static void test_BindToObject ( void  )
static

Definition at line 416 of file shlfolder.c.

417{
418 HRESULT hr;
419 UINT cChars;
420 IShellFolder *psfDesktop, *psfChild, *psfMyComputer, *psfSystemDir;
421 SHITEMID emptyitem = { 0, { 0 } };
422 LPITEMIDLIST pidlMyComputer, pidlSystemDir, pidl, pidlEmpty = (LPITEMIDLIST)&emptyitem;
423 WCHAR wszSystemDir[MAX_PATH];
424 char szSystemDir[MAX_PATH];
425 char buf[MAX_PATH];
428 HANDLE hfile;
429 WCHAR wszMyComputer[] = {
430 ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
431 'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
432 static const CHAR filename_html[] = "winetest.html";
433 static const CHAR filename_txt[] = "winetest.txt";
434 static const CHAR filename_foo[] = "winetest.foo";
435
436 /* The following tests shows that BindToObject should fail with E_INVALIDARG if called
437 * with an empty pidl. This is tested for Desktop, MyComputer and the FS ShellFolder
438 */
439 hr = SHGetDesktopFolder(&psfDesktop);
440 ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
441 if (hr != S_OK) return;
442
443 hr = IShellFolder_BindToObject(psfDesktop, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
444 ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
445
446 hr = IShellFolder_BindToObject(psfDesktop, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
447 ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
448
449 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
450 ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
451 if (hr != S_OK) {
452 IShellFolder_Release(psfDesktop);
453 return;
454 }
455
456 hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
457 ok (hr == S_OK, "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
458 IShellFolder_Release(psfDesktop);
459 IMalloc_Free(ppM, pidlMyComputer);
460 if (hr != S_OK) return;
461
462 hr = IShellFolder_BindToObject(psfMyComputer, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
463 ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
464
465 hr = IShellFolder_BindToObject(psfMyComputer, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
466 ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
467
468 cChars = GetSystemDirectoryA(szSystemDir, MAX_PATH);
469 ok (cChars > 0 && cChars < MAX_PATH, "GetSystemDirectoryA failed! LastError: %u\n", GetLastError());
470 if (cChars == 0 || cChars >= MAX_PATH) {
471 IShellFolder_Release(psfMyComputer);
472 return;
473 }
474 MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszSystemDir, MAX_PATH);
475
476 hr = IShellFolder_ParseDisplayName(psfMyComputer, NULL, NULL, wszSystemDir, NULL, &pidlSystemDir, NULL);
477 ok (hr == S_OK, "MyComputers's ParseDisplayName failed to parse the SystemDirectory! hr = %08x\n", hr);
478 if (hr != S_OK) {
479 IShellFolder_Release(psfMyComputer);
480 return;
481 }
482
483 hr = IShellFolder_BindToObject(psfMyComputer, pidlSystemDir, NULL, &IID_IShellFolder, (LPVOID*)&psfSystemDir);
484 ok (hr == S_OK, "MyComputer failed to bind to a FileSystem ShellFolder! hr = %08x\n", hr);
485 IShellFolder_Release(psfMyComputer);
486 IMalloc_Free(ppM, pidlSystemDir);
487 if (hr != S_OK) return;
488
489 hr = IShellFolder_BindToObject(psfSystemDir, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
490 ok (hr == E_INVALIDARG,
491 "FileSystem ShellFolder's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
492
493 hr = IShellFolder_BindToObject(psfSystemDir, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
494 ok (hr == E_INVALIDARG,
495 "FileSystem ShellFolder's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
496
497 IShellFolder_Release(psfSystemDir);
498
500 if(!cChars)
501 {
502 skip("Failed to get current directory, skipping tests.\n");
503 return;
504 }
505 if(buf[cChars-1] != '\\') lstrcatA(buf, "\\");
506
507 SHGetDesktopFolder(&psfDesktop);
508
509 /* Attempt BindToObject on files. */
510
511 /* .html */
513 lstrcatA(pathA, filename_html);
515 if(hfile != INVALID_HANDLE_VALUE)
516 {
517 CloseHandle(hfile);
519 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, path, NULL, &pidl, NULL);
520 ok(hr == S_OK, "Got 0x%08x\n", hr);
521 if(SUCCEEDED(hr))
522 {
523 hr = IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (void**)&psfChild);
524 ok(hr == S_OK ||
525 hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP, W2K3 */
526 "Got 0x%08x\n", hr);
527 if(SUCCEEDED(hr))
528 {
529 IPersist *pp;
530 hr = IShellFolder_QueryInterface(psfChild, &IID_IPersist, (void**)&pp);
531 ok(hr == S_OK, "Got 0x%08x\n", hr);
532 if(SUCCEEDED(hr))
533 {
534 CLSID id;
535 hr = IPersist_GetClassID(pp, &id);
536 ok(hr == S_OK, "Got 0x%08x\n", hr);
537 ok(IsEqualIID(&id, &CLSID_ShellDocObjView), "Unexpected classid %s\n", wine_dbgstr_guid(&id));
538 IPersist_Release(pp);
539 }
540
541 IShellFolder_Release(psfChild);
542 }
543 ILFree(pidl);
544 }
546 }
547 else
548 win_skip("Failed to create .html testfile.\n");
549
550 /* .txt */
552 lstrcatA(pathA, filename_txt);
554 if(hfile != INVALID_HANDLE_VALUE)
555 {
556 CloseHandle(hfile);
558 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, path, NULL, &pidl, NULL);
559 ok(hr == S_OK, "Got 0x%08x\n", hr);
560 if(SUCCEEDED(hr))
561 {
562 hr = IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (void**)&psfChild);
563 ok(hr == E_FAIL || /* Vista+ */
564 hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP, W2K3 */
565 "Got 0x%08x\n", hr);
566 if(SUCCEEDED(hr)) IShellFolder_Release(psfChild);
567 ILFree(pidl);
568 }
570 }
571 else
572 win_skip("Failed to create .txt testfile.\n");
573
574 /* .foo */
576 lstrcatA(pathA, filename_foo);
578 if(hfile != INVALID_HANDLE_VALUE)
579 {
580 CloseHandle(hfile);
582 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, path, NULL, &pidl, NULL);
583 ok(hr == S_OK, "Got 0x%08x\n", hr);
584 if(SUCCEEDED(hr))
585 {
586 hr = IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (void**)&psfChild);
587 ok(hr == E_FAIL || /* Vista+ */
588 hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP, W2K3 */
589 "Got 0x%08x\n", hr);
590 if(SUCCEEDED(hr)) IShellFolder_Release(psfChild);
591 ILFree(pidl);
592 }
594 }
595 else
596 win_skip("Failed to create .foo testfile.\n");
597
598 /* And on the desktop */
600 lstrcatA(pathA, "\\");
601 lstrcatA(pathA, filename_html);
603
604 CloseHandle(hfile);
606 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, path, NULL, &pidl, NULL);
607 ok(hr == S_OK, "Got 0x%08x\n", hr);
608
609 hr = IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (void **)&psfChild);
610 ok(hr == S_OK ||
611 hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP, W2K3 */
612 "Got 0x%08x\n", hr);
613 if(SUCCEEDED(hr)) IShellFolder_Release(psfChild);
614 ILFree(pidl);
615 if(!DeleteFileA(pathA))
616 trace("Failed to delete: %d\n", GetLastError());
617
619 lstrcatA(pathA, "\\");
620 lstrcatA(pathA, filename_foo);
622
623 CloseHandle(hfile);
625 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, path, NULL, &pidl, NULL);
626 ok(hr == S_OK, "Got 0x%08x\n", hr);
627
628 hr = IShellFolder_BindToObject(psfDesktop, pidl, NULL, &IID_IShellFolder, (void **)&psfChild);
629 ok(hr == E_FAIL || /* Vista+ */
630 hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP, W2K3 */
631 "Got 0x%08x\n", hr);
632 if(SUCCEEDED(hr)) IShellFolder_Release(psfChild);
633 ILFree(pidl);
635
636 IShellFolder_Release(psfDesktop);
637}
HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
#define skip(...)
Definition: atltest.h:64
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2146
UINT WINAPI GetSystemDirectoryA(OUT LPSTR lpBuffer, IN UINT uSize)
Definition: path.c:2283
BOOL WINAPI SHGetSpecialFolderPathA(HWND hwndOwner, LPSTR szPath, int nFolder, BOOL bCreate)
Definition: shellpath.c:3079
#define IShellFolder_ParseDisplayName
Definition: utils.cpp:14
GLuint pathA
Definition: glext.h:11719
GLuint id
Definition: glext.h:5910
#define SUCCEEDED(hr)
Definition: intsafe.h:50
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
LPSTR WINAPI lstrcatA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:123
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static SCRIPT_CACHE SCRIPT_ANALYSIS OPENTYPE_TAG OPENTYPE_TAG int TEXTRANGE_PROPERTIES int const WCHAR int cChars
Definition: usp10.c:64
unsigned int UINT
Definition: ndis.h:50
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:940
const GUID IID_IPersist
Definition: proxy.cpp:14
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197
#define win_skip
Definition: test.h:163
#define CSIDL_DESKTOP
Definition: shlobj.h:2159
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92

Referenced by START_TEST().

◆ test_CallForAttributes()

static void test_CallForAttributes ( void  )
static

Definition at line 806 of file shlfolder.c.

807{
808 HKEY hKey;
809 LONG lResult;
810 HRESULT hr;
812 LPSHELLFOLDER psfDesktop;
813 LPITEMIDLIST pidlMyDocuments;
814 DWORD dwAttributes, dwCallForAttributes, dwOrigAttributes, dwOrigCallForAttributes;
815 static const WCHAR wszAttributes[] = { 'A','t','t','r','i','b','u','t','e','s',0 };
816 static const WCHAR wszCallForAttributes[] = {
817 'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0 };
818 static const WCHAR wszMyDocumentsKey[] = {
819 'C','L','S','I','D','\\','{','4','5','0','D','8','F','B','A','-','A','D','2','5','-',
820 '1','1','D','0','-','9','8','A','8','-','0','8','0','0','3','6','1','B','1','1','0','3','}',
821 '\\','S','h','e','l','l','F','o','l','d','e','r',0 };
822 WCHAR wszMyDocuments[] = {
823 ':',':','{','4','5','0','D','8','F','B','A','-','A','D','2','5','-','1','1','D','0','-',
824 '9','8','A','8','-','0','8','0','0','3','6','1','B','1','1','0','3','}',0 };
825
826 /* For the root of a namespace extension, the attributes are not queried by binding
827 * to the object and calling GetAttributesOf. Instead, the attributes are read from
828 * the registry value HKCR/CLSID/{...}/ShellFolder/Attributes. This is documented on MSDN.
829 *
830 * The MyDocuments shellfolder on WinXP has a HKCR/CLSID/{...}/ShellFolder/CallForAttributes
831 * value. It seems that if the folder is queried for one of the flags set in CallForAttributes,
832 * the shell does bind to the folder object and calls GetAttributesOf. This is not documented
833 * on MSDN. This test is meant to document the observed behaviour on WinXP SP2.
834 */
835 hr = SHGetDesktopFolder(&psfDesktop);
836 ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
837 if (hr != S_OK) return;
838
839 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyDocuments, NULL,
840 &pidlMyDocuments, NULL);
841 ok (hr == S_OK,
842 "Desktop's ParseDisplayName failed to parse MyDocuments's CLSID! hr = %08x\n", hr);
843 if (hr != S_OK) {
844 IShellFolder_Release(psfDesktop);
845 return;
846 }
847
848 dwAttributes = 0xffffffff;
849 hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
850 (LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
851 ok (hr == S_OK, "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
852
853 /* We need the following setup (as observed on WinXP SP2), for the tests to make sense. */
854 ok (dwAttributes & SFGAO_FILESYSTEM, "SFGAO_FILESYSTEM attribute is not set for MyDocuments!\n");
855 ok (!(dwAttributes & SFGAO_ISSLOW), "SFGAO_ISSLOW attribute is set for MyDocuments!\n");
856 ok (!(dwAttributes & SFGAO_GHOSTED), "SFGAO_GHOSTED attribute is set for MyDocuments!\n");
857
858 /* We don't have the MyDocuments shellfolder in wine yet, and thus we don't have the registry
859 * key. So the test will return at this point, if run on wine.
860 */
861 lResult = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszMyDocumentsKey, 0, KEY_WRITE|KEY_READ, &hKey);
862 ok (lResult == ERROR_SUCCESS ||
863 lResult == ERROR_ACCESS_DENIED,
864 "RegOpenKeyEx failed! result: %08x\n", lResult);
865 if (lResult != ERROR_SUCCESS) {
866 if (lResult == ERROR_ACCESS_DENIED)
867 skip("Not enough rights to open the registry key\n");
868 IMalloc_Free(ppM, pidlMyDocuments);
869 IShellFolder_Release(psfDesktop);
870 return;
871 }
872
873 /* Query MyDocuments' Attributes value, to be able to restore it later. */
874 dwSize = sizeof(DWORD);
875 lResult = RegQueryValueExW(hKey, wszAttributes, NULL, NULL, (LPBYTE)&dwOrigAttributes, &dwSize);
876 ok (lResult == ERROR_SUCCESS, "RegQueryValueEx failed! result: %08x\n", lResult);
877 if (lResult != ERROR_SUCCESS) {
879 IMalloc_Free(ppM, pidlMyDocuments);
880 IShellFolder_Release(psfDesktop);
881 return;
882 }
883
884 /* Query MyDocuments' CallForAttributes value, to be able to restore it later. */
885 dwSize = sizeof(DWORD);
886 lResult = RegQueryValueExW(hKey, wszCallForAttributes, NULL, NULL,
887 (LPBYTE)&dwOrigCallForAttributes, &dwSize);
888 ok (lResult == ERROR_SUCCESS, "RegQueryValueEx failed! result: %08x\n", lResult);
889 if (lResult != ERROR_SUCCESS) {
891 IMalloc_Free(ppM, pidlMyDocuments);
892 IShellFolder_Release(psfDesktop);
893 return;
894 }
895
896 /* Define via the Attributes value that MyDocuments attributes are SFGAO_ISSLOW and
897 * SFGAO_GHOSTED and that MyDocuments should be called for the SFGAO_ISSLOW and
898 * SFGAO_FILESYSTEM attributes. */
899 dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED;
900 RegSetValueExW(hKey, wszAttributes, 0, REG_DWORD, (LPBYTE)&dwAttributes, sizeof(DWORD));
901 dwCallForAttributes = SFGAO_ISSLOW|SFGAO_FILESYSTEM;
902 RegSetValueExW(hKey, wszCallForAttributes, 0, REG_DWORD,
903 (LPBYTE)&dwCallForAttributes, sizeof(DWORD));
904
905 /* Although it is not set in CallForAttributes, the SFGAO_GHOSTED flag is reset by
906 * GetAttributesOf. It seems that once there is a single attribute queried, for which
907 * CallForAttributes is set, all flags are taken from the GetAttributesOf call and
908 * the flags in Attributes are ignored.
909 */
910 dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED|SFGAO_FILESYSTEM;
911 hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
912 (LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
913 ok (hr == S_OK, "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
914 if (hr == S_OK)
915 ok (dwAttributes == SFGAO_FILESYSTEM,
916 "Desktop->GetAttributes(MyDocuments) returned unexpected attributes: %08x\n",
918
919 /* Restore MyDocuments' original Attributes and CallForAttributes registry values */
920 RegSetValueExW(hKey, wszAttributes, 0, REG_DWORD, (LPBYTE)&dwOrigAttributes, sizeof(DWORD));
921 RegSetValueExW(hKey, wszCallForAttributes, 0, REG_DWORD,
922 (LPBYTE)&dwOrigCallForAttributes, sizeof(DWORD));
924 IMalloc_Free(ppM, pidlMyDocuments);
925 IShellFolder_Release(psfDesktop);
926}
#define RegCloseKey(hKey)
Definition: registry.h:49
#define ERROR_SUCCESS
Definition: deptool.c:10
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
FxAutoRegKey hKey
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define KEY_READ
Definition: nt_native.h:1023
#define KEY_WRITE
Definition: nt_native.h:1031
long LONG
Definition: pedump.c:60
#define REG_DWORD
Definition: sdbapi.c:596
static IBindCtx void **static IBindCtx void **static DWORD
Definition: shlfolder.c:52
unsigned char * LPBYTE
Definition: typedefs.h:53
DWORD dwAttributes
Definition: vdmdbg.h:34
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10

Referenced by START_TEST().

◆ test_contextmenu()

static void test_contextmenu ( IContextMenu menu,
BOOL  background 
)
static

Definition at line 4399 of file shlfolder.c.

4400{
4402 const int id_upper_limit = 32767;
4403 const int baseItem = 0x40;
4404 INT max_id, max_id_check;
4405 UINT count, i;
4406 HRESULT hr;
4407
4409
4410 hr = IContextMenu_QueryContextMenu(menu, hmenu, 0, baseItem, id_upper_limit, CMF_NORMAL);
4411 ok(SUCCEEDED(hr), "Failed to query the menu, hr %#x.\n", hr);
4412
4413 max_id = HRESULT_CODE(hr) - 1; /* returns max_id + 1 */
4414 ok(max_id <= id_upper_limit, "Got %d\n", max_id);
4416 ok(count, "Got %d\n", count);
4417
4418 max_id_check = 0;
4419 for (i = 0; i < count; i++)
4420 {
4421 MENUITEMINFOA mii;
4422 INT res;
4423 char buf[255], buf2[255];
4424 ZeroMemory(&mii, sizeof(MENUITEMINFOA));
4425 mii.cbSize = sizeof(MENUITEMINFOA);
4427 mii.dwTypeData = buf2;
4428 mii.cch = sizeof(buf2);
4429
4430 res = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
4431 ok(res, "Failed to get menu item info, error %d.\n", GetLastError());
4432
4433 ok((mii.wID <= id_upper_limit) || (mii.fType & MFT_SEPARATOR),
4434 "Got non-separator ID out of range: %d (type: %x)\n", mii.wID, mii.fType);
4435 if (!(mii.fType & MFT_SEPARATOR))
4436 {
4437 max_id_check = (mii.wID > max_id_check) ? mii.wID : max_id_check;
4438 hr = IContextMenu_GetCommandString(menu, mii.wID - baseItem, GCS_VERBA, 0, buf, sizeof(buf));
4439 todo_wine_if(background)
4440 ok(SUCCEEDED(hr) || hr == E_NOTIMPL, "for id 0x%x got 0x%08x (menustr: %s)\n", mii.wID - baseItem, hr, mii.dwTypeData);
4441 if (SUCCEEDED(hr))
4442 trace("for id 0x%x got string %s (menu string: %s)\n", mii.wID - baseItem, buf, mii.dwTypeData);
4443 else if (hr == E_NOTIMPL)
4444 trace("for id 0x%x got E_NOTIMPL (menu string: %s)\n", mii.wID - baseItem, mii.dwTypeData);
4445 }
4446 }
4447 max_id_check -= baseItem;
4448 ok((max_id_check == max_id) ||
4449 (max_id_check == max_id-1) || /* Win 7 */
4450 (max_id_check == max_id-2) || /* Win 8 */
4451 (max_id_check == max_id-3),
4452 "Not equal (or near equal), got %d and %d\n", max_id_check, max_id);
4453
4454 if (count)
4455 {
4456 CMINVOKECOMMANDINFO cmi;
4457
4458 memset(&cmi, 0, sizeof(CMINVOKECOMMANDINFO));
4459 cmi.cbSize = sizeof(CMINVOKECOMMANDINFO);
4460
4461 /* Attempt to execute a nonexistent command */
4462 cmi.lpVerb = MAKEINTRESOURCEA(9999);
4463 hr = IContextMenu_InvokeCommand(menu, &cmi);
4464 todo_wine_if(background)
4465 ok(hr == E_INVALIDARG, "Got 0x%08x\n", hr);
4466
4467 cmi.lpVerb = "foobar_wine_test";
4468 hr = IContextMenu_InvokeCommand(menu, &cmi);
4469 todo_wine_if(background)
4470 ok((hr == E_INVALIDARG) || (hr == E_FAIL /* Win7 */) ||
4471 (hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) /* Vista */),
4472 "Unexpected hr %#x.\n", hr);
4473 }
4474
4476}
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint res
Definition: glext.h:9613
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define todo_wine_if(is_todo)
Definition: custom.c:76
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:63
static void test_contextmenu_qi(IContextMenu *menu, BOOL todo)
Definition: shlfolder.c:4381
LPSTR dwTypeData
Definition: winuser.h:3251
int32_t INT
Definition: typedefs.h:58
static HMENU hmenu
Definition: win.c:66
#define ERROR_NO_ASSOCIATION
Definition: winerror.h:677
#define HRESULT_CODE(hr)
Definition: winerror.h:76
HMENU WINAPI CreatePopupMenu(void)
Definition: menu.c:838
#define MIIM_STRING
Definition: winuser.h:727
#define MIIM_ID
Definition: winuser.h:722
int WINAPI GetMenuItemCount(_In_opt_ HMENU)
struct tagMENUITEMINFOA MENUITEMINFOA
#define MIIM_FTYPE
Definition: winuser.h:729
#define MFT_SEPARATOR
Definition: winuser.h:744
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
BOOL WINAPI DestroyMenu(_In_ HMENU)
BOOL WINAPI GetMenuItemInfoA(_In_ HMENU, _In_ UINT, _In_ BOOL, _Inout_ LPMENUITEMINFOA)

◆ test_contextmenu_qi()

static void test_contextmenu_qi ( IContextMenu menu,
BOOL  todo 
)
static

Definition at line 4381 of file shlfolder.c.

4382{
4383 IUnknown *unk;
4384 HRESULT hr;
4385
4386 hr = IContextMenu_QueryInterface(menu, &IID_IShellExtInit, (void **)&unk);
4388 ok(hr == S_OK, "Failed to get IShellExtInit, hr %#x.\n", hr);
4389if (hr == S_OK)
4390 IUnknown_Release(unk);
4391
4392 hr = IContextMenu_QueryInterface(menu, &IID_IObjectWithSite, (void **)&unk);
4394 ok(hr == S_OK, "Failed to get IShellExtInit, hr %#x.\n", hr);
4395if (hr == S_OK)
4396 IUnknown_Release(unk);
4397}
const IID IID_IObjectWithSite
int todo
Definition: shlfolder.c:184

Referenced by test_contextmenu(), and test_SHCreateDefaultContextMenu().

◆ test_DataObject()

static void test_DataObject ( void  )
static

Definition at line 5102 of file shlfolder.c.

5103{
5104 IShellFolder *desktop;
5105 IDataObject *data_obj;
5106 HRESULT hres;
5107 IEnumIDList *peidl;
5108 LPITEMIDLIST apidl;
5109 FORMATETC fmt;
5110 DWORD cf_shellidlist;
5111 STGMEDIUM medium;
5112
5113 SHGetDesktopFolder(&desktop);
5114
5115 hres = IShellFolder_EnumObjects(desktop, NULL,
5116 SHCONTF_NONFOLDERS|SHCONTF_FOLDERS|SHCONTF_INCLUDEHIDDEN, &peidl);
5117 ok(hres == S_OK, "got %x\n", hres);
5118
5119 if(IEnumIDList_Next(peidl, 1, &apidl, NULL) != S_OK) {
5120 skip("no files on desktop - skipping GetDataObject tests\n");
5121 IEnumIDList_Release(peidl);
5122 IShellFolder_Release(desktop);
5123 return;
5124 }
5125 IEnumIDList_Release(peidl);
5126
5127 hres = IShellFolder_GetUIObjectOf(desktop, NULL, 1, (LPCITEMIDLIST*)&apidl,
5128 &IID_IDataObject, NULL, (void**)&data_obj);
5129 ok(hres == S_OK, "got %x\n", hres);
5130 ILFree(apidl);
5131 IShellFolder_Release(desktop);
5132
5134 fmt.cfFormat = cf_shellidlist;
5135 fmt.ptd = NULL;
5136 fmt.dwAspect = DVASPECT_CONTENT;
5137 fmt.lindex = -1;
5138 fmt.tymed = TYMED_HGLOBAL;
5139 hres = IDataObject_QueryGetData(data_obj, &fmt);
5140 ok(hres == S_OK, "got %x\n", hres);
5141
5142 fmt.tymed = TYMED_HGLOBAL | TYMED_ISTREAM;
5143 hres = IDataObject_QueryGetData(data_obj, &fmt);
5144 ok(hres == S_OK, "got %x\n", hres);
5145
5146 fmt.tymed = TYMED_ISTREAM;
5147 hres = IDataObject_QueryGetData(data_obj, &fmt);
5148 todo_wine ok(hres == S_FALSE, "got %x\n", hres);
5149
5150 fmt.tymed = TYMED_HGLOBAL | TYMED_ISTREAM;
5151 hres = IDataObject_GetData(data_obj, &fmt, &medium);
5152 ok(hres == S_OK, "got %x\n", hres);
5153 ok(medium.tymed == TYMED_HGLOBAL, "medium.tymed = %x\n", medium.tymed);
5154 ReleaseStgMedium(&medium);
5155
5156 IDataObject_Release(data_obj);
5157}
void WINAPI ReleaseStgMedium(STGMEDIUM *pmedium)
Definition: ole2.c:2033
HRESULT hres
Definition: protocol.c:465
#define todo_wine
Definition: custom.c:79
const GUID IID_IDataObject
static const WCHAR CFSTR_SHELLIDLISTW[]
Definition: shlobj.h:499
Definition: dsound.c:943
#define S_FALSE
Definition: winerror.h:2357
UINT WINAPI RegisterClipboardFormatW(_In_ LPCWSTR)

Referenced by START_TEST().

◆ test_desktop_IPersist()

static void test_desktop_IPersist ( void  )
static

Definition at line 4325 of file shlfolder.c.

4326{
4327 IShellFolder *desktop;
4328 IPersist *persist;
4329 IPersistFolder2 *ppf2;
4330 CLSID clsid;
4331 HRESULT hr;
4332
4333 hr = SHGetDesktopFolder(&desktop);
4334 ok(hr == S_OK, "failed %08x\n", hr);
4335
4336 hr = IShellFolder_QueryInterface(desktop, &IID_IPersist, (void**)&persist);
4337 ok(hr == S_OK, "failed %08x\n", hr);
4338
4339 if (hr == S_OK)
4340 {
4341 if (0)
4342 {
4343 /* crashes on native */
4344 IPersist_GetClassID(persist, NULL);
4345 }
4346 memset(&clsid, 0, sizeof(clsid));
4347 hr = IPersist_GetClassID(persist, &clsid);
4348 ok(hr == S_OK, "failed %08x\n", hr);
4349 ok(IsEqualIID(&CLSID_ShellDesktop, &clsid), "Expected CLSID_ShellDesktop\n");
4350 IPersist_Release(persist);
4351 }
4352
4353 hr = IShellFolder_QueryInterface(desktop, &IID_IPersistFolder2, (void**)&ppf2);
4354 ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* pre-Vista */, "failed %08x\n", hr);
4355 if(SUCCEEDED(hr))
4356 {
4357 IPersistFolder *ppf;
4358 LPITEMIDLIST pidl;
4359 hr = IShellFolder_QueryInterface(desktop, &IID_IPersistFolder, (void**)&ppf);
4360 ok(hr == S_OK, "IID_IPersistFolder2 without IID_IPersistFolder.\n");
4361 if(SUCCEEDED(hr))
4362 IPersistFolder_Release(ppf);
4363
4364 todo_wine {
4365 hr = IPersistFolder2_Initialize(ppf2, NULL);
4366 ok(hr == S_OK, "got %08x\n", hr);
4367 }
4368
4369 pidl = NULL;
4370 hr = IPersistFolder2_GetCurFolder(ppf2, &pidl);
4371 ok(hr == S_OK, "got %08x\n", hr);
4372 ok(pidl != NULL, "pidl was NULL.\n");
4373 if(SUCCEEDED(hr)) ILFree(pidl);
4374
4375 IPersistFolder2_Release(ppf2);
4376 }
4377
4378 IShellFolder_Release(desktop);
4379}
REFCLSID clsid
Definition: msctf.c:82

Referenced by START_TEST().

◆ test_EnumObjects()

static void test_EnumObjects ( IShellFolder iFolder)
static

Definition at line 321 of file shlfolder.c.

322{
323 IEnumIDList *iEnumList;
324 LPITEMIDLIST newPIDL, idlArr[10];
325 ULONG NumPIDLs;
326 int i=0, j;
327 HRESULT hr;
328
329 static const WORD iResults [5][5] =
330 {
331 { 0,-1,-1,-1,-1},
332 { 1, 0,-1,-1,-1},
333 { 1, 1, 0,-1,-1},
334 { 1, 1, 1, 0,-1},
335 { 1, 1, 1, 1, 0}
336 };
337
338#define SFGAO_testfor SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_CAPABILITYMASK
339 /* Don't test for SFGAO_HASSUBFOLDER since we return real state and native cached */
340 static const ULONG attrs[5] =
341 {
342 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
343 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
344 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
345 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
346 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
347 };
348 static const ULONG full_attrs[5] =
349 {
350 SFGAO_CAPABILITYMASK | SFGAO_STORAGE | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
351 SFGAO_CAPABILITYMASK | SFGAO_STORAGE | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
352 SFGAO_CAPABILITYMASK | SFGAO_STREAM | SFGAO_FILESYSTEM,
353 SFGAO_CAPABILITYMASK | SFGAO_STREAM | SFGAO_FILESYSTEM,
354 SFGAO_CAPABILITYMASK | SFGAO_STREAM | SFGAO_FILESYSTEM,
355 };
356
357 hr = IShellFolder_EnumObjects(iFolder, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &iEnumList);
358 ok(hr == S_OK, "EnumObjects failed %08x\n", hr);
359
360 /* This is to show that, contrary to what is said on MSDN, on IEnumIDList::Next,
361 * the filesystem shellfolders return S_OK even if less than 'celt' items are
362 * returned (in contrast to S_FALSE). We have to do it in a loop since WinXP
363 * only ever returns a single entry per call. */
364 while (IEnumIDList_Next(iEnumList, 10-i, &idlArr[i], &NumPIDLs) == S_OK)
365 i += NumPIDLs;
366 ok (i == 5, "i: %d\n", i);
367
368 hr = IEnumIDList_Release(iEnumList);
369 ok(hr == S_OK, "IEnumIDList_Release failed %08x\n", hr);
370
371 /* Sort them first in case of wrong order from system */
372 for (i=0;i<5;i++) for (j=0;j<5;j++)
373 if ((SHORT)IShellFolder_CompareIDs(iFolder, 0, idlArr[i], idlArr[j]) < 0)
374 {
375 newPIDL = idlArr[i];
376 idlArr[i] = idlArr[j];
377 idlArr[j] = newPIDL;
378 }
379
380 for (i=0;i<5;i++) for (j=0;j<5;j++)
381 {
382 hr = IShellFolder_CompareIDs(iFolder, 0, idlArr[i], idlArr[j]);
383 ok(hr == iResults[i][j], "Got %x expected [%d]-[%d]=%x\n", hr, i, j, iResults[i][j]);
384 }
385
386
387 for (i = 0; i < 5; i++)
388 {
390#define SFGAO_VISTA SFGAO_DROPTARGET | SFGAO_CANLINK | SFGAO_CANCOPY
391 /* Native returns all flags no matter what we ask for */
392 flags = SFGAO_CANCOPY;
393 hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
395 ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
396 ok(flags == (attrs[i]) ||
397 flags == ((attrs[i] & ~SFGAO_CAPABILITYMASK) | SFGAO_VISTA), /* Vista and higher */
398 "GetAttributesOf[%i] got %08x, expected %08x\n", i, flags, attrs[i]);
399
401 hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
403 ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
404 ok(flags == attrs[i], "GetAttributesOf[%i] got %08x, expected %08x\n", i, flags, attrs[i]);
405
406 flags = ~0u;
407 hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
408 ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
409 ok((flags & ~(SFGAO_HASSUBFOLDER|SFGAO_COMPRESSED)) == full_attrs[i], "%d: got %08x expected %08x\n", i, flags, full_attrs[i]);
410 }
411
412 for (i=0;i<5;i++)
413 IMalloc_Free(ppM, idlArr[i]);
414}
#define IShellFolder_CompareIDs
Definition: utils.cpp:15
static IShellFolder IShellItem **static IBindCtx LPITEMIDLIST SFGAOF
Definition: ebrowser.c:83
unsigned short WORD
Definition: ntddk_ex.h:93
GLbitfield flags
Definition: glext.h:7161
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
short SHORT
Definition: pedump.c:59
#define SFGAO_testfor
#define SFGAO_VISTA
uint32_t ULONG
Definition: typedefs.h:59

Referenced by test_EnumObjects_and_CompareIDs().

◆ test_EnumObjects_and_CompareIDs()

static void test_EnumObjects_and_CompareIDs ( void  )
static

Definition at line 1211 of file shlfolder.c.

1212{
1213 ITEMIDLIST *newPIDL;
1214 IShellFolder *IDesktopFolder, *testIShellFolder;
1215 char cCurrDirA [MAX_PATH] = {0};
1216 static const CHAR cTestDirA[] = "\\testdir";
1217 WCHAR cTestDirW[MAX_PATH];
1218 int len;
1219 HRESULT hr;
1220
1221 GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1222 len = lstrlenA(cCurrDirA);
1223
1224 if(len == 0) {
1225 win_skip("GetCurrentDirectoryA returned empty string. Skipping test_EnumObjects_and_CompareIDs\n");
1226 return;
1227 }
1228 if(cCurrDirA[len-1] == '\\')
1229 cCurrDirA[len-1] = 0;
1230
1231 lstrcatA(cCurrDirA, cTestDirA);
1232 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cTestDirW, MAX_PATH);
1233
1234 hr = SHGetDesktopFolder(&IDesktopFolder);
1235 ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1236
1238
1239 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
1240 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1241
1242 hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1243 ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1244
1245 test_EnumObjects(testIShellFolder);
1246
1247 IShellFolder_Release(testIShellFolder);
1248
1249 Cleanup();
1250
1251 IMalloc_Free(ppM, newPIDL);
1252
1253 IShellFolder_Release(IDesktopFolder);
1254}
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
static void Cleanup(void)
Definition: shlfolder.c:308
static IBindCtx REFIID
Definition: shlfolder.c:50
static void CreateFilesFolders(void)
Definition: shlfolder.c:296
static void test_EnumObjects(IShellFolder *iFolder)
Definition: shlfolder.c:321

Referenced by START_TEST().

◆ test_FolderShortcut()

static void test_FolderShortcut ( void  )
static

Definition at line 1369 of file shlfolder.c.

1369 {
1370 IPersistPropertyBag *pPersistPropertyBag;
1371 IShellFolder *pShellFolder, *pDesktopFolder;
1372 IPersistFolder3 *pPersistFolder3;
1373 HRESULT hr;
1374 STRRET strret;
1375 WCHAR wszDesktopPath[MAX_PATH], wszBuffer[MAX_PATH];
1376 BOOL result;
1377 CLSID clsid;
1378 LPITEMIDLIST pidlCurrentFolder, pidlWineTestFolder, pidlSubFolder;
1379 HKEY hShellExtKey;
1380 WCHAR wszWineTestFolder[] = {
1381 ':',':','{','9','B','3','5','2','E','B','F','-','2','7','6','5','-','4','5','C','1','-',
1382 'B','4','C','6','-','8','5','C','C','7','F','7','A','B','C','6','4','}',0 };
1383 WCHAR wszShellExtKey[] = { 'S','o','f','t','w','a','r','e','\\',
1384 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
1385 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1386 'E','x','p','l','o','r','e','r','\\','D','e','s','k','t','o','p','\\',
1387 'N','a','m','e','S','p','a','c','e','\\',
1388 '{','9','b','3','5','2','e','b','f','-','2','7','6','5','-','4','5','c','1','-',
1389 'b','4','c','6','-','8','5','c','c','7','f','7','a','b','c','6','4','}',0 };
1390
1391 WCHAR wszSomeSubFolder[] = { 'S','u','b','F','o','l','d','e','r', 0};
1392 static const GUID CLSID_UnixDosFolder =
1393 {0x9d20aae8, 0x0625, 0x44b0, {0x9c, 0xa7, 0x71, 0x88, 0x9c, 0x22, 0x54, 0xd9}};
1394
1395 /* These tests basically show, that CLSID_FolderShortcuts are initialized
1396 * via their IPersistPropertyBag interface. And that the target folder
1397 * is taken from the IPropertyBag's 'Target' property.
1398 */
1399 hr = CoCreateInstance(&CLSID_FolderShortcut, NULL, CLSCTX_INPROC_SERVER,
1400 &IID_IPersistPropertyBag, (LPVOID*)&pPersistPropertyBag);
1401 if (hr == REGDB_E_CLASSNOTREG) {
1402 win_skip("CLSID_FolderShortcut is not implemented\n");
1403 return;
1404 }
1405 ok (hr == S_OK, "CoCreateInstance failed! hr = 0x%08x\n", hr);
1406 if (hr != S_OK) return;
1407
1408 hr = IPersistPropertyBag_Load(pPersistPropertyBag, &InitPropertyBag, NULL);
1409 ok(hr == S_OK, "IPersistPropertyBag_Load failed! hr = %08x\n", hr);
1410 if (hr != S_OK) {
1411 IPersistPropertyBag_Release(pPersistPropertyBag);
1412 return;
1413 }
1414
1415 hr = IPersistPropertyBag_QueryInterface(pPersistPropertyBag, &IID_IShellFolder,
1416 (LPVOID*)&pShellFolder);
1417 IPersistPropertyBag_Release(pPersistPropertyBag);
1418 ok(hr == S_OK, "IPersistPropertyBag_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
1419 if (hr != S_OK) return;
1420
1421 hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
1422 ok(hr == S_OK || broken(hr == E_INVALIDARG) /* win10 */,
1423 "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
1424 if (hr != S_OK) {
1425 IShellFolder_Release(pShellFolder);
1426 return;
1427 }
1428
1430 ok(result, "SHGetSpecialFolderPathW(CSIDL_DESKTOPDIRECTORY) failed! %u\n", GetLastError());
1431 if (!result) return;
1432
1433 StrRetToBufW(&strret, NULL, wszBuffer, MAX_PATH);
1434 ok(!lstrcmpiW(wszDesktopPath, wszBuffer), "FolderShortcut returned incorrect folder!\n");
1435
1436 hr = IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder3, (LPVOID*)&pPersistFolder3);
1437 IShellFolder_Release(pShellFolder);
1438 ok(hr == S_OK, "IShellFolder_QueryInterface(IID_IPersistFolder3 failed! hr = 0x%08x\n", hr);
1439 if (hr != S_OK) return;
1440
1441 hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
1442 ok(hr == S_OK, "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
1443 ok(IsEqualCLSID(&clsid, &CLSID_FolderShortcut), "Unexpected CLSID!\n");
1444
1445 hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
1446 todo_wine ok(hr == S_FALSE, "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
1447 ok(!pidlCurrentFolder, "IPersistFolder3_GetCurFolder should return a NULL pidl!\n");
1448
1449 /* For FolderShortcut objects, the Initialize method initialized the folder's position in the
1450 * shell namespace. The target folder, read from the property bag above, remains untouched.
1451 * The following tests show this: The itemidlist for some imaginary shellfolder object
1452 * is created and the FolderShortcut is initialized with it. GetCurFolder now returns this
1453 * itemidlist, but GetDisplayNameOf still returns the path from above.
1454 */
1455 hr = SHGetDesktopFolder(&pDesktopFolder);
1456 ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
1457 if (hr != S_OK) return;
1458
1459 /* Temporarily register WineTestFolder as a shell namespace extension at the Desktop.
1460 * Otherwise ParseDisplayName fails on WinXP with E_INVALIDARG */
1461 RegCreateKeyW(HKEY_CURRENT_USER, wszShellExtKey, &hShellExtKey);
1462 RegCloseKey(hShellExtKey);
1463 hr = IShellFolder_ParseDisplayName(pDesktopFolder, NULL, NULL, wszWineTestFolder, NULL,
1464 &pidlWineTestFolder, NULL);
1465 RegDeleteKeyW(HKEY_CURRENT_USER, wszShellExtKey);
1466 IShellFolder_Release(pDesktopFolder);
1467 ok (hr == S_OK, "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
1468 if (hr != S_OK) return;
1469
1470 hr = IPersistFolder3_Initialize(pPersistFolder3, pidlWineTestFolder);
1471 ok (hr == S_OK, "IPersistFolder3::Initialize failed! hr = %08x\n", hr);
1472 if (hr != S_OK) {
1473 IPersistFolder3_Release(pPersistFolder3);
1474 ILFree(pidlWineTestFolder);
1475 return;
1476 }
1477
1478 hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
1479 ok(hr == S_OK, "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
1480 ok(ILIsEqual(pidlCurrentFolder, pidlWineTestFolder),
1481 "IPersistFolder3_GetCurFolder should return pidlWineTestFolder!\n");
1482 ILFree(pidlCurrentFolder);
1483 ILFree(pidlWineTestFolder);
1484
1485 hr = IPersistFolder3_QueryInterface(pPersistFolder3, &IID_IShellFolder, (LPVOID*)&pShellFolder);
1486 IPersistFolder3_Release(pPersistFolder3);
1487 ok(hr == S_OK, "IPersistFolder3_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
1488 if (hr != S_OK) return;
1489
1490 hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
1491 ok(hr == S_OK, "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
1492 if (hr != S_OK) {
1493 IShellFolder_Release(pShellFolder);
1494 return;
1495 }
1496
1497 StrRetToBufW(&strret, NULL, wszBuffer, MAX_PATH);
1498 ok(!lstrcmpiW(wszDesktopPath, wszBuffer), "FolderShortcut returned incorrect folder!\n");
1499
1500 /* Next few lines are meant to show that children of FolderShortcuts are not FolderShortcuts,
1501 * but ShellFSFolders. */
1502 myPathAddBackslashW(wszDesktopPath);
1503 lstrcatW(wszDesktopPath, wszSomeSubFolder);
1504 if (!CreateDirectoryW(wszDesktopPath, NULL)) {
1505 IShellFolder_Release(pShellFolder);
1506 return;
1507 }
1508
1509 hr = IShellFolder_ParseDisplayName(pShellFolder, NULL, NULL, wszSomeSubFolder, NULL,
1510 &pidlSubFolder, NULL);
1511 RemoveDirectoryW(wszDesktopPath);
1512 ok (hr == S_OK, "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
1513 if (hr != S_OK) {
1514 IShellFolder_Release(pShellFolder);
1515 return;
1516 }
1517
1518 hr = IShellFolder_BindToObject(pShellFolder, pidlSubFolder, NULL, &IID_IPersistFolder3,
1519 (LPVOID*)&pPersistFolder3);
1520 IShellFolder_Release(pShellFolder);
1521 ILFree(pidlSubFolder);
1522 ok (hr == S_OK, "IShellFolder::BindToObject failed! hr = %08x\n", hr);
1523 if (hr != S_OK)
1524 return;
1525
1526 /* On windows, we expect CLSID_ShellFSFolder. On wine we relax this constraint
1527 * a little bit and also allow CLSID_UnixDosFolder. */
1528 hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
1529 ok(hr == S_OK, "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
1530 ok(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder) || IsEqualCLSID(&clsid, &CLSID_UnixDosFolder),
1531 "IPersistFolder3::GetClassID returned unexpected CLSID!\n");
1532
1533 IPersistFolder3_Release(pPersistFolder3);
1534}
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1239
LONG WINAPI RegCreateKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:1201
BOOL WINAPI CreateDirectoryW(IN LPCWSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:90
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4261
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
const GUID CLSID_UnixDosFolder
HRESULT WINAPI StrRetToBufW(LPSTRRET src, const ITEMIDLIST *pidl, LPWSTR dest, UINT len)
Definition: string.c:1530
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
const GUID IID_IPersistPropertyBag
Definition: proxy.cpp:11
#define IsEqualCLSID(rclsid1, rclsid2)
Definition: guiddef.h:96
static struct IPropertyBag InitPropertyBag
Definition: shlfolder.c:1365
static LPWSTR myPathAddBackslashW(LPWSTR lpszPath)
Definition: shlfolder.c:161
#define REGDB_E_CLASSNOTREG
Definition: winerror.h:2696
#define HKEY_CURRENT_USER
Definition: winreg.h:11

Referenced by START_TEST().

◆ test_GetAttributesOf()

static void test_GetAttributesOf ( void  )
static

Definition at line 928 of file shlfolder.c.

929{
930 HRESULT hr;
931 LPSHELLFOLDER psfDesktop, psfMyComputer;
932 SHITEMID emptyitem = { 0, { 0 } };
933 LPCITEMIDLIST pidlEmpty = (LPCITEMIDLIST)&emptyitem;
934 LPITEMIDLIST pidlMyComputer;
936 static const DWORD desktopFlags = SFGAO_STORAGE | SFGAO_HASPROPSHEET | SFGAO_STORAGEANCESTOR |
937 SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER;
938 static const DWORD myComputerFlags = SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET |
939 SFGAO_DROPTARGET | SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
940 WCHAR wszMyComputer[] = {
941 ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
942 'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
943 char cCurrDirA [MAX_PATH] = {0};
944 WCHAR cCurrDirW [MAX_PATH];
945 static WCHAR cTestDirW[] = {'t','e','s','t','d','i','r',0};
946 IShellFolder *IDesktopFolder, *testIShellFolder;
947 ITEMIDLIST *newPIDL;
948 int len;
949
950 hr = SHGetDesktopFolder(&psfDesktop);
951 ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
952 if (hr != S_OK) return;
953
954 /* The Desktop attributes can be queried with a single empty itemidlist, .. */
955 dwFlags = 0xffffffff;
956 hr = IShellFolder_GetAttributesOf(psfDesktop, 1, &pidlEmpty, &dwFlags);
957 ok (hr == S_OK, "Desktop->GetAttributesOf(empty pidl) failed! hr = %08x\n", hr);
958 ok (dwFlags == desktopFlags, "Wrong Desktop attributes: %08x\n", dwFlags);
959
960 /* .. or with no itemidlist at all. */
961 dwFlags = 0xffffffff;
962 hr = IShellFolder_GetAttributesOf(psfDesktop, 0, NULL, &dwFlags);
963 ok (hr == S_OK, "Desktop->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
964 ok (dwFlags == desktopFlags, "Wrong Desktop attributes: %08x\n", dwFlags);
965
966 /* Testing the attributes of the MyComputer shellfolder */
967 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
968 ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
969 if (hr != S_OK) {
970 IShellFolder_Release(psfDesktop);
971 return;
972 }
973
974 /* Windows sets the SFGAO_CANLINK flag, when MyComputer is queried via the Desktop
975 * folder object. It doesn't do this, if MyComputer is queried directly (see below).
976 */
977 dwFlags = 0xffffffff;
978 hr = IShellFolder_GetAttributesOf(psfDesktop, 1, (LPCITEMIDLIST*)&pidlMyComputer, &dwFlags);
979 ok (hr == S_OK, "Desktop->GetAttributesOf(MyComputer) failed! hr = %08x\n", hr);
981 ok (dwFlags == (myComputerFlags | SFGAO_CANLINK), "Wrong MyComputer attributes: %08x\n", dwFlags);
982
983 hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
984 ok (hr == S_OK, "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
985 IShellFolder_Release(psfDesktop);
986 IMalloc_Free(ppM, pidlMyComputer);
987 if (hr != S_OK) return;
988
989 hr = IShellFolder_GetAttributesOf(psfMyComputer, 1, &pidlEmpty, &dwFlags);
991 ok (hr == E_INVALIDARG, "MyComputer->GetAttributesOf(empty pidl) should fail! hr = %08x\n", hr);
992
993 dwFlags = 0xffffffff;
994 hr = IShellFolder_GetAttributesOf(psfMyComputer, 0, NULL, &dwFlags);
995 ok (hr == S_OK, "MyComputer->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
997 ok (dwFlags == myComputerFlags, "Wrong MyComputer attributes: %08x\n", dwFlags);
998
999 IShellFolder_Release(psfMyComputer);
1000
1001 GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1002 len = lstrlenA(cCurrDirA);
1003
1004 if (len == 0) {
1005 win_skip("GetCurrentDirectoryA returned empty string. Skipping test_GetAttributesOf\n");
1006 return;
1007 }
1008 if (len > 3 && cCurrDirA[len-1] == '\\')
1009 cCurrDirA[len-1] = 0;
1010
1011 /* create test directory */
1013
1014 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
1015
1016 hr = SHGetDesktopFolder(&IDesktopFolder);
1017 ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1018
1019 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
1020 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1021
1022 hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1023 ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1024
1025 IMalloc_Free(ppM, newPIDL);
1026
1027 /* get relative PIDL */
1028 hr = IShellFolder_ParseDisplayName(testIShellFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
1029 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1030
1031 /* test the shell attributes of the test directory using the relative PIDL */
1032 dwFlags = SFGAO_FOLDER;
1033 hr = IShellFolder_GetAttributesOf(testIShellFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
1034 ok (hr == S_OK, "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
1035 ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for relative PIDL: %08x\n", dwFlags);
1036
1037 /* free memory */
1038 IMalloc_Free(ppM, newPIDL);
1039
1040 /* append testdirectory name to path */
1041 if (cCurrDirA[len-1] == '\\')
1042 cCurrDirA[len-1] = 0;
1043 lstrcatA(cCurrDirA, "\\testdir");
1044 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
1045
1046 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
1047 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1048
1049 /* test the shell attributes of the test directory using the absolute PIDL */
1050 dwFlags = SFGAO_FOLDER;
1051 hr = IShellFolder_GetAttributesOf(IDesktopFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
1052 ok (hr == S_OK, "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
1053 ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for absolute PIDL: %08x\n", dwFlags);
1054
1055 /* free memory */
1056 IMalloc_Free(ppM, newPIDL);
1057
1058 IShellFolder_Release(testIShellFolder);
1059
1060 Cleanup();
1061
1062 IShellFolder_Release(IDesktopFolder);
1063}
static IBindCtx void **static IBindCtx void **static void **static IShellFolder LPCITEMIDLIST
Definition: shlfolder.c:53
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by START_TEST().

◆ test_GetDefaultColumn()

static void test_GetDefaultColumn ( void  )
static

Definition at line 5159 of file shlfolder.c.

5160{
5161 static const CLSID *folders[] =
5162 {
5163 &CLSID_MyComputer,
5164 &CLSID_MyDocuments,
5165 &CLSID_ControlPanel,
5166 &CLSID_NetworkPlaces,
5167 &CLSID_Printers,
5168 &CLSID_RecycleBin,
5169 &CLSID_ShellDesktop,
5170 };
5171 HRESULT hr;
5172 int i;
5173
5175
5176 for (i = 0; i < ARRAY_SIZE(folders); i++)
5177 {
5180
5181 hr = CoCreateInstance(folders[i], NULL, CLSCTX_INPROC_SERVER, &IID_IShellFolder2, (void **)&folder);
5182 if (hr != S_OK)
5183 {
5184 win_skip("Failed to create folder %s, hr %#x.\n", wine_dbgstr_guid(folders[i]), hr);
5185 continue;
5186 }
5187
5188 hr = IShellFolder2_GetDefaultColumn(folder, 0, NULL, NULL);
5189 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
5190
5191 sort = display = 123;
5192 hr = IShellFolder2_GetDefaultColumn(folder, 0, &sort, &display);
5193 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
5194 ok(sort == 123 && display == 123, "Unexpected default column.\n");
5195
5196 display = 123;
5197 hr = IShellFolder2_GetDefaultColumn(folder, 0, NULL, &display);
5198 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
5199 ok(display == 123, "Unexpected default column.\n");
5200
5201 sort = 123;
5202 hr = IShellFolder2_GetDefaultColumn(folder, 0, &sort, NULL);
5203 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
5204 ok(sort == 123, "Unexpected default column.\n");
5205
5206 IShellFolder2_Release(folder);
5207 }
5208
5210}
_STLP_MOVE_TO_STD_NAMESPACE void sort(_RandomAccessIter __first, _RandomAccessIter __last)
Definition: _algo.c:993
#define ARRAY_SIZE(A)
Definition: main.h:33
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
Definition: fci.c:116
int * display
Definition: x11stubs.c:12

Referenced by START_TEST().

◆ test_GetDefaultSearchGUID()

static void test_GetDefaultSearchGUID ( void  )
static

Definition at line 5212 of file shlfolder.c.

5213{
5214 static const CLSID *folders[] =
5215 {
5216 &CLSID_MyComputer,
5217 &CLSID_MyDocuments,
5218 &CLSID_ControlPanel,
5219 &CLSID_NetworkPlaces,
5220 &CLSID_Printers,
5221 &CLSID_RecycleBin,
5222 &CLSID_ShellDesktop,
5223 };
5224 HRESULT hr;
5225 int i;
5226
5228
5229 for (i = 0; i < ARRAY_SIZE(folders); i++)
5230 {
5232 GUID guid;
5233
5234 hr = CoCreateInstance(folders[i], NULL, CLSCTX_INPROC_SERVER, &IID_IShellFolder2, (void **)&folder);
5235 if (hr != S_OK)
5236 {
5237 win_skip("Failed to create folder %s, hr %#x.\n", wine_dbgstr_guid(folders[i]), hr);
5238 continue;
5239 }
5240
5241 if (0)
5242 {
5243 /* crashes on XP */
5244 hr = IShellFolder2_GetDefaultSearchGUID(folder, NULL);
5245 ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr);
5246 }
5247
5248 memcpy(&guid, &CLSID_MyComputer, sizeof(guid));
5249 hr = IShellFolder2_GetDefaultSearchGUID(folder, &guid);
5250 ok(hr == E_NOTIMPL || broken(hr == S_OK) /* Method was last supported on XP */, "Unexpected hr %#x.\n", hr);
5251 if (hr == E_NOTIMPL)
5252 ok(IsEqualGUID(&guid, &CLSID_MyComputer), "Unexpected guid %s.\n", wine_dbgstr_guid(&guid));
5253
5254 IShellFolder2_Release(folder);
5255 }
5256
5258}
const GUID * guid
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147

Referenced by START_TEST().

◆ test_GetDisplayName()

static void test_GetDisplayName ( void  )
static

Definition at line 639 of file shlfolder.c.

640{
641 BOOL result;
642 HRESULT hr;
643 HANDLE hTestFile;
644 WCHAR wszTestFile[MAX_PATH], wszTestFile2[MAX_PATH];
645 char szTestFile[MAX_PATH], szTestDir[MAX_PATH];
646 DWORD attr;
647 STRRET strret;
648 LPSHELLFOLDER psfDesktop, psfPersonal;
649 IUnknown *psfFile;
650 SHITEMID emptyitem = { 0, { 0 } };
651 LPITEMIDLIST pidlTestFile, pidlEmpty = (LPITEMIDLIST)&emptyitem;
652 LPCITEMIDLIST pidlLast;
653 static const CHAR szFileName[] = "winetest.foo";
654 static const WCHAR wszFileName[] = { 'w','i','n','e','t','e','s','t','.','f','o','o',0 };
655 static const WCHAR wszDirName[] = { 'w','i','n','e','t','e','s','t',0 };
656
657 /* It's ok to use this fixed path. Call will fail anyway. */
658 WCHAR wszAbsoluteFilename[] = { 'C',':','\\','w','i','n','e','t','e','s','t', 0 };
659 LPITEMIDLIST pidlNew;
660
661 /* I'm trying to figure if there is a functional difference between calling
662 * SHGetPathFromIDListW and calling GetDisplayNameOf(SHGDN_FORPARSING) after
663 * binding to the shellfolder. One thing I thought of was that perhaps
664 * SHGetPathFromIDListW would be able to get the path to a file, which does
665 * not exist anymore, while the other method wouldn't. It turns out there's
666 * no functional difference in this respect.
667 */
668
669 /* First creating a directory in MyDocuments and a file in this directory. */
671 ok(result, "SHGetSpecialFolderPathA failed! Last error: %u\n", GetLastError());
672 if (!result) return;
673
674 /* Use ANSI file functions so this works on Windows 9x */
675 lstrcatA(szTestDir, "\\winetest");
676 CreateDirectoryA(szTestDir, NULL);
677 attr=GetFileAttributesA(szTestDir);
679 {
680 ok(0, "unable to create the '%s' directory\n", szTestDir);
681 return;
682 }
683
684 lstrcpyA(szTestFile, szTestDir);
685 lstrcatA(szTestFile, "\\");
686 lstrcatA(szTestFile, szFileName);
687 hTestFile = CreateFileA(szTestFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
688 ok((hTestFile != INVALID_HANDLE_VALUE), "CreateFileA failed! Last error: %u\n", GetLastError());
689 if (hTestFile == INVALID_HANDLE_VALUE) return;
690 CloseHandle(hTestFile);
691
692 /* Getting an itemidlist for the file. */
693 hr = SHGetDesktopFolder(&psfDesktop);
694 ok(hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
695 if (hr != S_OK) return;
696
697 MultiByteToWideChar(CP_ACP, 0, szTestFile, -1, wszTestFile, MAX_PATH);
698
699 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
700 ok(hr == S_OK, "Desktop->ParseDisplayName failed! hr = %08x\n", hr);
701 if (hr != S_OK) {
702 IShellFolder_Release(psfDesktop);
703 return;
704 }
705
706 pidlLast = ILFindLastID(pidlTestFile);
707 ok(pidlLast->mkid.cb >= 76, "Expected pidl length of at least 76, got %d.\n", pidlLast->mkid.cb);
708 if (pidlLast->mkid.cb >= 28) {
709 ok(!lstrcmpA((CHAR*)&pidlLast->mkid.abID[12], szFileName),
710 "Filename should be stored as ansi-string at this position!\n");
711 }
712 /* WinXP and up store the filenames as both ANSI and UNICODE in the pidls */
713 if (pidlLast->mkid.cb >= 76) {
714 ok(!lstrcmpW((WCHAR*)&pidlLast->mkid.abID[46], wszFileName) ||
715 (pidlLast->mkid.cb >= 94 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[64], wszFileName)) || /* Vista */
716 (pidlLast->mkid.cb >= 98 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[68], wszFileName)) || /* Win7 */
717 (pidlLast->mkid.cb >= 102 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[72], wszFileName)), /* Win8 */
718 "Filename should be stored as wchar-string at this position!\n");
719 }
720
721 /* It seems as if we cannot bind to regular files on windows, but only directories.
722 */
723 hr = IShellFolder_BindToObject(psfDesktop, pidlTestFile, NULL, &IID_IUnknown, (VOID**)&psfFile);
725 hr == E_NOTIMPL, /* Vista */
726 "hr = %08x\n", hr);
727 if (hr == S_OK) {
728 IUnknown_Release(psfFile);
729 }
730
731 /* Some tests for IShellFolder::SetNameOf */
732 hr = SHBindToParent(pidlTestFile, &IID_IShellFolder, (void **)&psfPersonal, &pidlLast);
733 ok(hr == S_OK, "SHBindToParent failed! hr = %08x\n", hr);
734
735 /* The pidl returned through the last parameter of SetNameOf is a simple one. */
736 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlLast, wszDirName, SHGDN_NORMAL, &pidlNew);
737 ok (hr == S_OK, "SetNameOf failed! hr = %08x\n", hr);
738
739 ok (((ITEMIDLIST *)((BYTE *)pidlNew + pidlNew->mkid.cb))->mkid.cb == 0,
740 "pidl returned from SetNameOf should be simple!\n");
741
742 /* Passing an absolute path to SetNameOf fails. The HRESULT code indicates that SetNameOf
743 * is implemented on top of SHFileOperation in WinXP. */
744 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszAbsoluteFilename, SHGDN_FORPARSING, NULL);
745 ok (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED), "SetNameOf succeeded! hr = %08x\n", hr);
746
747 /* Rename the file back to its original name. SetNameOf ignores the fact, that the
748 * SHGDN flags specify an absolute path. */
749 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszFileName, SHGDN_FORPARSING, NULL);
750 ok (hr == S_OK, "SetNameOf failed! hr = %08x\n", hr);
751
752 ILFree(pidlNew);
753 IShellFolder_Release(psfPersonal);
754
755 /* Deleting the file and the directory */
756 DeleteFileA(szTestFile);
757 RemoveDirectoryA(szTestDir);
758
759 /* SHGetPathFromIDListW still works, although the file is not present anymore. */
760 result = SHGetPathFromIDListW(pidlTestFile, wszTestFile2);
761 ok (result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
762 ok (!lstrcmpiW(wszTestFile, wszTestFile2), "SHGetPathFromIDListW returns incorrect path!\n");
763
764 /* SHBindToParent fails, if called with a NULL PIDL. */
765 hr = SHBindToParent(NULL, &IID_IShellFolder, (void **)&psfPersonal, &pidlLast);
766 ok (hr == E_INVALIDARG || broken(hr == E_OUTOFMEMORY) /* XP */,
767 "SHBindToParent(NULL) should fail! hr = %08x\n", hr);
768
769 /* But it succeeds with an empty PIDL. */
770 hr = SHBindToParent(pidlEmpty, &IID_IShellFolder, (void **)&psfPersonal, &pidlLast);
771 ok (hr == S_OK, "SHBindToParent(empty PIDL) should succeed! hr = %08x\n", hr);
772 ok (pidlLast == pidlEmpty, "The last element of an empty PIDL should be the PIDL itself!\n");
773 if (hr == S_OK)
774 IShellFolder_Release(psfPersonal);
775
776 /* Binding to the folder and querying the display name of the file also works. */
777 hr = SHBindToParent(pidlTestFile, &IID_IShellFolder, (void **)&psfPersonal, &pidlLast);
778 ok (hr == S_OK, "SHBindToParent failed! hr = %08x\n", hr);
779 if (hr != S_OK) {
780 IShellFolder_Release(psfDesktop);
781 return;
782 }
783
784 /* This test shows that Windows doesn't allocate a new pidlLast, but returns a pointer into
785 * pidlTestFile (In accordance with MSDN). */
786 ok (ILFindLastID(pidlTestFile) == pidlLast,
787 "SHBindToParent doesn't return the last id of the pidl param!\n");
788
789 hr = IShellFolder_GetDisplayNameOf(psfPersonal, pidlLast, SHGDN_FORPARSING, &strret);
790 ok (hr == S_OK, "Personal->GetDisplayNameOf failed! hr = %08x\n", hr);
791 if (hr != S_OK) {
792 IShellFolder_Release(psfDesktop);
793 IShellFolder_Release(psfPersonal);
794 return;
795 }
796
797 hr = StrRetToBufW(&strret, pidlLast, wszTestFile2, MAX_PATH);
798 ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
799 ok (!lstrcmpiW(wszTestFile, wszTestFile2), "GetDisplayNameOf returns incorrect path!\n");
800
801 ILFree(pidlTestFile);
802 IShellFolder_Release(psfDesktop);
803 IShellFolder_Release(psfPersonal);
804}
static WCHAR wszFileName[MAX_PATH]
Definition: wordpad.c:71
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:636
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1342
#define CSIDL_PERSONAL
Definition: shlobj.h:2164
Definition: cookie.c:202
#define ERROR_CANCELLED
Definition: winerror.h:726
unsigned char BYTE
Definition: xxhash.c:193

Referenced by START_TEST().

◆ test_GetUIObject()

static void test_GetUIObject ( void  )
static

Definition at line 4478 of file shlfolder.c.

4479{
4480 IShellFolder *psf_desktop;
4481 IContextMenu *pcm;
4482 LPITEMIDLIST pidl;
4483 HRESULT hr;
4485 const WCHAR filename[] =
4486 {'\\','t','e','s','t','d','i','r','\\','t','e','s','t','1','.','t','x','t',0};
4487 LPCITEMIDLIST pidl_child;
4488 IShellFolder *psf;
4489
4491 if (!path[0])
4492 {
4493 skip("GetCurrentDirectoryW returned an empty string.\n");
4494 return;
4495 }
4497 SHGetDesktopFolder(&psf_desktop);
4498
4500
4501 hr = IShellFolder_ParseDisplayName(psf_desktop, NULL, NULL, path, NULL, &pidl, 0);
4502 ok(hr == S_OK, "Got 0x%08x\n", hr);
4503
4504 hr = SHBindToParent(pidl, &IID_IShellFolder, (void **)&psf, &pidl_child);
4505 ok(hr == S_OK, "Failed to bind to folder, hr %#x.\n", hr);
4506
4507 /* Item menu */
4508 hr = IShellFolder_GetUIObjectOf(psf, NULL, 1, &pidl_child, &IID_IContextMenu, NULL, (void **)&pcm);
4509 ok(hr == S_OK, "GetUIObjectOf() failed, hr %#x.\n", hr);
4510 test_contextmenu(pcm, FALSE);
4511 IContextMenu_Release(pcm);
4512
4513 /* Background menu */
4514 hr = IShellFolder_GetUIObjectOf(psf_desktop, NULL, 0, NULL, &IID_IContextMenu, NULL, (void **)&pcm);
4515 ok(hr == S_OK, "GetUIObjectOf() failed, hr %#x.\n", hr);
4516 test_contextmenu(pcm, TRUE);
4517 IContextMenu_Release(pcm);
4518
4519 IShellFolder_Release(psf);
4520 ILFree(pidl);
4521
4522 IShellFolder_Release(psf_desktop);
4523 Cleanup();
4524}
#define GetCurrentDirectoryW(x, y)
Definition: compat.h:756
static void test_contextmenu(void)
Definition: edit.c:2566

Referenced by START_TEST().

◆ test_ITEMIDLIST_format()

static void test_ITEMIDLIST_format ( void  )
static

Definition at line 1562 of file shlfolder.c.

1562 {
1563 WCHAR wszPersonal[MAX_PATH];
1564 LPSHELLFOLDER psfDesktop, psfPersonal;
1565 LPITEMIDLIST pidlPersonal, pidlFile;
1566 HANDLE hFile;
1567 HRESULT hr;
1568 BOOL bResult;
1569 WCHAR wszFile[3][17] = { { 'e','v','e','n','_',0 }, { 'o','d','d','_',0 },
1570 { 'l','o','n','g','e','r','_','t','h','a','n','.','8','_','3',0 } };
1571 int i;
1572
1573 bResult = SHGetSpecialFolderPathW(NULL, wszPersonal, CSIDL_PERSONAL, FALSE);
1574 ok(bResult, "SHGetSpecialFolderPathW failed! Last error: %u\n", GetLastError());
1575 if (!bResult) return;
1576
1577 SetLastError(0xdeadbeef);
1578 bResult = SetCurrentDirectoryW(wszPersonal);
1579 if (!bResult && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
1580 win_skip("Most W-calls are not implemented\n");
1581 return;
1582 }
1583 ok(bResult, "SetCurrentDirectory failed! Last error: %u\n", GetLastError());
1584 if (!bResult) return;
1585
1586 hr = SHGetDesktopFolder(&psfDesktop);
1587 ok(hr == S_OK, "SHGetDesktopFolder failed! hr: %08x\n", hr);
1588 if (hr != S_OK) return;
1589
1590 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszPersonal, NULL, &pidlPersonal, NULL);
1591 ok(hr == S_OK, "psfDesktop->ParseDisplayName failed! hr = %08x\n", hr);
1592 if (hr != S_OK) {
1593 IShellFolder_Release(psfDesktop);
1594 return;
1595 }
1596
1597 hr = IShellFolder_BindToObject(psfDesktop, pidlPersonal, NULL, &IID_IShellFolder,
1598 (LPVOID*)&psfPersonal);
1599 IShellFolder_Release(psfDesktop);
1600 ILFree(pidlPersonal);
1601 ok(hr == S_OK, "psfDesktop->BindToObject failed! hr = %08x\n", hr);
1602 if (hr != S_OK) return;
1603
1604 for (i=0; i<3; i++) {
1605 CHAR szFile[MAX_PATH];
1606 struct FileStructA *pFileStructA;
1607 WORD cbOffset;
1608
1609 WideCharToMultiByte(CP_ACP, 0, wszFile[i], -1, szFile, MAX_PATH, NULL, NULL);
1610
1612 ok(hFile != INVALID_HANDLE_VALUE, "CreateFile failed! (%u)\n", GetLastError());
1613 if (hFile == INVALID_HANDLE_VALUE) {
1614 IShellFolder_Release(psfPersonal);
1615 return;
1616 }
1618
1619 hr = IShellFolder_ParseDisplayName(psfPersonal, NULL, NULL, wszFile[i], NULL, &pidlFile, NULL);
1621 ok(hr == S_OK, "psfPersonal->ParseDisplayName failed! hr: %08x\n", hr);
1622 if (hr != S_OK) {
1623 IShellFolder_Release(psfPersonal);
1624 return;
1625 }
1626
1627 pFileStructA = (struct FileStructA *)pidlFile->mkid.abID;
1628 ok(pFileStructA->type == 0x32, "PIDLTYPE should be 0x32!\n");
1629 ok(pFileStructA->dummy == 0x00, "Dummy Byte should be 0x00!\n");
1630 ok(pFileStructA->dwFileSize == 0, "Filesize should be zero!\n");
1631
1632 if (i < 2) /* First two file names are already in valid 8.3 format */
1633 ok(!strcmp(szFile, (CHAR*)&pidlFile->mkid.abID[12]), "Wrong file name!\n");
1634 else
1635 /* WinXP stores a derived 8.3 dos name (LONGER~1.8_3) here. We probably
1636 * can't implement this correctly, since unix filesystems don't support
1637 * this nasty short/long filename stuff. So we'll probably stay with our
1638 * current habit of storing the long filename here, which seems to work
1639 * just fine. */
1640 todo_wine
1641 ok(pidlFile->mkid.abID[18] == '~', "Should be derived 8.3 name!\n");
1642
1643 if (i == 0) /* First file name has an even number of chars. No need for alignment. */
1644 ok(pidlFile->mkid.abID[12 + strlen(szFile) + 1] != '\0',
1645 "Alignment byte, where there shouldn't be!\n");
1646
1647 if (i == 1) /* Second file name has an uneven number of chars => alignment byte */
1648 ok(pidlFile->mkid.abID[12 + strlen(szFile) + 1] == '\0',
1649 "There should be an alignment byte, but isn't!\n");
1650
1651 /* The offset of the FileStructW member is stored as a WORD at the end of the pidl. */
1652 cbOffset = *(WORD*)(((LPBYTE)pidlFile)+pidlFile->mkid.cb-sizeof(WORD));
1653 ok ((cbOffset >= sizeof(struct FileStructA) &&
1654 cbOffset <= pidlFile->mkid.cb - sizeof(struct FileStructW)),
1655 "Wrong offset value (%d) stored at the end of the PIDL\n", cbOffset);
1656
1657 if (cbOffset >= sizeof(struct FileStructA) &&
1658 cbOffset <= pidlFile->mkid.cb - sizeof(struct FileStructW))
1659 {
1660 struct FileStructW *pFileStructW = (struct FileStructW *)(((LPBYTE)pidlFile)+cbOffset);
1661 WCHAR *name = pFileStructW->wszName;
1662
1663 ok(pidlFile->mkid.cb == cbOffset + pFileStructW->cbLen,
1664 "FileStructW's offset and length should add up to the PIDL's length!\n");
1665
1666 if (pidlFile->mkid.cb == cbOffset + pFileStructW->cbLen) {
1667 /* Since we just created the file, time of creation,
1668 * time of last access and time of last write access just be the same.
1669 * These tests seem to fail sometimes (on WinXP), if the test is run again shortly
1670 * after the first run. I do remember something with NTFS keeping the creation time
1671 * if a file is deleted and then created again within a couple of seconds or so.
1672 * Might be the reason. */
1673 ok (pFileStructA->uFileDate == pFileStructW->uDate &&
1674 pFileStructA->uFileTime == pFileStructW->uTime,
1675 "Last write time should match creation time!\n");
1676
1677 /* On FAT filesystems the last access time is midnight
1678 local time, so the values of uDate2 and uTime2 will
1679 depend on the local timezone. If the times are exactly
1680 equal then the dates should be identical for both FAT
1681 and NTFS as no timezone is more than 1 day away from UTC.
1682 */
1683 if (pFileStructA->uFileTime == pFileStructW->uTime2)
1684 {
1685 ok (pFileStructA->uFileDate == pFileStructW->uDate2,
1686 "Last write date and time should match last access date and time!\n");
1687 }
1688 else
1689 {
1690 /* Filesystem may be FAT. Check date within 1 day
1691 and seconds are zero. */
1692 trace ("Filesystem may be FAT. Performing less strict atime test.\n");
1693 ok ((pFileStructW->uTime2 & 0x1F) == 0,
1694 "Last access time on FAT filesystems should have zero seconds.\n");
1695 /* TODO: Perform check for date being within one day.*/
1696 }
1697
1698 ok (!lstrcmpW(wszFile[i], name) ||
1699 !lstrcmpW(wszFile[i], name + 9) || /* Vista */
1700 !lstrcmpW(wszFile[i], name + 11) || /* Win7 */
1701 !lstrcmpW(wszFile[i], name + 13), /* Win8 */
1702 "The filename should be stored in unicode at this position!\n");
1703 }
1704 }
1705
1706 ILFree(pidlFile);
1707 }
1708
1709 IShellFolder_Release(psfPersonal);
1710}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define CreateFileW
Definition: compat.h:741
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
BOOL WINAPI SetCurrentDirectoryW(IN LPCWSTR lpPathName)
Definition: path.c:2249
#define CREATE_NEW
Definition: disk.h:69
#define FILE_FLAG_WRITE_THROUGH
Definition: disk.h:47
_In_ HANDLE hFile
Definition: mswsock.h:90
DWORD dwFileSize
Definition: shlfolder.c:1540
WORD uFileDate
Definition: shlfolder.c:1541
WORD uFileTime
Definition: shlfolder.c:1542
WORD cbOffset
Definition: shlfolder.c:1557
WCHAR wszName[1]
Definition: shlfolder.c:1555
static const WCHAR wszFile[]
Definition: urlmon_main.c:386

Referenced by START_TEST().

◆ test_LocalizedNames()

static void test_LocalizedNames ( void  )
static

Definition at line 1896 of file shlfolder.c.

1897{
1898 static char cCurrDirA[MAX_PATH];
1899 WCHAR cCurrDirW[MAX_PATH], tempbufW[25];
1900 IShellFolder *IDesktopFolder, *testIShellFolder;
1901 ITEMIDLIST *newPIDL;
1902 int len;
1903 HRESULT hr;
1904 static char resourcefile[MAX_PATH];
1905 DWORD res;
1906 HANDLE file;
1907 STRRET strret;
1908 BOOL ret;
1909
1910 static const char desktopini_contents1[] =
1911 "[.ShellClassInfo]\r\n"
1912 "LocalizedResourceName=@";
1913 static const char desktopini_contents2[] =
1914 ",-1\r\n";
1915 static WCHAR foldernameW[] = {'t','e','s','t','f','o','l','d','e','r',0};
1916 static const WCHAR folderdisplayW[] = {'F','o','l','d','e','r',' ','N','a','m','e',' ','R','e','s','o','u','r','c','e',0};
1917
1918 /* create folder with desktop.ini and localized name in GetModuleFileNameA(NULL) */
1919 CreateDirectoryA(".\\testfolder", NULL);
1920
1921 SetFileAttributesA(".\\testfolder", GetFileAttributesA(".\\testfolder")|FILE_ATTRIBUTE_SYSTEM);
1922
1923 GetModuleFileNameA(NULL, resourcefile, MAX_PATH);
1924
1925 file = CreateFileA(".\\testfolder\\desktop.ini", GENERIC_WRITE, 0, NULL,
1927 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %i\n", GetLastError());
1928 ret = WriteFile(file, desktopini_contents1, strlen(desktopini_contents1), &res, NULL) &&
1929 WriteFile(file, resourcefile, strlen(resourcefile), &res, NULL) &&
1930 WriteFile(file, desktopini_contents2, strlen(desktopini_contents2), &res, NULL);
1931 ok(ret, "WriteFile failed %i\n", GetLastError());
1933
1934 /* get IShellFolder for parent */
1935 GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1936 len = lstrlenA(cCurrDirA);
1937
1938 if (len == 0) {
1939 win_skip("GetCurrentDirectoryA returned empty string. Skipping test_LocalizedNames\n");
1940 goto cleanup;
1941 }
1942 if(cCurrDirA[len-1] == '\\')
1943 cCurrDirA[len-1] = 0;
1944
1945 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
1946
1947 hr = SHGetDesktopFolder(&IDesktopFolder);
1948 ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1949
1950 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
1951 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1952
1953 hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1954 ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1955
1956 IMalloc_Free(ppM, newPIDL);
1957
1958 /* windows reads the display name from the resource */
1959 hr = IShellFolder_ParseDisplayName(testIShellFolder, NULL, NULL, foldernameW, NULL, &newPIDL, 0);
1960 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1961
1962 hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER, &strret);
1963 ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1964
1965 hr = StrRetToBufW(&strret, newPIDL, tempbufW, ARRAY_SIZE(tempbufW));
1966 ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
1967 todo_wine
1968 ok (!lstrcmpiW(tempbufW, folderdisplayW), "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1969
1970 /* editing name is also read from the resource */
1971 hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FOREDITING, &strret);
1972 ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1973
1974 hr = StrRetToBufW(&strret, newPIDL, tempbufW, ARRAY_SIZE(tempbufW));
1975 ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
1976 todo_wine
1977 ok (!lstrcmpiW(tempbufW, folderdisplayW), "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1978
1979 /* parsing name is unchanged */
1980 hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FORPARSING, &strret);
1981 ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1982
1983 hr = StrRetToBufW(&strret, newPIDL, tempbufW, ARRAY_SIZE(tempbufW));
1984 ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
1985 ok (!lstrcmpiW(tempbufW, foldernameW), "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1986
1987 IShellFolder_Release(IDesktopFolder);
1988 IShellFolder_Release(testIShellFolder);
1989
1990 IMalloc_Free(ppM, newPIDL);
1991
1992cleanup:
1993 DeleteFileA(".\\testfolder\\desktop.ini");
1994 SetFileAttributesA(".\\testfolder", GetFileAttributesA(".\\testfolder")&~FILE_ATTRIBUTE_SYSTEM);
1995 RemoveDirectoryA(".\\testfolder");
1996}
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
static void cleanup(void)
Definition: main.c:1335
BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:776
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
Definition: loader.c:539
#define FILE_ATTRIBUTE_SYSTEM
Definition: nt_native.h:704

Referenced by START_TEST().

◆ test_ParseDisplayName()

static void test_ParseDisplayName ( void  )
static

Definition at line 207 of file shlfolder.c.

208{
209 static WCHAR testdirW[] = {'p','a','r','s','e','t','e','s','t',0};
210 static WCHAR backslashW[] = {'\\',0};
211 WCHAR buffer[MAX_PATH], buffer2[MAX_PATH];
212 IShellFolder *desktop;
213 ITEMIDLIST *pidl;
214 HRESULT hr;
215 BOOL bRes;
216 int i;
217
218 hr = SHGetDesktopFolder(&desktop);
219 ok(hr == S_OK, "Expected SHGetDesktopFolder to return S_OK, got 0x%08x\n", hr);
220
221 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, NULL, NULL, &pidl, NULL);
222 ok(hr == E_INVALIDARG, "got %#x\n", hr);
223
224 for (i = 0; i < ARRAY_SIZE(parse_tests); i++)
225 {
228 ok(hr == parse_tests[i].hr, "%s: expected %#x, got %#x\n",
230 if (SUCCEEDED(hr))
231 CoTaskMemFree(pidl);
232 }
233
234 /* I thought that perhaps the DesktopFolder's ParseDisplayName would recognize the
235 * path corresponding to CSIDL_PERSONAL and return a CLSID_MyDocuments PIDL. Turns
236 * out it doesn't. The magic seems to happen in the file dialogs, then. */
237
239 ok(bRes, "SHGetSpecialFolderPath(CSIDL_PERSONAL) failed! %u\n", GetLastError());
240
241 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, buffer, NULL, &pidl, 0);
242 ok(hr == S_OK, "DesktopFolder->ParseDisplayName failed. hr = %08x.\n", hr);
243
244 ok(ILFindLastID(pidl)->mkid.abID[0] == 0x31,
245 "Last pidl should be of type PT_FOLDER, but is: %02x\n",
246 ILFindLastID(pidl)->mkid.abID[0]);
247 CoTaskMemFree(pidl);
248
249 /* Relative paths are interpreted relative to the desktop. */
253 CreateDirectoryW(testdirW, NULL);
254
255 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, testdirW, NULL, &pidl, NULL);
256 ok(hr == 0x80070002, "got %#x\n", hr);
257
258 RemoveDirectoryW(testdirW);
259
261 ok(hr == S_FALSE, "got %#x\n", hr);
263 CreateDirectoryW(testdirW, NULL);
264
265 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, testdirW, NULL, &pidl, NULL);
266 ok(hr == S_OK, "got %#x\n", hr);
267
268 ok(SHGetPathFromIDListW(pidl, buffer2), "SHGetPathFromIDList failed\n");
270 lstrcatW(buffer, testdirW);
271 ok(!lstrcmpW(buffer, buffer2), "expected %s, got %s\n", wine_dbgstr_w(buffer), wine_dbgstr_w(buffer2));
272
273 RemoveDirectoryW(testdirW);
274 CoTaskMemFree(pidl);
275
276 IShellFolder_Release(desktop);
277}
static const WCHAR backslashW[]
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
DWORD WINAPI GetLongPathNameW(IN LPCWSTR lpszShortPath, OUT LPWSTR lpszLongPath, IN DWORD cchBuffer)
Definition: path.c:1456
GLuint buffer
Definition: glext.h:5915
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
static struct @1705 parse_tests[]

Referenced by START_TEST().

◆ test_ParseDisplayNamePBC()

static void test_ParseDisplayNamePBC ( void  )
static

Definition at line 4676 of file shlfolder.c.

4677{
4678 WCHAR wFileSystemBindData[] =
4679 {'F','i','l','e',' ','S','y','s','t','e','m',' ','B','i','n','d',' ','D','a','t','a',0};
4680 WCHAR adirW[] = {'C',':','\\','f','s','b','d','d','i','r',0};
4681 WCHAR afileW[] = {'C',':','\\','f','s','b','d','d','i','r','\\','f','i','l','e','.','t','x','t',0};
4682 WCHAR afile2W[] = {'C',':','\\','f','s','b','d','d','i','r','\\','s','\\','f','i','l','e','.','t','x','t',0};
4684
4685 IShellFolder *psf;
4686 IBindCtx *pbc;
4687 HRESULT hres;
4688 ITEMIDLIST *pidl;
4689
4690 /* Check if we support WCHAR functions */
4691 SetLastError(0xdeadbeef);
4692 lstrcmpiW(adirW, adirW);
4694 win_skip("Most W-calls are not implemented\n");
4695 return;
4696 }
4697
4698 hres = SHGetDesktopFolder(&psf);
4699 ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08x\n", hres);
4700 if(FAILED(hres)){
4701 win_skip("Failed to get IShellFolder, can't run tests\n");
4702 return;
4703 }
4704
4705 /* fails on unknown dir with no IBindCtx */
4706 hres = IShellFolder_ParseDisplayName(psf, NULL, NULL, adirW, NULL, &pidl, NULL);
4707 ok(hres == exp_err, "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
4708 hres = IShellFolder_ParseDisplayName(psf, NULL, NULL, afileW, NULL, &pidl, NULL);
4709 ok(hres == exp_err, "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
4710 hres = IShellFolder_ParseDisplayName(psf, NULL, NULL, afile2W, NULL, &pidl, NULL);
4711 ok(hres == exp_err, "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
4712
4713 /* fails on unknown dir with IBindCtx with no IFileSystemBindData */
4714 hres = CreateBindCtx(0, &pbc);
4715 ok(hres == S_OK, "CreateBindCtx failed: 0x%08x\n", hres);
4716
4717 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
4718 ok(hres == exp_err, "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
4719 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afileW, NULL, &pidl, NULL);
4720 ok(hres == exp_err, "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
4721 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afile2W, NULL, &pidl, NULL);
4722 ok(hres == exp_err, "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
4723
4724 /* unknown dir with IBindCtx with IFileSystemBindData */
4725 hres = IBindCtx_RegisterObjectParam(pbc, wFileSystemBindData, (IUnknown*)&fsbd);
4726 ok(hres == S_OK, "RegisterObjectParam failed: 0x%08x\n", hres);
4727
4728 /* return E_FAIL from GetFindData */
4729 pidl = (ITEMIDLIST*)0xdeadbeef;
4730 fsbdVtbl.GetFindData = fsbd_GetFindData_fail;
4731 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
4732 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4733 if(SUCCEEDED(hres)){
4734 verify_pidl(pidl, adirW);
4735 ILFree(pidl);
4736 }
4737
4738 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afileW, NULL, &pidl, NULL);
4739 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4740 if(SUCCEEDED(hres)){
4741 verify_pidl(pidl, afileW);
4742 ILFree(pidl);
4743 }
4744
4745 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afile2W, NULL, &pidl, NULL);
4746 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4747 if(SUCCEEDED(hres)){
4748 verify_pidl(pidl, afile2W);
4749 ILFree(pidl);
4750 }
4751
4752 /* set FIND_DATA struct to NULLs */
4753 pidl = (ITEMIDLIST*)0xdeadbeef;
4754 fsbdVtbl.GetFindData = fsbd_GetFindData_nul;
4755 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
4756 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4757 if(SUCCEEDED(hres)){
4758 verify_pidl(pidl, adirW);
4759 ILFree(pidl);
4760 }
4761
4762 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afileW, NULL, &pidl, NULL);
4763 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4764 if(SUCCEEDED(hres)){
4765 verify_pidl(pidl, afileW);
4766 ILFree(pidl);
4767 }
4768
4769 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afile2W, NULL, &pidl, NULL);
4770 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4771 if(SUCCEEDED(hres)){
4772 verify_pidl(pidl, afile2W);
4773 ILFree(pidl);
4774 }
4775
4776 /* set FIND_DATA struct to junk */
4777 pidl = (ITEMIDLIST*)0xdeadbeef;
4778 fsbdVtbl.GetFindData = fsbd_GetFindData_junk;
4779 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
4780 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4781 if(SUCCEEDED(hres)){
4782 verify_pidl(pidl, adirW);
4783 ILFree(pidl);
4784 }
4785
4786 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afileW, NULL, &pidl, NULL);
4787 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4788 if(SUCCEEDED(hres)){
4789 verify_pidl(pidl, afileW);
4790 ILFree(pidl);
4791 }
4792
4793 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afile2W, NULL, &pidl, NULL);
4794 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4795 if(SUCCEEDED(hres)){
4796 verify_pidl(pidl, afile2W);
4797 ILFree(pidl);
4798 }
4799
4800 /* set FIND_DATA struct to invalid data */
4801 pidl = (ITEMIDLIST*)0xdeadbeef;
4802 fsbdVtbl.GetFindData = fsbd_GetFindData_invalid;
4803 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
4804 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4805 if(SUCCEEDED(hres)){
4806 verify_pidl(pidl, adirW);
4807 ILFree(pidl);
4808 }
4809
4810 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afileW, NULL, &pidl, NULL);
4811 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4812 if(SUCCEEDED(hres)){
4813 verify_pidl(pidl, afileW);
4814 ILFree(pidl);
4815 }
4816
4817 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afile2W, NULL, &pidl, NULL);
4818 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4819 if(SUCCEEDED(hres)){
4820 verify_pidl(pidl, afile2W);
4821 ILFree(pidl);
4822 }
4823
4824 /* set FIND_DATA struct to valid data */
4825 pidl = (ITEMIDLIST*)0xdeadbeef;
4826 fsbdVtbl.GetFindData = fsbd_GetFindData_valid;
4827 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
4828 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4829 if(SUCCEEDED(hres)){
4830 verify_pidl(pidl, adirW);
4831 ILFree(pidl);
4832 }
4833
4834 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afileW, NULL, &pidl, NULL);
4835 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4836 if(SUCCEEDED(hres)){
4837 verify_pidl(pidl, afileW);
4838 ILFree(pidl);
4839 }
4840
4841 hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, afile2W, NULL, &pidl, NULL);
4842 ok(hres == S_OK, "ParseDisplayName failed: 0x%08x\n", hres);
4843 if(SUCCEEDED(hres)){
4844 verify_pidl(pidl, afile2W);
4845 ILFree(pidl);
4846 }
4847
4848 IBindCtx_Release(pbc);
4849 IShellFolder_Release(psf);
4850}
HRESULT WINAPI CreateBindCtx(DWORD reserved, LPBC *ppbc)
Definition: bindctx.c:556
#define verify_pidl(i, p)
Definition: shlfolder.c:4526
static HRESULT WINAPI fsbd_GetFindData_nul(IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
Definition: shlfolder.c:4628
static HRESULT WINAPI fsbd_GetFindData_valid(IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
Definition: shlfolder.c:4651
static HRESULT WINAPI fsbd_GetFindData_invalid(IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
Definition: shlfolder.c:4642
static HRESULT WINAPI fsbd_GetFindData_fail(IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
Definition: shlfolder.c:4660
static HRESULT WINAPI fsbd_GetFindData_junk(IFileSystemBindData *fsbd, WIN32_FIND_DATAW *pfd)
Definition: shlfolder.c:4635
static IFileSystemBindDataVtbl fsbdVtbl
Definition: shlfolder.c:4666

Referenced by START_TEST().

◆ test_SHChangeNotify()

static void test_SHChangeNotify ( BOOL  test_new_delivery)
static

Definition at line 4944 of file shlfolder.c.

4945{
4946 HWND wnd;
4947 ULONG notifyID, i;
4948 HRESULT hr;
4949 BOOL br, has_unicode;
4950 SHChangeNotifyEntry entries[1];
4951 const CHAR root_dirA[] = "C:\\shell32_cn_test";
4952 const WCHAR root_dirW[] = {'C',':','\\','s','h','e','l','l','3','2','_','c','n','_','t','e','s','t',0};
4953
4954 trace("SHChangeNotify tests (%x)\n", test_new_delivery);
4955
4957 has_unicode = !(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED);
4958
4959 test_new_delivery_flag = test_new_delivery;
4960 if(!test_new_delivery)
4962
4964 CW_USEDEFAULT, CW_USEDEFAULT, 130, 105,
4966 ok(wnd != NULL, "Failed to make a window\n");
4967
4968 br = CreateDirectoryA(root_dirA, NULL);
4969 ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
4970
4971 entries[0].pidl = NULL;
4972 if(has_unicode)
4973 hr = SHILCreateFromPath(root_dirW, (LPITEMIDLIST*)&entries[0].pidl, 0);
4974 else
4975 hr = SHILCreateFromPath((const void *)root_dirA, (LPITEMIDLIST*)&entries[0].pidl, 0);
4976 ok(hr == S_OK, "SHILCreateFromPath failed: 0x%08x\n", hr);
4977 entries[0].fRecursive = TRUE;
4978
4980 SHCNE_ALLEVENTS, WM_USER_NOTIFY, 1, entries);
4981 ok(notifyID != 0, "Failed to register a window for change notifications\n");
4982
4983 for (i = 0; i < ARRAY_SIZE(chnotify_tests); ++i)
4984 {
4986
4987 exp_data->missing_events = exp_data->notify_count;
4989 exp_data->path_1[0] ? exp_data->path_1 : NULL,
4990 exp_data->path_2[0] ? exp_data->path_2 : NULL);
4991 do_events();
4992 ok(exp_data->missing_events == 0, "%s: Expected wndproc to be called\n", exp_data->id);
4993
4994 if(has_unicode){
4995 WCHAR *path1, *path2;
4996
4997 path1 = make_wstr(exp_data->path_1);
4998 path2 = make_wstr(exp_data->path_2);
4999
5000 exp_data->missing_events = exp_data->notify_count;
5002 do_events();
5003 ok(exp_data->missing_events == 0, "%s: Expected wndproc to be called\n", exp_data->id);
5004
5007 }
5008 }
5009
5010 SHChangeNotifyDeregister(notifyID);
5011 DestroyWindow(wnd);
5012
5013 ILFree((LPITEMIDLIST)entries[0].pidl);
5014 br = RemoveDirectoryA(root_dirA);
5015 ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
5016}
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
EXTERN_C ULONG WINAPI SHChangeNotifyRegister(HWND hwnd, INT fSources, LONG wEventMask, UINT uMsg, INT cItems, SHChangeNotifyEntry *lpItems)
EXTERN_C void WINAPI SHChangeNotify(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
EXTERN_C BOOL WINAPI SHChangeNotifyDeregister(ULONG hNotify)
static const WCHAR path1[]
Definition: path.c:28
static const WCHAR path2[]
Definition: path.c:29
struct ChNotifyTest chnotify_tests[]
#define WM_USER_NOTIFY
Definition: shlfolder.c:4853
static void register_testwindow_class(void)
Definition: shlfolder.c:4910
static void do_events(void)
Definition: shlfolder.c:4929
static WCHAR * make_wstr(const char *str)
Definition: shlfolder.c:71
BOOL test_new_delivery_flag
Definition: shlfolder.c:4869
HRESULT WINAPI SHILCreateFromPath(_In_ PCWSTR, _Outptr_ PIDLIST_ABSOLUTE *, _Inout_opt_ DWORD *)
#define SHCNF_PATHA
Definition: shlobj.h:1908
#define SHCNRF_NewDelivery
Definition: shlobj.h:1924
#define SHCNRF_ShellLevel
Definition: shlobj.h:1922
#define SHCNF_FLUSH
Definition: shlobj.h:1914
#define SHCNF_PATHW
Definition: shlobj.h:1911
#define SHCNE_ALLEVENTS
Definition: shlobj.h:1900
PCIDLIST_ABSOLUTE pidl
Definition: shlobj.h:1872
HWND WINAPI CreateWindowExA(_In_ DWORD dwExStyle, _In_opt_ LPCSTR lpClassName, _In_opt_ LPCSTR lpWindowName, _In_ DWORD dwStyle, _In_ int X, _In_ int Y, _In_ int nWidth, _In_ int nHeight, _In_opt_ HWND hWndParent, _In_opt_ HMENU hMenu, _In_opt_ HINSTANCE hInstance, _In_opt_ LPVOID lpParam)
#define CW_USEDEFAULT
Definition: winuser.h:225
BOOL WINAPI DestroyWindow(_In_ HWND)

Referenced by START_TEST().

◆ test_SHCreateDefaultContextMenu()

static void test_SHCreateDefaultContextMenu ( void  )
static

Definition at line 5018 of file shlfolder.c.

5019{
5020 HKEY keys[16];
5022 IShellFolder *desktop,*folder;
5023 IPersistFolder2 *persist;
5024 IContextMenu *cmenu;
5025 LONG status;
5026 LPITEMIDLIST pidlFolder, pidl_child, pidl;
5027 DEFCONTEXTMENU cminfo;
5028 HRESULT hr;
5029 UINT i;
5030 const WCHAR filename[] =
5031 {'\\','t','e','s','t','d','i','r','\\','t','e','s','t','1','.','t','x','t',0};
5032 if(!pSHCreateDefaultContextMenu)
5033 {
5034 win_skip("SHCreateDefaultContextMenu missing.\n");
5035 return;
5036 }
5037
5039 if (!path[0])
5040 {
5041 skip("GetCurrentDirectoryW returned an empty string.\n");
5042 return;
5043 }
5045 SHGetDesktopFolder(&desktop);
5046
5048
5049 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, path, NULL, &pidl, 0);
5050 ok(hr == S_OK, "Got 0x%08x\n", hr);
5051 if(SUCCEEDED(hr))
5052 {
5053 hr = SHBindToParent(pidl, &IID_IShellFolder, (void **)&folder, (const ITEMIDLIST **)&pidl_child);
5054 ok(hr == S_OK, "Got 0x%08x\n", hr);
5055
5056 IShellFolder_QueryInterface(folder,&IID_IPersistFolder2,(void**)&persist);
5057 IPersistFolder2_GetCurFolder(persist,&pidlFolder);
5058 IPersistFolder2_Release(persist);
5059 if(SUCCEEDED(hr))
5060 {
5061 cminfo.hwnd=NULL;
5062 cminfo.pcmcb=NULL;
5063 cminfo.psf=folder;
5064 cminfo.pidlFolder=NULL;
5065 cminfo.apidl=(LPCITEMIDLIST*)&pidl_child;
5066 cminfo.cidl=1;
5067 cminfo.aKeys=NULL;
5068 cminfo.cKeys=0;
5070
5071 hr = pSHCreateDefaultContextMenu(&cminfo,&IID_IContextMenu,(void**)&cmenu);
5072 ok(hr==S_OK,"Got 0x%08x\n", hr);
5073 test_contextmenu_qi(cmenu, TRUE);
5074 IContextMenu_Release(cmenu);
5075
5076 cminfo.pidlFolder=pidlFolder;
5077 hr = pSHCreateDefaultContextMenu(&cminfo,&IID_IContextMenu,(void**)&cmenu);
5078 ok(hr==S_OK,"Got 0x%08x\n", hr);
5079 test_contextmenu_qi(cmenu, TRUE);
5080 IContextMenu_Release(cmenu);
5081
5083 if(status==ERROR_SUCCESS){
5084 for(i=1;i<16;i++)
5085 keys[i]=keys[0];
5086 cminfo.aKeys=keys;
5087 cminfo.cKeys=16;
5088 hr = pSHCreateDefaultContextMenu(&cminfo,&IID_IContextMenu,(void**)&cmenu);
5089 RegCloseKey(keys[0]);
5090 ok(hr==S_OK,"Got 0x%08x\n", hr);
5091 IContextMenu_Release(cmenu);
5092 }
5093 }
5094 ILFree(pidlFolder);
5095 IShellFolder_Release(folder);
5096 }
5097 IShellFolder_Release(desktop);
5098 ILFree(pidl);
5099 Cleanup();
5100}
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3298
IContextMenuCB * pcmcb
Definition: shlobj.h:2536
IShellFolder * psf
Definition: shlobj.h:2538
IUnknown * punkAssociationInfo
Definition: shlobj.h:2541
PCUITEMID_CHILD_ARRAY apidl
Definition: shlobj.h:2540
const HKEY * aKeys
Definition: shlobj.h:2543
PCIDLIST_ABSOLUTE pidlFolder
Definition: shlobj.h:2537
Definition: ps.c:97

Referenced by START_TEST().

◆ test_SHCreateShellItem()

static void test_SHCreateShellItem ( void  )
static

Definition at line 1998 of file shlfolder.c.

1999{
2000 IShellItem *shellitem, *shellitem2;
2001 IPersistIDList *persistidl;
2002 LPITEMIDLIST pidl_cwd=NULL, pidl_testfile, pidl_abstestfile, pidl_test, pidl_desktop;
2003 HRESULT ret;
2004 char curdirA[MAX_PATH];
2005 WCHAR curdirW[MAX_PATH];
2006 WCHAR fnbufW[MAX_PATH];
2007 IShellFolder *desktopfolder=NULL, *currentfolder=NULL;
2008 static WCHAR testfileW[] = {'t','e','s','t','f','i','l','e',0};
2009
2011
2012 if (!pSHCreateShellItem)
2013 {
2014 win_skip("SHCreateShellItem isn't available\n");
2015 return;
2016 }
2017
2018 if (!curdirA[0])
2019 {
2020 win_skip("GetCurrentDirectoryA returned empty string, skipping test_SHCreateShellItem\n");
2021 return;
2022 }
2023
2025 ok(ret == S_OK, "Got 0x%08x\n", ret);
2026
2027 MultiByteToWideChar(CP_ACP, 0, curdirA, -1, curdirW, MAX_PATH);
2028
2029 ret = SHGetDesktopFolder(&desktopfolder);
2030 ok(SUCCEEDED(ret), "SHGetShellFolder returned %x\n", ret);
2031
2032 ret = IShellFolder_ParseDisplayName(desktopfolder, NULL, NULL, curdirW, NULL, &pidl_cwd, NULL);
2033 ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
2034
2035 ret = IShellFolder_BindToObject(desktopfolder, pidl_cwd, NULL, &IID_IShellFolder, (void**)&currentfolder);
2036 ok(SUCCEEDED(ret), "BindToObject returned %x\n", ret);
2037
2038 CreateTestFile(".\\testfile");
2039
2040 ret = IShellFolder_ParseDisplayName(currentfolder, NULL, NULL, testfileW, NULL, &pidl_testfile, NULL);
2041 ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
2042
2043 pidl_abstestfile = ILCombine(pidl_cwd, pidl_testfile);
2044
2045 shellitem = (void*)0xdeadbeef;
2046 ret = pSHCreateShellItem(NULL, NULL, NULL, &shellitem);
2047 ok(ret == E_INVALIDARG, "SHCreateShellItem returned %x\n", ret);
2048 ok(shellitem == 0, "Got %p\n", shellitem);
2049
2050 if (0) /* crashes on Windows XP */
2051 {
2052 pSHCreateShellItem(NULL, NULL, pidl_cwd, NULL);
2053 pSHCreateShellItem(pidl_cwd, NULL, NULL, &shellitem);
2054 pSHCreateShellItem(NULL, currentfolder, NULL, &shellitem);
2055 pSHCreateShellItem(pidl_cwd, currentfolder, NULL, &shellitem);
2056 }
2057
2058 ret = pSHCreateShellItem(NULL, NULL, pidl_cwd, &shellitem);
2059 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2060 if (SUCCEEDED(ret))
2061 {
2062 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2063 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2064 if (SUCCEEDED(ret))
2065 {
2066 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2067 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2068 if (SUCCEEDED(ret))
2069 {
2070 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
2071 ILFree(pidl_test);
2072 }
2073 IPersistIDList_Release(persistidl);
2074 }
2075 IShellItem_Release(shellitem);
2076 }
2077
2078 ret = pSHCreateShellItem(pidl_cwd, NULL, pidl_testfile, &shellitem);
2079 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2080 if (SUCCEEDED(ret))
2081 {
2082 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2083 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2084 if (SUCCEEDED(ret))
2085 {
2086 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2087 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2088 if (SUCCEEDED(ret))
2089 {
2090 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2091 ILFree(pidl_test);
2092 }
2093 IPersistIDList_Release(persistidl);
2094 }
2095
2096 ret = IShellItem_GetParent(shellitem, &shellitem2);
2097 ok(SUCCEEDED(ret), "GetParent returned %x\n", ret);
2098 if (SUCCEEDED(ret))
2099 {
2100 ret = IShellItem_QueryInterface(shellitem2, &IID_IPersistIDList, (void**)&persistidl);
2101 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2102 if (SUCCEEDED(ret))
2103 {
2104 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2105 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2106 if (SUCCEEDED(ret))
2107 {
2108 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
2109 ILFree(pidl_test);
2110 }
2111 IPersistIDList_Release(persistidl);
2112 }
2113 IShellItem_Release(shellitem2);
2114 }
2115
2116 IShellItem_Release(shellitem);
2117 }
2118
2119 ret = pSHCreateShellItem(NULL, currentfolder, pidl_testfile, &shellitem);
2120 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2121 if (SUCCEEDED(ret))
2122 {
2123 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2124 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2125 if (SUCCEEDED(ret))
2126 {
2127 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2128 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2129 if (SUCCEEDED(ret))
2130 {
2131 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2132 ILFree(pidl_test);
2133 }
2134 IPersistIDList_Release(persistidl);
2135 }
2136 IShellItem_Release(shellitem);
2137 }
2138
2139 /* if a parent pidl and shellfolder are specified, the shellfolder is ignored */
2140 ret = pSHCreateShellItem(pidl_cwd, desktopfolder, pidl_testfile, &shellitem);
2141 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2142 if (SUCCEEDED(ret))
2143 {
2144 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2145 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2146 if (SUCCEEDED(ret))
2147 {
2148 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2149 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2150 if (SUCCEEDED(ret))
2151 {
2152 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2153 ILFree(pidl_test);
2154 }
2155 IPersistIDList_Release(persistidl);
2156 }
2157 IShellItem_Release(shellitem);
2158 }
2159
2160 ret = pSHCreateShellItem(NULL, desktopfolder, pidl_testfile, &shellitem);
2161 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2162 if (SUCCEEDED(ret))
2163 {
2164 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2165 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2166 if (SUCCEEDED(ret))
2167 {
2168 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2169 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2170 if (SUCCEEDED(ret))
2171 {
2172 ok(ILIsEqual(pidl_testfile, pidl_test), "id lists are not equal\n");
2173 ILFree(pidl_test);
2174 }
2175 IPersistIDList_Release(persistidl);
2176 }
2177
2178 IShellItem_Release(shellitem);
2179 }
2180
2181 ret = pSHCreateShellItem(NULL, NULL, pidl_desktop, &shellitem);
2182 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2183 if (SUCCEEDED(ret))
2184 {
2185 ret = IShellItem_GetParent(shellitem, &shellitem2);
2186 ok(FAILED(ret), "Got 0x%08x\n", ret);
2187 if(SUCCEEDED(ret)) IShellItem_Release(shellitem2);
2188 IShellItem_Release(shellitem);
2189 }
2190
2191 /* SHCreateItemFromParsingName */
2192 if(pSHCreateItemFromParsingName)
2193 {
2194 if(0)
2195 {
2196 /* Crashes under windows 7 */
2197 pSHCreateItemFromParsingName(NULL, NULL, &IID_IShellItem, NULL);
2198 }
2199
2200 shellitem = (void*)0xdeadbeef;
2201 ret = pSHCreateItemFromParsingName(NULL, NULL, &IID_IShellItem, (void**)&shellitem);
2202 ok(ret == E_INVALIDARG, "SHCreateItemFromParsingName returned %x\n", ret);
2203 ok(shellitem == NULL, "shellitem was %p.\n", shellitem);
2204
2205 ret = pSHCreateItemFromParsingName(testfileW, NULL, &IID_IShellItem, (void**)&shellitem);
2207 "SHCreateItemFromParsingName returned %x\n", ret);
2208 if(SUCCEEDED(ret)) IShellItem_Release(shellitem);
2209
2210 lstrcpyW(fnbufW, curdirW);
2211 myPathAddBackslashW(fnbufW);
2212 lstrcatW(fnbufW, testfileW);
2213
2214 ret = pSHCreateItemFromParsingName(fnbufW, NULL, &IID_IShellItem, (void**)&shellitem);
2215 ok(ret == S_OK, "SHCreateItemFromParsingName returned %x\n", ret);
2216 if(SUCCEEDED(ret))
2217 {
2218 LPWSTR tmp_fname;
2219 ret = IShellItem_GetDisplayName(shellitem, SIGDN_FILESYSPATH, &tmp_fname);
2220 ok(ret == S_OK, "GetDisplayName returned %x\n", ret);
2221 if(SUCCEEDED(ret))
2222 {
2223 ok(!lstrcmpW(fnbufW, tmp_fname), "strings not equal\n");
2224 CoTaskMemFree(tmp_fname);
2225 }
2226 IShellItem_Release(shellitem);
2227 }
2228 }
2229 else
2230 win_skip("No SHCreateItemFromParsingName\n");
2231
2232
2233 /* SHCreateItemFromIDList */
2234 if(pSHCreateItemFromIDList)
2235 {
2236 if(0)
2237 {
2238 /* Crashes under win7 */
2239 pSHCreateItemFromIDList(NULL, &IID_IShellItem, NULL);
2240 }
2241
2242 ret = pSHCreateItemFromIDList(NULL, &IID_IShellItem, (void**)&shellitem);
2243 ok(ret == E_INVALIDARG, "SHCreateItemFromIDList returned %x\n", ret);
2244
2245 ret = pSHCreateItemFromIDList(pidl_cwd, &IID_IShellItem, (void**)&shellitem);
2246 ok(ret == S_OK, "SHCreateItemFromIDList returned %x\n", ret);
2247 if (SUCCEEDED(ret))
2248 {
2249 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2250 ok(ret == S_OK, "QueryInterface returned %x\n", ret);
2251 if (SUCCEEDED(ret))
2252 {
2253 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2254 ok(ret == S_OK, "GetIDList returned %x\n", ret);
2255 if (SUCCEEDED(ret))
2256 {
2257 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
2258 ILFree(pidl_test);
2259 }
2260 IPersistIDList_Release(persistidl);
2261 }
2262 IShellItem_Release(shellitem);
2263 }
2264
2265 ret = pSHCreateItemFromIDList(pidl_testfile, &IID_IShellItem, (void**)&shellitem);
2266 ok(ret == S_OK, "SHCreateItemFromIDList returned %x\n", ret);
2267 if (SUCCEEDED(ret))
2268 {
2269 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2270 ok(ret == S_OK, "QueryInterface returned %x\n", ret);
2271 if (SUCCEEDED(ret))
2272 {
2273 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2274 ok(ret == S_OK, "GetIDList returned %x\n", ret);
2275 if (SUCCEEDED(ret))
2276 {
2277 ok(ILIsEqual(pidl_testfile, pidl_test), "id lists are not equal\n");
2278 ILFree(pidl_test);
2279 }
2280 IPersistIDList_Release(persistidl);
2281 }
2282 IShellItem_Release(shellitem);
2283 }
2284 }
2285 else
2286 win_skip("No SHCreateItemFromIDList\n");
2287
2288 /* SHCreateItemFromRelativeName */
2289 if(pSHCreateItemFromRelativeName && pSHGetKnownFolderPath)
2290 {
2291 IShellItem *shellitem_desktop = NULL;
2292 WCHAR *desktop_path, *displayname;
2293 WCHAR testfile_path[MAX_PATH] = {0};
2294 HANDLE file;
2295 LPITEMIDLIST pidl_desktop_testfile = NULL;
2296 int order;
2297
2298 ret = pSHCreateShellItem(NULL, NULL, pidl_desktop, &shellitem_desktop);
2299 ok(ret == S_OK, "SHCreateShellItem failed: 0x%08x.\n", ret);
2300
2301 shellitem = (void*)0xdeadbeef;
2302 ret = pSHCreateItemFromRelativeName(shellitem_desktop, NULL, NULL, &IID_IShellItem,
2303 (void**)&shellitem);
2304 ok(ret == E_INVALIDARG, "Expected 0x%08x but SHCreateItemFromRelativeName return: 0x%08x.\n",
2305 E_INVALIDARG, ret);
2306 ok(shellitem == NULL, "shellitem was %p.\n", shellitem);
2307
2308 /* Test with a non-existent file */
2309 shellitem = (void*)0xdeadbeef;
2310 ret = pSHCreateItemFromRelativeName(shellitem_desktop, testfileW, NULL, &IID_IShellItem,
2311 (void**)&shellitem);
2313 "Expected 0x%08x but SHCreateItemFromRelativeName return: 0x%08x.\n",
2315 ok(shellitem == NULL, "shellitem was %p.\n", shellitem);
2316
2317 /* Create a file for testing in desktop folder */
2318 pSHGetKnownFolderPath(&FOLDERID_Desktop, 0, NULL, &desktop_path);
2319 lstrcatW(tes