git.oblomov.eu Git - wine/blob - dlls/shell32/tests/shlfolder.c

   1 /*
   2  * Unit test of the IShellFolder functions.
   3  *
   4  * Copyright 2004 Vitaliy Margolen
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25 #define CONST_VTABLE
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wtypes.h"
  30 #include "shellapi.h"
  31
  32
  33 #include "shlguid.h"
  34 #include "shlobj.h"
  35 #include "shobjidl.h"
  36 #include "shlwapi.h"
  37 #include "ocidl.h"
  38 #include "oleauto.h"
  39
  40 #include "wine/test.h"
  41
  42 #include <initguid.h>
  43 DEFINE_GUID(IID_IParentAndItem, 0xB3A4B685, 0xB685, 0x4805, 0x99,0xD9, 0x5D,0xEA,0xD2,0x87,0x32,0x36);
  44
  45 static IMalloc *ppM;
  46
  47 static HRESULT (WINAPI *pSHBindToParent)(LPCITEMIDLIST, REFIID, LPVOID*, LPCITEMIDLIST*);
  48 static HRESULT (WINAPI *pSHGetFolderPathA)(HWND, int, HANDLE, DWORD, LPSTR);
  49 static HRESULT (WINAPI *pSHGetFolderPathAndSubDirA)(HWND, int, HANDLE, DWORD, LPCSTR, LPSTR);
  50 static BOOL (WINAPI *pSHGetPathFromIDListW)(LPCITEMIDLIST,LPWSTR);
  51 static HRESULT (WINAPI *pSHGetSpecialFolderLocation)(HWND, int, LPITEMIDLIST *);
  52 static BOOL (WINAPI *pSHGetSpecialFolderPathA)(HWND, LPSTR, int, BOOL);
  53 static BOOL (WINAPI *pSHGetSpecialFolderPathW)(HWND, LPWSTR, int, BOOL);
  54 static HRESULT (WINAPI *pStrRetToBufW)(STRRET*,LPCITEMIDLIST,LPWSTR,UINT);
  55 static LPITEMIDLIST (WINAPI *pILFindLastID)(LPCITEMIDLIST);
  56 static void (WINAPI *pILFree)(LPITEMIDLIST);
  57 static BOOL (WINAPI *pILIsEqual)(LPCITEMIDLIST, LPCITEMIDLIST);
  58 static HRESULT (WINAPI *pSHCreateItemFromIDList)(PCIDLIST_ABSOLUTE pidl, REFIID riid, void **ppv);
  59 static HRESULT (WINAPI *pSHCreateItemFromParsingName)(PCWSTR,IBindCtx*,REFIID,void**);
  60 static HRESULT (WINAPI *pSHCreateShellItem)(LPCITEMIDLIST,IShellFolder*,LPCITEMIDLIST,IShellItem**);
  61 static HRESULT (WINAPI *pSHCreateShellItemArray)(LPCITEMIDLIST,IShellFolder*,UINT,LPCITEMIDLIST*,IShellItemArray**);
  62 static HRESULT (WINAPI *pSHCreateShellItemArrayFromDataObject)(IDataObject*, REFIID, void **);
  63 static HRESULT (WINAPI *pSHCreateShellItemArrayFromShellItem)(IShellItem*, REFIID, void **);
  64 static LPITEMIDLIST (WINAPI *pILCombine)(LPCITEMIDLIST,LPCITEMIDLIST);
  65 static HRESULT (WINAPI *pSHParseDisplayName)(LPCWSTR,IBindCtx*,LPITEMIDLIST*,SFGAOF,SFGAOF*);
  66 static LPITEMIDLIST (WINAPI *pSHSimpleIDListFromPathAW)(LPCVOID);
  67 static HRESULT (WINAPI *pSHGetNameFromIDList)(PCIDLIST_ABSOLUTE,SIGDN,PWSTR*);
  68 static HRESULT (WINAPI *pSHGetItemFromDataObject)(IDataObject*,DATAOBJ_GET_ITEM_FLAGS,REFIID,void**);
  69 static HRESULT (WINAPI *pSHGetIDListFromObject)(IUnknown*, PIDLIST_ABSOLUTE*);
  70 static HRESULT (WINAPI *pSHGetItemFromObject)(IUnknown*,REFIID,void**);
  71
  72 static int strcmp_wa(LPCWSTR strw, const char *stra)
  73 {
  74     CHAR buf[512];
  75     WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
  76     return lstrcmpA(stra, buf);
  77 }
  78
  79 static void init_function_pointers(void)
  80 {
  81     HMODULE hmod;
  82     HRESULT hr;
  83     void *ptr;
  84
  85     hmod = GetModuleHandleA("shell32.dll");
  86
  87 #define MAKEFUNC(f) (p##f = (void*)GetProcAddress(hmod, #f))
  88     MAKEFUNC(SHBindToParent);
  89     MAKEFUNC(SHCreateItemFromIDList);
  90     MAKEFUNC(SHCreateItemFromParsingName);
  91     MAKEFUNC(SHCreateShellItem);
  92     MAKEFUNC(SHCreateShellItemArray);
  93     MAKEFUNC(SHCreateShellItemArrayFromDataObject);
  94     MAKEFUNC(SHCreateShellItemArrayFromShellItem);
  95     MAKEFUNC(SHGetFolderPathA);
  96     MAKEFUNC(SHGetFolderPathAndSubDirA);
  97     MAKEFUNC(SHGetPathFromIDListW);
  98     MAKEFUNC(SHGetSpecialFolderPathA);
  99     MAKEFUNC(SHGetSpecialFolderPathW);
 100     MAKEFUNC(SHGetSpecialFolderLocation);
 101     MAKEFUNC(SHParseDisplayName);
 102     MAKEFUNC(SHGetNameFromIDList);
 103     MAKEFUNC(SHGetItemFromDataObject);
 104     MAKEFUNC(SHGetIDListFromObject);
 105     MAKEFUNC(SHGetItemFromObject);
 106 #undef MAKEFUNC
 107
 108 #define MAKEFUNC_ORD(f, ord) (p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))
 109     MAKEFUNC_ORD(ILFindLastID, 16);
 110     MAKEFUNC_ORD(ILIsEqual, 21);
 111     MAKEFUNC_ORD(ILCombine, 25);
 112     MAKEFUNC_ORD(ILFree, 155);
 113     MAKEFUNC_ORD(SHSimpleIDListFromPathAW, 162);
 114 #undef MAKEFUNC_ORD
 115
 116     /* test named exports */
 117     ptr = GetProcAddress(hmod, "ILFree");
 118     ok(broken(ptr == 0) || ptr != 0, "expected named export for ILFree\n");
 119     if (ptr)
 120     {
 121 #define TESTNAMED(f) \
 122     ptr = (void*)GetProcAddress(hmod, #f); \
 123     ok(ptr != 0, "expected named export for " #f "\n");
 124
 125         TESTNAMED(ILAppendID);
 126         TESTNAMED(ILClone);
 127         TESTNAMED(ILCloneFirst);
 128         TESTNAMED(ILCombine);
 129         TESTNAMED(ILCreateFromPath);
 130         TESTNAMED(ILCreateFromPathA);
 131         TESTNAMED(ILCreateFromPathW);
 132         TESTNAMED(ILFindChild);
 133         TESTNAMED(ILFindLastID);
 134         TESTNAMED(ILGetNext);
 135         TESTNAMED(ILGetSize);
 136         TESTNAMED(ILIsEqual);
 137         TESTNAMED(ILIsParent);
 138         TESTNAMED(ILRemoveLastID);
 139         TESTNAMED(ILSaveToStream);
 140 #undef TESTNAMED
 141     }
 142
 143     hmod = GetModuleHandleA("shlwapi.dll");
 144     pStrRetToBufW = (void*)GetProcAddress(hmod, "StrRetToBufW");
 145
 146     hr = SHGetMalloc(&ppM);
 147     ok(hr == S_OK, "SHGetMalloc failed %08x\n", hr);
 148 }
 149
 150 static void test_ParseDisplayName(void)
 151 {
 152     HRESULT hr;
 153     IShellFolder *IDesktopFolder;
 154     static const char *cNonExistDir1A = "c:\\nonexist_subdir";
 155     static const char *cNonExistDir2A = "c:\\\\nonexist_subdir";
 156     static const char *cInetTestA = "http:\\yyy";
 157     static const char *cInetTest2A = "xx:yyy";
 158     DWORD res;
 159     WCHAR cTestDirW [MAX_PATH] = {0};
 160     ITEMIDLIST *newPIDL;
 161     BOOL bRes;
 162
 163     hr = SHGetDesktopFolder(&IDesktopFolder);
 164     ok(hr == S_OK, "Expected SHGetDesktopFolder to return S_OK, got 0x%08x\n", hr);
 165     if(hr != S_OK) return;
 166
 167     /* Tests crash on W2K and below (SHCreateShellItem available as of XP) */
 168     if (pSHCreateShellItem)
 169     {
 170         /* null name and pidl */
 171         hr = IShellFolder_ParseDisplayName(IDesktopFolder,
 172             NULL, NULL, NULL, NULL, NULL, 0);
 173         ok(hr == E_INVALIDARG, "returned %08x, expected E_INVALIDARG\n", hr);
 174
 175         /* null name */
 176         newPIDL = (ITEMIDLIST*)0xdeadbeef;
 177         hr = IShellFolder_ParseDisplayName(IDesktopFolder,
 178             NULL, NULL, NULL, NULL, &newPIDL, 0);
 179         ok(newPIDL == 0, "expected null, got %p\n", newPIDL);
 180         ok(hr == E_INVALIDARG, "returned %08x, expected E_INVALIDARG\n", hr);
 181     }
 182     else
 183         win_skip("Tests would crash on W2K and below\n");
 184
 185     MultiByteToWideChar(CP_ACP, 0, cInetTestA, -1, cTestDirW, MAX_PATH);
 186     hr = IShellFolder_ParseDisplayName(IDesktopFolder,
 187         NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
 188     todo_wine ok(hr == S_OK || broken(hr == E_FAIL) /* NT4 */,
 189         "ParseDisplayName returned %08x, expected SUCCESS or E_FAIL\n", hr);
 190     if (hr == S_OK)
 191     {
 192         ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x61, "Last pidl should be of type "
 193            "PT_IESPECIAL1, but is: %02x\n", pILFindLastID(newPIDL)->mkid.abID[0]);
 194         IMalloc_Free(ppM, newPIDL);
 195     }
 196
 197     MultiByteToWideChar(CP_ACP, 0, cInetTest2A, -1, cTestDirW, MAX_PATH);
 198     hr = IShellFolder_ParseDisplayName(IDesktopFolder,
 199         NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
 200     todo_wine ok(hr == S_OK || broken(hr == E_FAIL) /* NT4 */,
 201         "ParseDisplayName returned %08x, expected SUCCESS or E_FAIL\n", hr);
 202     if (hr == S_OK)
 203     {
 204         ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x61, "Last pidl should be of type "
 205            "PT_IESPECIAL1, but is: %02x\n", pILFindLastID(newPIDL)->mkid.abID[0]);
 206         IMalloc_Free(ppM, newPIDL);
 207     }
 208
 209     res = GetFileAttributesA(cNonExistDir1A);
 210     if(res != INVALID_FILE_ATTRIBUTES)
 211     {
 212         skip("Test directory unexpectedly exists\n");
 213         goto finished;
 214     }
 215
 216     MultiByteToWideChar(CP_ACP, 0, cNonExistDir1A, -1, cTestDirW, MAX_PATH);
 217     hr = IShellFolder_ParseDisplayName(IDesktopFolder,
 218         NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
 219     ok((hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) || (hr == E_FAIL),
 220         "ParseDisplayName returned %08x, expected 80070002 or E_FAIL\n", hr);
 221
 222     res = GetFileAttributesA(cNonExistDir2A);
 223     if(res != INVALID_FILE_ATTRIBUTES)
 224     {
 225         skip("Test directory unexpectedly exists\n");
 226         goto finished;
 227     }
 228
 229     MultiByteToWideChar(CP_ACP, 0, cNonExistDir2A, -1, cTestDirW, MAX_PATH);
 230     hr = IShellFolder_ParseDisplayName(IDesktopFolder,
 231         NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
 232     ok((hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) || (hr == E_FAIL) || (hr == E_INVALIDARG),
 233         "ParseDisplayName returned %08x, expected 80070002, E_FAIL or E_INVALIDARG\n", hr);
 234
 235     /* I thought that perhaps the DesktopFolder's ParseDisplayName would recognize the
 236      * path corresponding to CSIDL_PERSONAL and return a CLSID_MyDocuments PIDL. Turns
 237      * out it doesn't. The magic seems to happen in the file dialogs, then. */
 238     if (!pSHGetSpecialFolderPathW || !pILFindLastID)
 239     {
 240         win_skip("SHGetSpecialFolderPathW and/or ILFindLastID are not available\n");
 241         goto finished;
 242     }
 243
 244     bRes = pSHGetSpecialFolderPathW(NULL, cTestDirW, CSIDL_PERSONAL, FALSE);
 245     ok(bRes, "SHGetSpecialFolderPath(CSIDL_PERSONAL) failed! %u\n", GetLastError());
 246     if (!bRes) goto finished;
 247
 248     hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
 249     ok(hr == S_OK, "DesktopFolder->ParseDisplayName failed. hr = %08x.\n", hr);
 250     if (hr != S_OK) goto finished;
 251
 252     ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x31 ||
 253        pILFindLastID(newPIDL)->mkid.abID[0] == 0xb1, /* Win98 */
 254        "Last pidl should be of type PT_FOLDER or PT_IESPECIAL2, but is: %02x\n",
 255        pILFindLastID(newPIDL)->mkid.abID[0]);
 256     IMalloc_Free(ppM, newPIDL);
 257
 258 finished:
 259     IShellFolder_Release(IDesktopFolder);
 260 }
 261
 262 /* creates a file with the specified name for tests */
 263 static void CreateTestFile(const CHAR *name)
 264 {
 265     HANDLE file;
 266     DWORD written;
 267
 268     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 269     if (file != INVALID_HANDLE_VALUE)
 270     {
 271         WriteFile(file, name, strlen(name), &written, NULL);
 272         WriteFile(file, "\n", strlen("\n"), &written, NULL);
 273         CloseHandle(file);
 274     }
 275 }
 276
 277
 278 /* initializes the tests */
 279 static void CreateFilesFolders(void)
 280 {
 281     CreateDirectoryA(".\\testdir", NULL);
 282     CreateDirectoryA(".\\testdir\\test.txt", NULL);
 283     CreateTestFile  (".\\testdir\\test1.txt ");
 284     CreateTestFile  (".\\testdir\\test2.txt ");
 285     CreateTestFile  (".\\testdir\\test3.txt ");
 286     CreateDirectoryA(".\\testdir\\testdir2 ", NULL);
 287     CreateDirectoryA(".\\testdir\\testdir2\\subdir", NULL);
 288 }
 289
 290 /* cleans after tests */
 291 static void Cleanup(void)
 292 {
 293     DeleteFileA(".\\testdir\\test1.txt");
 294     DeleteFileA(".\\testdir\\test2.txt");
 295     DeleteFileA(".\\testdir\\test3.txt");
 296     RemoveDirectoryA(".\\testdir\\test.txt");
 297     RemoveDirectoryA(".\\testdir\\testdir2\\subdir");
 298     RemoveDirectoryA(".\\testdir\\testdir2");
 299     RemoveDirectoryA(".\\testdir");
 300 }
 301
 302
 303 /* perform test */
 304 static void test_EnumObjects(IShellFolder *iFolder)
 305 {
 306     IEnumIDList *iEnumList;
 307     LPITEMIDLIST newPIDL, idlArr[10];
 308     ULONG NumPIDLs;
 309     int i=0, j;
 310     HRESULT hr;
 311
 312     static const WORD iResults [5][5] =
 313     {
 314         { 0,-1,-1,-1,-1},
 315         { 1, 0,-1,-1,-1},
 316         { 1, 1, 0,-1,-1},
 317         { 1, 1, 1, 0,-1},
 318         { 1, 1, 1, 1, 0}
 319     };
 320
 321 #define SFGAO_testfor SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_CAPABILITYMASK
 322     /* Don't test for SFGAO_HASSUBFOLDER since we return real state and native cached */
 323     static const ULONG attrs[5] =
 324     {
 325         SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
 326         SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
 327         SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
 328         SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
 329         SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
 330     };
 331
 332     hr = IShellFolder_EnumObjects(iFolder, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &iEnumList);
 333     ok(hr == S_OK, "EnumObjects failed %08x\n", hr);
 334
 335     /* This is to show that, contrary to what is said on MSDN, on IEnumIDList::Next,
 336      * the filesystem shellfolders return S_OK even if less than 'celt' items are
 337      * returned (in contrast to S_FALSE). We have to do it in a loop since WinXP
 338      * only ever returns a single entry per call. */
 339     while (IEnumIDList_Next(iEnumList, 10-i, &idlArr[i], &NumPIDLs) == S_OK)
 340         i += NumPIDLs;
 341     ok (i == 5, "i: %d\n", i);
 342
 343     hr = IEnumIDList_Release(iEnumList);
 344     ok(hr == S_OK, "IEnumIDList_Release failed %08x\n", hr);
 345
 346     /* Sort them first in case of wrong order from system */
 347     for (i=0;i<5;i++) for (j=0;j<5;j++)
 348         if ((SHORT)IShellFolder_CompareIDs(iFolder, 0, idlArr[i], idlArr[j]) < 0)
 349         {
 350             newPIDL = idlArr[i];
 351             idlArr[i] = idlArr[j];
 352             idlArr[j] = newPIDL;
 353         }
 354
 355     for (i=0;i<5;i++) for (j=0;j<5;j++)
 356     {
 357         hr = IShellFolder_CompareIDs(iFolder, 0, idlArr[i], idlArr[j]);
 358         ok(hr == iResults[i][j], "Got %x expected [%d]-[%d]=%x\n", hr, i, j, iResults[i][j]);
 359     }
 360
 361
 362     for (i = 0; i < 5; i++)
 363     {
 364         SFGAOF flags;
 365 #define SFGAO_VISTA SFGAO_DROPTARGET | SFGAO_CANLINK | SFGAO_CANCOPY
 366         /* Native returns all flags no matter what we ask for */
 367         flags = SFGAO_CANCOPY;
 368         hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
 369         flags &= SFGAO_testfor;
 370         ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
 371         ok(flags == (attrs[i]) ||
 372            flags == (attrs[i] & ~SFGAO_FILESYSANCESTOR) || /* Win9x, NT4 */
 373            flags == ((attrs[i] & ~SFGAO_CAPABILITYMASK) | SFGAO_VISTA), /* Vista and higher */
 374            "GetAttributesOf[%i] got %08x, expected %08x\n", i, flags, attrs[i]);
 375
 376         flags = SFGAO_testfor;
 377         hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
 378         flags &= SFGAO_testfor;
 379         ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
 380         ok(flags == attrs[i] ||
 381            flags == (attrs[i] & ~SFGAO_FILESYSANCESTOR), /* Win9x, NT4 */
 382            "GetAttributesOf[%i] got %08x, expected %08x\n", i, flags, attrs[i]);
 383     }
 384
 385     for (i=0;i<5;i++)
 386         IMalloc_Free(ppM, idlArr[i]);
 387 }
 388
 389 static void test_BindToObject(void)
 390 {
 391     HRESULT hr;
 392     UINT cChars;
 393     IShellFolder *psfDesktop, *psfChild, *psfMyComputer, *psfSystemDir;
 394     SHITEMID emptyitem = { 0, { 0 } };
 395     LPITEMIDLIST pidlMyComputer, pidlSystemDir, pidlEmpty = (LPITEMIDLIST)&emptyitem;
 396     WCHAR wszSystemDir[MAX_PATH];
 397     char szSystemDir[MAX_PATH];
 398     WCHAR wszMyComputer[] = {
 399         ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
 400         'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
 401
 402     /* The following tests shows that BindToObject should fail with E_INVALIDARG if called
 403      * with an empty pidl. This is tested for Desktop, MyComputer and the FS ShellFolder
 404      */
 405     hr = SHGetDesktopFolder(&psfDesktop);
 406     ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
 407     if (hr != S_OK) return;
 408
 409     hr = IShellFolder_BindToObject(psfDesktop, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 410     ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
 411
 412     hr = IShellFolder_BindToObject(psfDesktop, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 413     ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
 414
 415     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
 416     ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
 417     if (hr != S_OK) {
 418         IShellFolder_Release(psfDesktop);
 419         return;
 420     }
 421
 422     hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
 423     ok (hr == S_OK, "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
 424     IShellFolder_Release(psfDesktop);
 425     IMalloc_Free(ppM, pidlMyComputer);
 426     if (hr != S_OK) return;
 427
 428     hr = IShellFolder_BindToObject(psfMyComputer, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 429     ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
 430
 431 if (0)
 432 {
 433     /* this call segfaults on 98SE */
 434     hr = IShellFolder_BindToObject(psfMyComputer, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 435     ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
 436 }
 437
 438     cChars = GetSystemDirectoryA(szSystemDir, MAX_PATH);
 439     ok (cChars > 0 && cChars < MAX_PATH, "GetSystemDirectoryA failed! LastError: %u\n", GetLastError());
 440     if (cChars == 0 || cChars >= MAX_PATH) {
 441         IShellFolder_Release(psfMyComputer);
 442         return;
 443     }
 444     MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszSystemDir, MAX_PATH);
 445
 446     hr = IShellFolder_ParseDisplayName(psfMyComputer, NULL, NULL, wszSystemDir, NULL, &pidlSystemDir, NULL);
 447     ok (hr == S_OK, "MyComputers's ParseDisplayName failed to parse the SystemDirectory! hr = %08x\n", hr);
 448     if (hr != S_OK) {
 449         IShellFolder_Release(psfMyComputer);
 450         return;
 451     }
 452
 453     hr = IShellFolder_BindToObject(psfMyComputer, pidlSystemDir, NULL, &IID_IShellFolder, (LPVOID*)&psfSystemDir);
 454     ok (hr == S_OK, "MyComputer failed to bind to a FileSystem ShellFolder! hr = %08x\n", hr);
 455     IShellFolder_Release(psfMyComputer);
 456     IMalloc_Free(ppM, pidlSystemDir);
 457     if (hr != S_OK) return;
 458
 459     hr = IShellFolder_BindToObject(psfSystemDir, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 460     ok (hr == E_INVALIDARG,
 461         "FileSystem ShellFolder's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
 462
 463 if (0)
 464 {
 465     /* this call segfaults on 98SE */
 466     hr = IShellFolder_BindToObject(psfSystemDir, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
 467     ok (hr == E_INVALIDARG,
 468         "FileSystem ShellFolder's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
 469 }
 470
 471     IShellFolder_Release(psfSystemDir);
 472 }
 473
 474 /* Based on PathAddBackslashW from dlls/shlwapi/path.c */
 475 static LPWSTR myPathAddBackslashW( LPWSTR lpszPath )
 476 {
 477   size_t iLen;
 478
 479   if (!lpszPath || (iLen = lstrlenW(lpszPath)) >= MAX_PATH)
 480     return NULL;
 481
 482   if (iLen)
 483   {
 484     lpszPath += iLen;
 485     if (lpszPath[-1] != '\\')
 486     {
 487       *lpszPath++ = '\\';
 488       *lpszPath = '\0';
 489     }
 490   }
 491   return lpszPath;
 492 }
 493
 494 static void test_GetDisplayName(void)
 495 {
 496     BOOL result;
 497     HRESULT hr;
 498     HANDLE hTestFile;
 499     WCHAR wszTestFile[MAX_PATH], wszTestFile2[MAX_PATH];
 500     char szTestFile[MAX_PATH], szTestDir[MAX_PATH];
 501     DWORD attr;
 502     STRRET strret;
 503     LPSHELLFOLDER psfDesktop, psfPersonal;
 504     IUnknown *psfFile;
 505     SHITEMID emptyitem = { 0, { 0 } };
 506     LPITEMIDLIST pidlTestFile, pidlEmpty = (LPITEMIDLIST)&emptyitem;
 507     LPCITEMIDLIST pidlLast;
 508     static const CHAR szFileName[] = "winetest.foo";
 509     static const WCHAR wszFileName[] = { 'w','i','n','e','t','e','s','t','.','f','o','o',0 };
 510     static const WCHAR wszDirName[] = { 'w','i','n','e','t','e','s','t',0 };
 511
 512     /* I'm trying to figure if there is a functional difference between calling
 513      * SHGetPathFromIDListW and calling GetDisplayNameOf(SHGDN_FORPARSING) after
 514      * binding to the shellfolder. One thing I thought of was that perhaps
 515      * SHGetPathFromIDListW would be able to get the path to a file, which does
 516      * not exist anymore, while the other method wouldn't. It turns out there's
 517      * no functional difference in this respect.
 518      */
 519
 520     if(!pSHGetSpecialFolderPathA) {
 521         win_skip("SHGetSpecialFolderPathA is not available\n");
 522         return;
 523     }
 524
 525     /* First creating a directory in MyDocuments and a file in this directory. */
 526     result = pSHGetSpecialFolderPathA(NULL, szTestDir, CSIDL_PERSONAL, FALSE);
 527     ok(result, "SHGetSpecialFolderPathA failed! Last error: %u\n", GetLastError());
 528     if (!result) return;
 529
 530     /* Use ANSI file functions so this works on Windows 9x */
 531     lstrcatA(szTestDir, "\\winetest");
 532     CreateDirectoryA(szTestDir, NULL);
 533     attr=GetFileAttributesA(szTestDir);
 534     if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_DIRECTORY))
 535     {
 536         ok(0, "unable to create the '%s' directory\n", szTestDir);
 537         return;
 538     }
 539
 540     lstrcpyA(szTestFile, szTestDir);
 541     lstrcatA(szTestFile, "\\");
 542     lstrcatA(szTestFile, szFileName);
 543     hTestFile = CreateFileA(szTestFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 544     ok((hTestFile != INVALID_HANDLE_VALUE), "CreateFileA failed! Last error: %u\n", GetLastError());
 545     if (hTestFile == INVALID_HANDLE_VALUE) return;
 546     CloseHandle(hTestFile);
 547
 548     /* Getting an itemidlist for the file. */
 549     hr = SHGetDesktopFolder(&psfDesktop);
 550     ok(hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
 551     if (hr != S_OK) return;
 552
 553     MultiByteToWideChar(CP_ACP, 0, szTestFile, -1, wszTestFile, MAX_PATH);
 554
 555     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
 556     ok(hr == S_OK, "Desktop->ParseDisplayName failed! hr = %08x\n", hr);
 557     if (hr != S_OK) {
 558         IShellFolder_Release(psfDesktop);
 559         return;
 560     }
 561
 562     pidlLast = pILFindLastID(pidlTestFile);
 563     ok(pidlLast->mkid.cb >=76 ||
 564         broken(pidlLast->mkid.cb == 28) || /* W2K */
 565         broken(pidlLast->mkid.cb == 40), /* Win9x, WinME */
 566         "Expected pidl length of at least 76, got %d.\n", pidlLast->mkid.cb);
 567     if (pidlLast->mkid.cb >= 28) {
 568         ok(!lstrcmpA((CHAR*)&pidlLast->mkid.abID[12], szFileName),
 569             "Filename should be stored as ansi-string at this position!\n");
 570     }
 571     /* WinXP and up store the filenames as both ANSI and UNICODE in the pidls */
 572     if (pidlLast->mkid.cb >= 76) {
 573         ok(!lstrcmpW((WCHAR*)&pidlLast->mkid.abID[46], wszFileName) ||
 574             (pidlLast->mkid.cb >= 94 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[64], wszFileName)) ||  /* Vista */
 575             (pidlLast->mkid.cb >= 98 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[68], wszFileName)), /* Win7 */
 576             "Filename should be stored as wchar-string at this position!\n");
 577     }
 578
 579     /* It seems as if we cannot bind to regular files on windows, but only directories.
 580      */
 581     hr = IShellFolder_BindToObject(psfDesktop, pidlTestFile, NULL, &IID_IUnknown, (VOID**)&psfFile);
 582     todo_wine
 583     ok (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 584         hr == E_NOTIMPL || /* Vista */
 585         broken(hr == S_OK), /* Win9x, W2K */
 586         "hr = %08x\n", hr);
 587     if (hr == S_OK) {
 588         IShellFolder_Release(psfFile);
 589     }
 590
 591     if (!pSHBindToParent)
 592     {
 593         win_skip("SHBindToParent is missing\n");
 594         DeleteFileA(szTestFile);
 595         RemoveDirectoryA(szTestDir);
 596         return;
 597     }
 598
 599     /* Some tests for IShellFolder::SetNameOf */
 600     if (pSHGetFolderPathAndSubDirA)
 601     {
 602         hr = pSHBindToParent(pidlTestFile, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
 603         ok(hr == S_OK, "SHBindToParent failed! hr = %08x\n", hr);
 604         if (hr == S_OK) {
 605             /* It's ok to use this fixed path. Call will fail anyway. */
 606             WCHAR wszAbsoluteFilename[] = { 'C',':','\\','w','i','n','e','t','e','s','t', 0 };
 607             LPITEMIDLIST pidlNew;
 608
 609             /* The pidl returned through the last parameter of SetNameOf is a simple one. */
 610             hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlLast, wszDirName, SHGDN_NORMAL, &pidlNew);
 611             ok (hr == S_OK, "SetNameOf failed! hr = %08x\n", hr);
 612             if (hr == S_OK)
 613             {
 614                 ok (((LPITEMIDLIST)((LPBYTE)pidlNew+pidlNew->mkid.cb))->mkid.cb == 0,
 615                     "pidl returned from SetNameOf should be simple!\n");
 616
 617                 /* Passing an absolute path to SetNameOf fails. The HRESULT code indicates that SetNameOf
 618                  * is implemented on top of SHFileOperation in WinXP. */
 619                 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszAbsoluteFilename,
 620                         SHGDN_FORPARSING, NULL);
 621                 ok (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED), "SetNameOf succeeded! hr = %08x\n", hr);
 622
 623                 /* Rename the file back to its original name. SetNameOf ignores the fact, that the
 624                  * SHGDN flags specify an absolute path. */
 625                 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszFileName, SHGDN_FORPARSING, NULL);
 626                 ok (hr == S_OK, "SetNameOf failed! hr = %08x\n", hr);
 627
 628                 pILFree(pidlNew);
 629             }
 630
 631             IShellFolder_Release(psfPersonal);
 632         }
 633     }
 634     else
 635         win_skip("Avoid needs of interaction on Win2k\n");
 636
 637     /* Deleting the file and the directory */
 638     DeleteFileA(szTestFile);
 639     RemoveDirectoryA(szTestDir);
 640
 641     /* SHGetPathFromIDListW still works, although the file is not present anymore. */
 642     if (pSHGetPathFromIDListW)
 643     {
 644         result = pSHGetPathFromIDListW(pidlTestFile, wszTestFile2);
 645         ok (result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
 646         ok (!lstrcmpiW(wszTestFile, wszTestFile2), "SHGetPathFromIDListW returns incorrect path!\n");
 647     }
 648
 649     /* SHBindToParent fails, if called with a NULL PIDL. */
 650     hr = pSHBindToParent(NULL, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
 651     ok (hr != S_OK, "SHBindToParent(NULL) should fail!\n");
 652
 653     /* But it succeeds with an empty PIDL. */
 654     hr = pSHBindToParent(pidlEmpty, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
 655     ok (hr == S_OK, "SHBindToParent(empty PIDL) should succeed! hr = %08x\n", hr);
 656     ok (pidlLast == pidlEmpty, "The last element of an empty PIDL should be the PIDL itself!\n");
 657     if (hr == S_OK)
 658         IShellFolder_Release(psfPersonal);
 659
 660     /* Binding to the folder and querying the display name of the file also works. */
 661     hr = pSHBindToParent(pidlTestFile, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
 662     ok (hr == S_OK, "SHBindToParent failed! hr = %08x\n", hr);
 663     if (hr != S_OK) {
 664         IShellFolder_Release(psfDesktop);
 665         return;
 666     }
 667
 668     /* This test shows that Windows doesn't allocate a new pidlLast, but returns a pointer into
 669      * pidlTestFile (In accordance with MSDN). */
 670     ok (pILFindLastID(pidlTestFile) == pidlLast,
 671                                 "SHBindToParent doesn't return the last id of the pidl param!\n");
 672
 673     hr = IShellFolder_GetDisplayNameOf(psfPersonal, pidlLast, SHGDN_FORPARSING, &strret);
 674     ok (hr == S_OK, "Personal->GetDisplayNameOf failed! hr = %08x\n", hr);
 675     if (hr != S_OK) {
 676         IShellFolder_Release(psfDesktop);
 677         IShellFolder_Release(psfPersonal);
 678         return;
 679     }
 680
 681     if (pStrRetToBufW)
 682     {
 683         hr = pStrRetToBufW(&strret, pidlLast, wszTestFile2, MAX_PATH);
 684         ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
 685         ok (!lstrcmpiW(wszTestFile, wszTestFile2), "GetDisplayNameOf returns incorrect path!\n");
 686     }
 687
 688     ILFree(pidlTestFile);
 689     IShellFolder_Release(psfDesktop);
 690     IShellFolder_Release(psfPersonal);
 691 }
 692
 693 static void test_CallForAttributes(void)
 694 {
 695     HKEY hKey;
 696     LONG lResult;
 697     HRESULT hr;
 698     DWORD dwSize;
 699     LPSHELLFOLDER psfDesktop;
 700     LPITEMIDLIST pidlMyDocuments;
 701     DWORD dwAttributes, dwCallForAttributes, dwOrigAttributes, dwOrigCallForAttributes;
 702     static const WCHAR wszAttributes[] = { 'A','t','t','r','i','b','u','t','e','s',0 };
 703     static const WCHAR wszCallForAttributes[] = {
 704         'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0 };
 705     static const WCHAR wszMyDocumentsKey[] = {
 706         'C','L','S','I','D','\\','{','4','5','0','D','8','F','B','A','-','A','D','2','5','-',
 707         '1','1','D','0','-','9','8','A','8','-','0','8','0','0','3','6','1','B','1','1','0','3','}',
 708         '\\','S','h','e','l','l','F','o','l','d','e','r',0 };
 709     WCHAR wszMyDocuments[] = {
 710         ':',':','{','4','5','0','D','8','F','B','A','-','A','D','2','5','-','1','1','D','0','-',
 711         '9','8','A','8','-','0','8','0','0','3','6','1','B','1','1','0','3','}',0 };
 712
 713     /* For the root of a namespace extension, the attributes are not queried by binding
 714      * to the object and calling GetAttributesOf. Instead, the attributes are read from
 715      * the registry value HKCR/CLSID/{...}/ShellFolder/Attributes. This is documented on MSDN.
 716      *
 717      * The MyDocuments shellfolder on WinXP has a HKCR/CLSID/{...}/ShellFolder/CallForAttributes
 718      * value. It seems that if the folder is queried for one of the flags set in CallForAttributes,
 719      * the shell does bind to the folder object and calls GetAttributesOf. This is not documented
 720      * on MSDN. This test is meant to document the observed behaviour on WinXP SP2.
 721      */
 722     hr = SHGetDesktopFolder(&psfDesktop);
 723     ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
 724     if (hr != S_OK) return;
 725
 726     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyDocuments, NULL,
 727                                        &pidlMyDocuments, NULL);
 728     ok (hr == S_OK ||
 729         broken(hr == E_INVALIDARG), /* Win95, NT4 */
 730         "Desktop's ParseDisplayName failed to parse MyDocuments's CLSID! hr = %08x\n", hr);
 731     if (hr != S_OK) {
 732         IShellFolder_Release(psfDesktop);
 733         return;
 734     }
 735
 736     dwAttributes = 0xffffffff;
 737     hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
 738                                       (LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
 739     ok (hr == S_OK, "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
 740
 741     /* We need the following setup (as observed on WinXP SP2), for the tests to make sense. */
 742     ok (dwAttributes & SFGAO_FILESYSTEM, "SFGAO_FILESYSTEM attribute is not set for MyDocuments!\n");
 743     ok (!(dwAttributes & SFGAO_ISSLOW), "SFGAO_ISSLOW attribute is set for MyDocuments!\n");
 744     ok (!(dwAttributes & SFGAO_GHOSTED), "SFGAO_GHOSTED attribute is set for MyDocuments!\n");
 745
 746     /* We don't have the MyDocuments shellfolder in wine yet, and thus we don't have the registry
 747      * key. So the test will return at this point, if run on wine.
 748      */
 749     lResult = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszMyDocumentsKey, 0, KEY_WRITE|KEY_READ, &hKey);
 750     ok (lResult == ERROR_SUCCESS ||
 751         lResult == ERROR_ACCESS_DENIED,
 752         "RegOpenKeyEx failed! result: %08x\n", lResult);
 753     if (lResult != ERROR_SUCCESS) {
 754         if (lResult == ERROR_ACCESS_DENIED)
 755             skip("Not enough rights to open the registry key\n");
 756         IMalloc_Free(ppM, pidlMyDocuments);
 757         IShellFolder_Release(psfDesktop);
 758         return;
 759     }
 760
 761     /* Query MyDocuments' Attributes value, to be able to restore it later. */
 762     dwSize = sizeof(DWORD);
 763     lResult = RegQueryValueExW(hKey, wszAttributes, NULL, NULL, (LPBYTE)&dwOrigAttributes, &dwSize);
 764     ok (lResult == ERROR_SUCCESS, "RegQueryValueEx failed! result: %08x\n", lResult);
 765     if (lResult != ERROR_SUCCESS) {
 766         RegCloseKey(hKey);
 767         IMalloc_Free(ppM, pidlMyDocuments);
 768         IShellFolder_Release(psfDesktop);
 769         return;
 770     }
 771
 772     /* Query MyDocuments' CallForAttributes value, to be able to restore it later. */
 773     dwSize = sizeof(DWORD);
 774     lResult = RegQueryValueExW(hKey, wszCallForAttributes, NULL, NULL,
 775                               (LPBYTE)&dwOrigCallForAttributes, &dwSize);
 776     ok (lResult == ERROR_SUCCESS, "RegQueryValueEx failed! result: %08x\n", lResult);
 777     if (lResult != ERROR_SUCCESS) {
 778         RegCloseKey(hKey);
 779         IMalloc_Free(ppM, pidlMyDocuments);
 780         IShellFolder_Release(psfDesktop);
 781         return;
 782     }
 783
 784     /* Define via the Attributes value that MyDocuments attributes are SFGAO_ISSLOW and
 785      * SFGAO_GHOSTED and that MyDocuments should be called for the SFGAO_ISSLOW and
 786      * SFGAO_FILESYSTEM attributes. */
 787     dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED;
 788     RegSetValueExW(hKey, wszAttributes, 0, REG_DWORD, (LPBYTE)&dwAttributes, sizeof(DWORD));
 789     dwCallForAttributes = SFGAO_ISSLOW|SFGAO_FILESYSTEM;
 790     RegSetValueExW(hKey, wszCallForAttributes, 0, REG_DWORD,
 791                    (LPBYTE)&dwCallForAttributes, sizeof(DWORD));
 792
 793     /* Although it is not set in CallForAttributes, the SFGAO_GHOSTED flag is reset by
 794      * GetAttributesOf. It seems that once there is a single attribute queried, for which
 795      * CallForAttributes is set, all flags are taken from the GetAttributesOf call and
 796      * the flags in Attributes are ignored.
 797      */
 798     dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED|SFGAO_FILESYSTEM;
 799     hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
 800                                       (LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
 801     ok (hr == S_OK, "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
 802     if (hr == S_OK)
 803         ok (dwAttributes == SFGAO_FILESYSTEM,
 804             "Desktop->GetAttributes(MyDocuments) returned unexpected attributes: %08x\n",
 805             dwAttributes);
 806
 807     /* Restore MyDocuments' original Attributes and CallForAttributes registry values */
 808     RegSetValueExW(hKey, wszAttributes, 0, REG_DWORD, (LPBYTE)&dwOrigAttributes, sizeof(DWORD));
 809     RegSetValueExW(hKey, wszCallForAttributes, 0, REG_DWORD,
 810                    (LPBYTE)&dwOrigCallForAttributes, sizeof(DWORD));
 811     RegCloseKey(hKey);
 812     IMalloc_Free(ppM, pidlMyDocuments);
 813     IShellFolder_Release(psfDesktop);
 814 }
 815
 816 static void test_GetAttributesOf(void)
 817 {
 818     HRESULT hr;
 819     LPSHELLFOLDER psfDesktop, psfMyComputer;
 820     SHITEMID emptyitem = { 0, { 0 } };
 821     LPCITEMIDLIST pidlEmpty = (LPCITEMIDLIST)&emptyitem;
 822     LPITEMIDLIST pidlMyComputer;
 823     DWORD dwFlags;
 824     static const DWORD desktopFlags[] = {
 825         /* WinXP */
 826         SFGAO_STORAGE | SFGAO_HASPROPSHEET | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSANCESTOR |
 827         SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER,
 828         /* Win2k */
 829         SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_STREAM | SFGAO_FILESYSANCESTOR |
 830         SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER,
 831         /* WinMe, Win9x, WinNT*/
 832         SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSANCESTOR |
 833         SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER
 834     };
 835     static const DWORD myComputerFlags[] = {
 836         /* WinXP */
 837         SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
 838         SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER,
 839         /* Win2k */
 840         SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_STREAM |
 841         SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER,
 842         /* WinMe, Win9x, WinNT */
 843         SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_FILESYSANCESTOR |
 844         SFGAO_FOLDER | SFGAO_HASSUBFOLDER,
 845         /* Win95, WinNT when queried directly */
 846         SFGAO_CANLINK | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_FILESYSANCESTOR |
 847         SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER
 848     };
 849     WCHAR wszMyComputer[] = {
 850         ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
 851         'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
 852     char  cCurrDirA [MAX_PATH] = {0};
 853     WCHAR cCurrDirW [MAX_PATH];
 854     static WCHAR cTestDirW[] = {'t','e','s','t','d','i','r',0};
 855     IShellFolder *IDesktopFolder, *testIShellFolder;
 856     ITEMIDLIST *newPIDL;
 857     int len, i;
 858     BOOL foundFlagsMatch;
 859
 860     hr = SHGetDesktopFolder(&psfDesktop);
 861     ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
 862     if (hr != S_OK) return;
 863
 864     /* The Desktop attributes can be queried with a single empty itemidlist, .. */
 865     dwFlags = 0xffffffff;
 866     hr = IShellFolder_GetAttributesOf(psfDesktop, 1, &pidlEmpty, &dwFlags);
 867     ok (hr == S_OK, "Desktop->GetAttributesOf(empty pidl) failed! hr = %08x\n", hr);
 868     for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
 869          i < sizeof(desktopFlags) / sizeof(desktopFlags[0]); i++)
 870     {
 871         if (desktopFlags[i] == dwFlags)
 872             foundFlagsMatch = TRUE;
 873     }
 874     ok (foundFlagsMatch, "Wrong Desktop attributes: %08x\n", dwFlags);
 875
 876     /* .. or with no itemidlist at all. */
 877     dwFlags = 0xffffffff;
 878     hr = IShellFolder_GetAttributesOf(psfDesktop, 0, NULL, &dwFlags);
 879     ok (hr == S_OK, "Desktop->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
 880     for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
 881          i < sizeof(desktopFlags) / sizeof(desktopFlags[0]); i++)
 882     {
 883         if (desktopFlags[i] == dwFlags)
 884             foundFlagsMatch = TRUE;
 885     }
 886     ok (foundFlagsMatch, "Wrong Desktop attributes: %08x\n", dwFlags);
 887
 888     /* Testing the attributes of the MyComputer shellfolder */
 889     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
 890     ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
 891     if (hr != S_OK) {
 892         IShellFolder_Release(psfDesktop);
 893         return;
 894     }
 895
 896     /* Windows sets the SFGAO_CANLINK flag, when MyComputer is queried via the Desktop
 897      * folder object. It doesn't do this, if MyComputer is queried directly (see below).
 898      */
 899     dwFlags = 0xffffffff;
 900     hr = IShellFolder_GetAttributesOf(psfDesktop, 1, (LPCITEMIDLIST*)&pidlMyComputer, &dwFlags);
 901     ok (hr == S_OK, "Desktop->GetAttributesOf(MyComputer) failed! hr = %08x\n", hr);
 902     for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
 903          i < sizeof(myComputerFlags) / sizeof(myComputerFlags[0]); i++)
 904     {
 905         if ((myComputerFlags[i] | SFGAO_CANLINK) == dwFlags)
 906             foundFlagsMatch = TRUE;
 907     }
 908     todo_wine
 909     ok (foundFlagsMatch, "Wrong MyComputer attributes: %08x\n", dwFlags);
 910
 911     hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
 912     ok (hr == S_OK, "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
 913     IShellFolder_Release(psfDesktop);
 914     IMalloc_Free(ppM, pidlMyComputer);
 915     if (hr != S_OK) return;
 916
 917     hr = IShellFolder_GetAttributesOf(psfMyComputer, 1, &pidlEmpty, &dwFlags);
 918     todo_wine
 919     ok (hr == E_INVALIDARG ||
 920         broken(hr == S_OK), /* W2K and earlier */
 921         "MyComputer->GetAttributesOf(emtpy pidl) should fail! hr = %08x\n", hr);
 922
 923     dwFlags = 0xffffffff;
 924     hr = IShellFolder_GetAttributesOf(psfMyComputer, 0, NULL, &dwFlags);
 925     ok (hr == S_OK, "MyComputer->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
 926     for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
 927          i < sizeof(myComputerFlags) / sizeof(myComputerFlags[0]); i++)
 928     {
 929         if (myComputerFlags[i] == dwFlags)
 930             foundFlagsMatch = TRUE;
 931     }
 932     todo_wine
 933     ok (foundFlagsMatch, "Wrong MyComputer attributes: %08x\n", dwFlags);
 934
 935     IShellFolder_Release(psfMyComputer);
 936
 937     GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
 938     len = lstrlenA(cCurrDirA);
 939
 940     if (len == 0) {
 941         win_skip("GetCurrentDirectoryA returned empty string. Skipping test_GetAttributesOf\n");
 942         return;
 943     }
 944     if (len > 3 && cCurrDirA[len-1] == '\\')
 945         cCurrDirA[len-1] = 0;
 946
 947     /* create test directory */
 948     CreateFilesFolders();
 949
 950     MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
 951
 952     hr = SHGetDesktopFolder(&IDesktopFolder);
 953     ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
 954
 955     hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
 956     ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
 957
 958     hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
 959     ok(hr == S_OK, "BindToObject failed %08x\n", hr);
 960
 961     IMalloc_Free(ppM, newPIDL);
 962
 963     /* get relative PIDL */
 964     hr = IShellFolder_ParseDisplayName(testIShellFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
 965     ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
 966
 967     /* test the shell attributes of the test directory using the relative PIDL */
 968     dwFlags = SFGAO_FOLDER;
 969     hr = IShellFolder_GetAttributesOf(testIShellFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
 970     ok (hr == S_OK, "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
 971     ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for relative PIDL: %08x\n", dwFlags);
 972
 973     /* free memory */
 974     IMalloc_Free(ppM, newPIDL);
 975
 976     /* append testdirectory name to path */
 977     if (cCurrDirA[len-1] == '\\')
 978         cCurrDirA[len-1] = 0;
 979     lstrcatA(cCurrDirA, "\\testdir");
 980     MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
 981
 982     hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
 983     ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
 984
 985     /* test the shell attributes of the test directory using the absolute PIDL */
 986     dwFlags = SFGAO_FOLDER;
 987     hr = IShellFolder_GetAttributesOf(IDesktopFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
 988     ok (hr == S_OK, "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
 989     ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for absolute PIDL: %08x\n", dwFlags);
 990
 991     /* free memory */
 992     IMalloc_Free(ppM, newPIDL);
 993
 994     IShellFolder_Release(testIShellFolder);
 995
 996     Cleanup();
 997
 998     IShellFolder_Release(IDesktopFolder);
 999 }
1000
1001 static void test_SHGetPathFromIDList(void)
1002 {
1003     SHITEMID emptyitem = { 0, { 0 } };
1004     LPCITEMIDLIST pidlEmpty = (LPCITEMIDLIST)&emptyitem;
1005     LPITEMIDLIST pidlMyComputer;
1006     WCHAR wszPath[MAX_PATH], wszDesktop[MAX_PATH];
1007     BOOL result;
1008     HRESULT hr;
1009     LPSHELLFOLDER psfDesktop;
1010     WCHAR wszMyComputer[] = {
1011         ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
1012         'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
1013     WCHAR wszFileName[MAX_PATH];
1014     LPITEMIDLIST pidlTestFile;
1015     HANDLE hTestFile;
1016     STRRET strret;
1017     static WCHAR wszTestFile[] = {
1018         'w','i','n','e','t','e','s','t','.','f','o','o',0 };
1019     LPITEMIDLIST pidlPrograms;
1020
1021     if(!pSHGetPathFromIDListW || !pSHGetSpecialFolderPathW)
1022     {
1023         win_skip("SHGetPathFromIDListW() or SHGetSpecialFolderPathW() is missing\n");
1024         return;
1025     }
1026
1027     /* Calling SHGetPathFromIDListW with no pidl should return the empty string */
1028     wszPath[0] = 'a';
1029     wszPath[1] = '\0';
1030     result = pSHGetPathFromIDListW(NULL, wszPath);
1031     ok(!result, "Expected failure\n");
1032     ok(!wszPath[0], "Expected empty string\n");
1033
1034     /* Calling SHGetPathFromIDListW with an empty pidl should return the desktop folder's path. */
1035     result = pSHGetSpecialFolderPathW(NULL, wszDesktop, CSIDL_DESKTOP, FALSE);
1036     ok(result, "SHGetSpecialFolderPathW(CSIDL_DESKTOP) failed! Last error: %u\n", GetLastError());
1037     if (!result) return;
1038
1039     /* Check if we are on Win9x */
1040     SetLastError(0xdeadbeef);
1041     lstrcmpiW(wszDesktop, wszDesktop);
1042     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1043     {
1044         win_skip("Most W-calls are not implemented\n");
1045         return;
1046     }
1047
1048     result = pSHGetPathFromIDListW(pidlEmpty, wszPath);
1049     ok(result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
1050     if (!result) return;
1051     ok(!lstrcmpiW(wszDesktop, wszPath), "SHGetPathFromIDListW didn't return desktop path for empty pidl!\n");
1052
1053     /* MyComputer does not map to a filesystem path. SHGetPathFromIDListW should fail. */
1054     hr = SHGetDesktopFolder(&psfDesktop);
1055     ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
1056     if (hr != S_OK) return;
1057
1058     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
1059     ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
1060     if (hr != S_OK) {
1061         IShellFolder_Release(psfDesktop);
1062         return;
1063     }
1064
1065     SetLastError(0xdeadbeef);
1066     wszPath[0] = 'a';
1067     wszPath[1] = '\0';
1068     result = pSHGetPathFromIDListW(pidlMyComputer, wszPath);
1069     ok (!result, "SHGetPathFromIDListW succeeded where it shouldn't!\n");
1070     ok (GetLastError()==0xdeadbeef ||
1071         GetLastError()==ERROR_SUCCESS, /* Vista and higher */
1072         "Unexpected last error from SHGetPathFromIDListW: %u\n", GetLastError());
1073     ok (!wszPath[0], "Expected empty path\n");
1074     if (result) {
1075         IShellFolder_Release(psfDesktop);
1076         return;
1077     }
1078
1079     IMalloc_Free(ppM, pidlMyComputer);
1080
1081     result = pSHGetSpecialFolderPathW(NULL, wszFileName, CSIDL_DESKTOPDIRECTORY, FALSE);
1082     ok(result, "SHGetSpecialFolderPathW failed! Last error: %u\n", GetLastError());
1083     if (!result) {
1084         IShellFolder_Release(psfDesktop);
1085         return;
1086     }
1087     myPathAddBackslashW(wszFileName);
1088     lstrcatW(wszFileName, wszTestFile);
1089     hTestFile = CreateFileW(wszFileName, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL);
1090     ok(hTestFile != INVALID_HANDLE_VALUE, "CreateFileW failed! Last error: %u\n", GetLastError());
1091     if (hTestFile == INVALID_HANDLE_VALUE) {
1092         IShellFolder_Release(psfDesktop);
1093         return;
1094     }
1095     CloseHandle(hTestFile);
1096
1097     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
1098     ok (hr == S_OK, "Desktop's ParseDisplayName failed to parse filename hr = %08x\n", hr);
1099     if (hr != S_OK) {
1100         IShellFolder_Release(psfDesktop);
1101         DeleteFileW(wszFileName);
1102         IMalloc_Free(ppM, pidlTestFile);
1103         return;
1104     }
1105
1106     /* This test is to show that the Desktop shellfolder prepends the CSIDL_DESKTOPDIRECTORY
1107      * path for files placed on the desktop, if called with SHGDN_FORPARSING. */
1108     hr = IShellFolder_GetDisplayNameOf(psfDesktop, pidlTestFile, SHGDN_FORPARSING, &strret);
1109     ok (hr == S_OK, "Desktop's GetDisplayNamfOf failed! hr = %08x\n", hr);
1110     IShellFolder_Release(psfDesktop);
1111     DeleteFileW(wszFileName);
1112     if (hr != S_OK) {
1113         IMalloc_Free(ppM, pidlTestFile);
1114         return;
1115     }
1116     if (pStrRetToBufW)
1117     {
1118         pStrRetToBufW(&strret, pidlTestFile, wszPath, MAX_PATH);
1119         ok(0 == lstrcmpW(wszFileName, wszPath),
1120            "Desktop->GetDisplayNameOf(pidlTestFile, SHGDN_FORPARSING) "
1121            "returned incorrect path for file placed on desktop\n");
1122     }
1123
1124     result = pSHGetPathFromIDListW(pidlTestFile, wszPath);
1125     ok(result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
1126     IMalloc_Free(ppM, pidlTestFile);
1127     if (!result) return;
1128     ok(0 == lstrcmpW(wszFileName, wszPath), "SHGetPathFromIDListW returned incorrect path for file placed on desktop\n");
1129
1130
1131     /* Test if we can get the path from the start menu "program files" PIDL. */
1132     hr = pSHGetSpecialFolderLocation(NULL, CSIDL_PROGRAM_FILES, &pidlPrograms);
1133     ok(hr == S_OK, "SHGetFolderLocation failed: 0x%08x\n", hr);
1134
1135     SetLastError(0xdeadbeef);
1136     result = pSHGetPathFromIDListW(pidlPrograms, wszPath);
1137         IMalloc_Free(ppM, pidlPrograms);
1138     ok(result, "SHGetPathFromIDListW failed\n");
1139 }
1140
1141 static void test_EnumObjects_and_CompareIDs(void)
1142 {
1143     ITEMIDLIST *newPIDL;
1144     IShellFolder *IDesktopFolder, *testIShellFolder;
1145     char  cCurrDirA [MAX_PATH] = {0};
1146     static const CHAR cTestDirA[] = "\\testdir";
1147     WCHAR cTestDirW[MAX_PATH];
1148     int len;
1149     HRESULT hr;
1150
1151     GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1152     len = lstrlenA(cCurrDirA);
1153
1154     if(len == 0) {
1155         win_skip("GetCurrentDirectoryA returned empty string. Skipping test_EnumObjects_and_CompareIDs\n");
1156         return;
1157     }
1158     if(cCurrDirA[len-1] == '\\')
1159         cCurrDirA[len-1] = 0;
1160
1161     lstrcatA(cCurrDirA, cTestDirA);
1162     MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cTestDirW, MAX_PATH);
1163
1164     hr = SHGetDesktopFolder(&IDesktopFolder);
1165     ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1166
1167     CreateFilesFolders();
1168
1169     hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
1170     ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1171
1172     hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1173     ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1174
1175     test_EnumObjects(testIShellFolder);
1176
1177     IShellFolder_Release(testIShellFolder);
1178
1179     Cleanup();
1180
1181     IMalloc_Free(ppM, newPIDL);
1182
1183     IShellFolder_Release(IDesktopFolder);
1184 }
1185
1186 /* A simple implementation of an IPropertyBag, which returns fixed values for
1187  * 'Target' and 'Attributes' properties.
1188  */
1189 static HRESULT WINAPI InitPropertyBag_IPropertyBag_QueryInterface(IPropertyBag *iface, REFIID riid,
1190     void **ppvObject)
1191 {
1192     if (!ppvObject)
1193         return E_INVALIDARG;
1194
1195     if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPropertyBag, riid)) {
1196         *ppvObject = iface;
1197     } else {
1198         ok (FALSE, "InitPropertyBag asked for unknown interface!\n");
1199         return E_NOINTERFACE;
1200     }
1201
1202     IPropertyBag_AddRef(iface);
1203     return S_OK;
1204 }
1205
1206 static ULONG WINAPI InitPropertyBag_IPropertyBag_AddRef(IPropertyBag *iface) {
1207     return 2;
1208 }
1209
1210 static ULONG WINAPI InitPropertyBag_IPropertyBag_Release(IPropertyBag *iface) {
1211     return 1;
1212 }
1213
1214 static HRESULT WINAPI InitPropertyBag_IPropertyBag_Read(IPropertyBag *iface, LPCOLESTR pszPropName,
1215     VARIANT *pVar, IErrorLog *pErrorLog)
1216 {
1217     static const WCHAR wszTargetSpecialFolder[] = {
1218         'T','a','r','g','e','t','S','p','e','c','i','a','l','F','o','l','d','e','r',0 };
1219     static const WCHAR wszTarget[] = {
1220         'T','a','r','g','e','t',0 };
1221     static const WCHAR wszAttributes[] = {
1222         'A','t','t','r','i','b','u','t','e','s',0 };
1223     static const WCHAR wszResolveLinkFlags[] = {
1224         'R','e','s','o','l','v','e','L','i','n','k','F','l','a','g','s',0 };
1225     static const WCHAR wszTargetKnownFolder[] = {
1226         'T','a','r','g','e','t','K','n','o','w','n','F','o','l','d','e','r',0 };
1227     static const WCHAR wszCLSID[] = {
1228         'C','L','S','I','D',0 };
1229
1230     if (!lstrcmpW(pszPropName, wszTargetSpecialFolder)) {
1231         ok(V_VT(pVar) == VT_I4 ||
1232            broken(V_VT(pVar) == VT_BSTR),   /* Win2k */
1233            "Wrong variant type for 'TargetSpecialFolder' property!\n");
1234         return E_INVALIDARG;
1235     }
1236
1237     if (!lstrcmpW(pszPropName, wszResolveLinkFlags))
1238     {
1239         ok(V_VT(pVar) == VT_UI4, "Wrong variant type for 'ResolveLinkFlags' property!\n");
1240         return E_INVALIDARG;
1241     }
1242
1243     if (!lstrcmpW(pszPropName, wszTarget)) {
1244         WCHAR wszPath[MAX_PATH];
1245         BOOL result;
1246
1247         ok(V_VT(pVar) == VT_BSTR ||
1248            broken(V_VT(pVar) == VT_EMPTY),  /* Win2k */
1249            "Wrong variant type for 'Target' property!\n");
1250         if (V_VT(pVar) != VT_BSTR) return E_INVALIDARG;
1251
1252         result = pSHGetSpecialFolderPathW(NULL, wszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
1253         ok(result, "SHGetSpecialFolderPathW(DESKTOPDIRECTORY) failed! %u\n", GetLastError());
1254         if (!result) return E_INVALIDARG;
1255
1256         V_BSTR(pVar) = SysAllocString(wszPath);
1257         return S_OK;
1258     }
1259
1260     if (!lstrcmpW(pszPropName, wszAttributes)) {
1261         ok(V_VT(pVar) == VT_UI4, "Wrong variant type for 'Attributes' property!\n");
1262         if (V_VT(pVar) != VT_UI4) return E_INVALIDARG;
1263         V_UI4(pVar) = SFGAO_FOLDER|SFGAO_HASSUBFOLDER|SFGAO_FILESYSANCESTOR|
1264                       SFGAO_CANRENAME|SFGAO_FILESYSTEM;
1265         return S_OK;
1266     }
1267
1268     if (!lstrcmpW(pszPropName, wszTargetKnownFolder)) {
1269         ok(V_VT(pVar) == VT_BSTR, "Wrong variant type for 'TargetKnownFolder' property!\n");
1270         /* TODO */
1271         return E_INVALIDARG;
1272     }
1273
1274     if (!lstrcmpW(pszPropName, wszCLSID)) {
1275         ok(V_VT(pVar) == VT_EMPTY, "Wrong variant type for 'CLSID' property!\n");
1276         /* TODO */
1277         return E_INVALIDARG;
1278     }
1279
1280     ok(FALSE, "PropertyBag was asked for unknown property %s (vt=%d)!\n", wine_dbgstr_w(pszPropName), V_VT(pVar));
1281     return E_INVALIDARG;
1282 }
1283
1284 static HRESULT WINAPI InitPropertyBag_IPropertyBag_Write(IPropertyBag *iface, LPCOLESTR pszPropName,
1285     VARIANT *pVar)
1286 {
1287     ok(FALSE, "Unexpected call to IPropertyBag_Write\n");
1288     return E_NOTIMPL;
1289 }
1290
1291 static const IPropertyBagVtbl InitPropertyBag_IPropertyBagVtbl = {
1292     InitPropertyBag_IPropertyBag_QueryInterface,
1293     InitPropertyBag_IPropertyBag_AddRef,
1294     InitPropertyBag_IPropertyBag_Release,
1295     InitPropertyBag_IPropertyBag_Read,
1296     InitPropertyBag_IPropertyBag_Write
1297 };
1298
1299 static struct IPropertyBag InitPropertyBag = {
1300     &InitPropertyBag_IPropertyBagVtbl
1301 };
1302
1303 static void test_FolderShortcut(void) {
1304     IPersistPropertyBag *pPersistPropertyBag;
1305     IShellFolder *pShellFolder, *pDesktopFolder;
1306     IPersistFolder3 *pPersistFolder3;
1307     HRESULT hr;
1308     STRRET strret;
1309     WCHAR wszDesktopPath[MAX_PATH], wszBuffer[MAX_PATH];
1310     BOOL result;
1311     CLSID clsid;
1312     LPITEMIDLIST pidlCurrentFolder, pidlWineTestFolder, pidlSubFolder;
1313     HKEY hShellExtKey;
1314     WCHAR wszWineTestFolder[] = {
1315         ':',':','{','9','B','3','5','2','E','B','F','-','2','7','6','5','-','4','5','C','1','-',
1316         'B','4','C','6','-','8','5','C','C','7','F','7','A','B','C','6','4','}',0 };
1317     WCHAR wszShellExtKey[] = { 'S','o','f','t','w','a','r','e','\\',
1318         'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
1319         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1320         'E','x','p','l','o','r','e','r','\\','D','e','s','k','t','o','p','\\',
1321         'N','a','m','e','S','p','a','c','e','\\',
1322         '{','9','b','3','5','2','e','b','f','-','2','7','6','5','-','4','5','c','1','-',
1323         'b','4','c','6','-','8','5','c','c','7','f','7','a','b','c','6','4','}',0 };
1324
1325     WCHAR wszSomeSubFolder[] = { 'S','u','b','F','o','l','d','e','r', 0};
1326     static const GUID CLSID_UnixDosFolder =
1327         {0x9d20aae8, 0x0625, 0x44b0, {0x9c, 0xa7, 0x71, 0x88, 0x9c, 0x22, 0x54, 0xd9}};
1328
1329     if (!pSHGetSpecialFolderPathW || !pStrRetToBufW) {
1330         win_skip("SHGetSpecialFolderPathW and/or StrRetToBufW are not available\n");
1331         return;
1332     }
1333
1334     if (!pSHGetFolderPathAndSubDirA)
1335     {
1336         win_skip("FolderShortcut test doesn't work on Win2k\n");
1337         return;
1338     }
1339
1340     /* These tests basically show, that CLSID_FolderShortcuts are initialized
1341      * via their IPersistPropertyBag interface. And that the target folder
1342      * is taken from the IPropertyBag's 'Target' property.
1343      */
1344     hr = CoCreateInstance(&CLSID_FolderShortcut, NULL, CLSCTX_INPROC_SERVER,
1345                           &IID_IPersistPropertyBag, (LPVOID*)&pPersistPropertyBag);
1346     if (hr == REGDB_E_CLASSNOTREG) {
1347         win_skip("CLSID_FolderShortcut is not implemented\n");
1348         return;
1349     }
1350     ok (hr == S_OK, "CoCreateInstance failed! hr = 0x%08x\n", hr);
1351     if (hr != S_OK) return;
1352
1353     hr = IPersistPropertyBag_Load(pPersistPropertyBag, &InitPropertyBag, NULL);
1354     ok(hr == S_OK, "IPersistPropertyBag_Load failed! hr = %08x\n", hr);
1355     if (hr != S_OK) {
1356         IPersistPropertyBag_Release(pPersistPropertyBag);
1357         return;
1358     }
1359
1360     hr = IPersistPropertyBag_QueryInterface(pPersistPropertyBag, &IID_IShellFolder,
1361                                             (LPVOID*)&pShellFolder);
1362     IPersistPropertyBag_Release(pPersistPropertyBag);
1363     ok(hr == S_OK, "IPersistPropertyBag_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
1364     if (hr != S_OK) return;
1365
1366     hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
1367     ok(hr == S_OK, "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
1368     if (hr != S_OK) {
1369         IShellFolder_Release(pShellFolder);
1370         return;
1371     }
1372
1373     result = pSHGetSpecialFolderPathW(NULL, wszDesktopPath, CSIDL_DESKTOPDIRECTORY, FALSE);
1374     ok(result, "SHGetSpecialFolderPathW(CSIDL_DESKTOPDIRECTORY) failed! %u\n", GetLastError());
1375     if (!result) return;
1376
1377     pStrRetToBufW(&strret, NULL, wszBuffer, MAX_PATH);
1378     ok(!lstrcmpiW(wszDesktopPath, wszBuffer), "FolderShortcut returned incorrect folder!\n");
1379
1380     hr = IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder3, (LPVOID*)&pPersistFolder3);
1381     IShellFolder_Release(pShellFolder);
1382     ok(hr == S_OK, "IShellFolder_QueryInterface(IID_IPersistFolder3 failed! hr = 0x%08x\n", hr);
1383     if (hr != S_OK) return;
1384
1385     hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
1386     ok(hr == S_OK, "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
1387     ok(IsEqualCLSID(&clsid, &CLSID_FolderShortcut), "Unexpected CLSID!\n");
1388
1389     hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
1390     todo_wine ok(hr == S_FALSE, "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
1391     ok(!pidlCurrentFolder, "IPersistFolder3_GetCurFolder should return a NULL pidl!\n");
1392
1393     /* For FolderShortcut objects, the Initialize method initialized the folder's position in the
1394      * shell namespace. The target folder, read from the property bag above, remains untouched.
1395      * The following tests show this: The itemidlist for some imaginary shellfolder object
1396      * is created and the FolderShortcut is initialized with it. GetCurFolder now returns this
1397      * itemidlist, but GetDisplayNameOf still returns the path from above.
1398      */
1399     hr = SHGetDesktopFolder(&pDesktopFolder);
1400     ok (hr == S_OK, "SHGetDesktopFolder failed! hr = %08x\n", hr);
1401     if (hr != S_OK) return;
1402
1403     /* Temporarily register WineTestFolder as a shell namespace extension at the Desktop.
1404      * Otherwise ParseDisplayName fails on WinXP with E_INVALIDARG */
1405     RegCreateKeyW(HKEY_CURRENT_USER, wszShellExtKey, &hShellExtKey);
1406     RegCloseKey(hShellExtKey);
1407     hr = IShellFolder_ParseDisplayName(pDesktopFolder, NULL, NULL, wszWineTestFolder, NULL,
1408                                        &pidlWineTestFolder, NULL);
1409     RegDeleteKeyW(HKEY_CURRENT_USER, wszShellExtKey);
1410     IShellFolder_Release(pDesktopFolder);
1411     ok (hr == S_OK, "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
1412     if (hr != S_OK) return;
1413
1414     hr = IPersistFolder3_Initialize(pPersistFolder3, pidlWineTestFolder);
1415     ok (hr == S_OK, "IPersistFolder3::Initialize failed! hr = %08x\n", hr);
1416     if (hr != S_OK) {
1417         IPersistFolder3_Release(pPersistFolder3);
1418         pILFree(pidlWineTestFolder);
1419         return;
1420     }
1421
1422     hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
1423     ok(hr == S_OK, "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
1424     ok(pILIsEqual(pidlCurrentFolder, pidlWineTestFolder),
1425         "IPersistFolder3_GetCurFolder should return pidlWineTestFolder!\n");
1426     pILFree(pidlCurrentFolder);
1427     pILFree(pidlWineTestFolder);
1428
1429     hr = IPersistFolder3_QueryInterface(pPersistFolder3, &IID_IShellFolder, (LPVOID*)&pShellFolder);
1430     IPersistFolder3_Release(pPersistFolder3);
1431     ok(hr == S_OK, "IPersistFolder3_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
1432     if (hr != S_OK) return;
1433
1434     hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
1435     ok(hr == S_OK, "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
1436     if (hr != S_OK) {
1437         IShellFolder_Release(pShellFolder);
1438         return;
1439     }
1440
1441     pStrRetToBufW(&strret, NULL, wszBuffer, MAX_PATH);
1442     ok(!lstrcmpiW(wszDesktopPath, wszBuffer), "FolderShortcut returned incorrect folder!\n");
1443
1444     /* Next few lines are meant to show that children of FolderShortcuts are not FolderShortcuts,
1445      * but ShellFSFolders. */
1446     myPathAddBackslashW(wszDesktopPath);
1447     lstrcatW(wszDesktopPath, wszSomeSubFolder);
1448     if (!CreateDirectoryW(wszDesktopPath, NULL)) {
1449         IShellFolder_Release(pShellFolder);
1450         return;
1451     }
1452
1453     hr = IShellFolder_ParseDisplayName(pShellFolder, NULL, NULL, wszSomeSubFolder, NULL,
1454                                        &pidlSubFolder, NULL);
1455     RemoveDirectoryW(wszDesktopPath);
1456     ok (hr == S_OK, "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
1457     if (hr != S_OK) {
1458         IShellFolder_Release(pShellFolder);
1459         return;
1460     }
1461
1462     hr = IShellFolder_BindToObject(pShellFolder, pidlSubFolder, NULL, &IID_IPersistFolder3,
1463                                    (LPVOID*)&pPersistFolder3);
1464     IShellFolder_Release(pShellFolder);
1465     pILFree(pidlSubFolder);
1466     ok (hr == S_OK, "IShellFolder::BindToObject failed! hr = %08x\n", hr);
1467     if (hr != S_OK)
1468         return;
1469
1470     /* On windows, we expect CLSID_ShellFSFolder. On wine we relax this constraint
1471      * a little bit and also allow CLSID_UnixDosFolder. */
1472     hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
1473     ok(hr == S_OK, "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
1474     ok(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder) || IsEqualCLSID(&clsid, &CLSID_UnixDosFolder),
1475         "IPersistFolder3::GetClassID returned unexpected CLSID!\n");
1476
1477     IPersistFolder3_Release(pPersistFolder3);
1478 }
1479
1480 #include "pshpack1.h"
1481 struct FileStructA {
1482     BYTE  type;
1483     BYTE  dummy;
1484     DWORD dwFileSize;
1485     WORD  uFileDate;    /* In our current implementation this is */
1486     WORD  uFileTime;    /* FileTimeToDosDate(WIN32_FIND_DATA->ftLastWriteTime) */
1487     WORD  uFileAttribs;
1488     CHAR  szName[1];
1489 };
1490
1491 struct FileStructW {
1492     WORD  cbLen;        /* Length of this element. */
1493     BYTE  abFooBar1[6]; /* Beyond any recognition. */
1494     WORD  uDate;        /* FileTimeToDosDate(WIN32_FIND_DATA->ftCreationTime)? */
1495     WORD  uTime;        /* (this is currently speculation) */
1496     WORD  uDate2;       /* FileTimeToDosDate(WIN32_FIND_DATA->ftLastAccessTime)? */
1497     WORD  uTime2;       /* (this is currently speculation) */
1498     BYTE  abFooBar2[4]; /* Beyond any recognition. */
1499     WCHAR wszName[1];   /* The long filename in unicode. */
1500     /* Just for documentation: Right after the unicode string: */
1501     WORD  cbOffset;     /* FileStructW's offset from the beginning of the SHITMEID.
1502                          * SHITEMID->cb == uOffset + cbLen */
1503 };
1504 #include "poppack.h"
1505
1506 static void test_ITEMIDLIST_format(void) {
1507     WCHAR wszPersonal[MAX_PATH];
1508     LPSHELLFOLDER psfDesktop, psfPersonal;
1509     LPITEMIDLIST pidlPersonal, pidlFile;
1510     HANDLE hFile;
1511     HRESULT hr;
1512     BOOL bResult;
1513     WCHAR wszFile[3][17] = { { 'e','v','e','n','_',0 }, { 'o','d','d','_',0 },
1514         { 'l','o','n','g','e','r','_','t','h','a','n','.','8','_','3',0 } };
1515     int i;
1516
1517     if (!pSHGetSpecialFolderPathW) return;
1518
1519     bResult = pSHGetSpecialFolderPathW(NULL, wszPersonal, CSIDL_PERSONAL, FALSE);
1520     ok(bResult, "SHGetSpecialFolderPathW failed! Last error: %u\n", GetLastError());
1521     if (!bResult) return;
1522
1523     SetLastError(0xdeadbeef);
1524     bResult = SetCurrentDirectoryW(wszPersonal);
1525     if (!bResult && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
1526         win_skip("Most W-calls are not implemented\n");
1527         return;
1528     }
1529     ok(bResult, "SetCurrentDirectory failed! Last error: %u\n", GetLastError());
1530     if (!bResult) return;
1531
1532     hr = SHGetDesktopFolder(&psfDesktop);
1533     ok(hr == S_OK, "SHGetDesktopFolder failed! hr: %08x\n", hr);
1534     if (hr != S_OK) return;
1535
1536     hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszPersonal, NULL, &pidlPersonal, NULL);
1537     ok(hr == S_OK, "psfDesktop->ParseDisplayName failed! hr = %08x\n", hr);
1538     if (hr != S_OK) {
1539         IShellFolder_Release(psfDesktop);
1540         return;
1541     }
1542
1543     hr = IShellFolder_BindToObject(psfDesktop, pidlPersonal, NULL, &IID_IShellFolder,
1544         (LPVOID*)&psfPersonal);
1545     IShellFolder_Release(psfDesktop);
1546     pILFree(pidlPersonal);
1547     ok(hr == S_OK, "psfDesktop->BindToObject failed! hr = %08x\n", hr);
1548     if (hr != S_OK) return;
1549
1550     for (i=0; i<3; i++) {
1551         CHAR szFile[MAX_PATH];
1552         struct FileStructA *pFileStructA;
1553         WORD cbOffset;
1554
1555         WideCharToMultiByte(CP_ACP, 0, wszFile[i], -1, szFile, MAX_PATH, NULL, NULL);
1556
1557         hFile = CreateFileW(wszFile[i], GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_FLAG_WRITE_THROUGH, NULL);
1558         ok(hFile != INVALID_HANDLE_VALUE, "CreateFile failed! (%u)\n", GetLastError());
1559         if (hFile == INVALID_HANDLE_VALUE) {
1560             IShellFolder_Release(psfPersonal);
1561             return;
1562         }
1563         CloseHandle(hFile);
1564
1565         hr = IShellFolder_ParseDisplayName(psfPersonal, NULL, NULL, wszFile[i], NULL, &pidlFile, NULL);
1566         DeleteFileW(wszFile[i]);
1567         ok(hr == S_OK, "psfPersonal->ParseDisplayName failed! hr: %08x\n", hr);
1568         if (hr != S_OK) {
1569             IShellFolder_Release(psfPersonal);
1570             return;
1571         }
1572
1573         pFileStructA = (struct FileStructA *)pidlFile->mkid.abID;
1574         ok(pFileStructA->type == 0x32, "PIDLTYPE should be 0x32!\n");
1575         ok(pFileStructA->dummy == 0x00, "Dummy Byte should be 0x00!\n");
1576         ok(pFileStructA->dwFileSize == 0, "Filesize should be zero!\n");
1577
1578         if (i < 2) /* First two file names are already in valid 8.3 format */
1579             ok(!strcmp(szFile, (CHAR*)&pidlFile->mkid.abID[12]), "Wrong file name!\n");
1580         else
1581             /* WinXP stores a derived 8.3 dos name (LONGER~1.8_3) here. We probably
1582              * can't implement this correctly, since unix filesystems don't support
1583              * this nasty short/long filename stuff. So we'll probably stay with our
1584              * current habbit of storing the long filename here, which seems to work
1585              * just fine. */
1586             todo_wine
1587             ok(pidlFile->mkid.abID[18] == '~' ||
1588                broken(pidlFile->mkid.abID[34] == '~'),  /* Win2k */
1589                "Should be derived 8.3 name!\n");
1590
1591         if (i == 0) /* First file name has an even number of chars. No need for alignment. */
1592             ok(pidlFile->mkid.abID[12 + strlen(szFile) + 1] != '\0' ||
1593                broken(pidlFile->mkid.cb == 2 + 12 + strlen(szFile) + 1 + 1),    /* Win2k */
1594                 "Alignment byte, where there shouldn't be!\n");
1595
1596         if (i == 1) /* Second file name has an uneven number of chars => alignment byte */
1597             ok(pidlFile->mkid.abID[12 + strlen(szFile) + 1] == '\0',
1598                 "There should be an alignment byte, but isn't!\n");
1599
1600         /* The offset of the FileStructW member is stored as a WORD at the end of the pidl. */
1601         cbOffset = *(WORD*)(((LPBYTE)pidlFile)+pidlFile->mkid.cb-sizeof(WORD));
1602         ok ((cbOffset >= sizeof(struct FileStructA) &&
1603             cbOffset <= pidlFile->mkid.cb - sizeof(struct FileStructW)) ||
1604             broken(pidlFile->mkid.cb == 2 + 12 + strlen(szFile) + 1 + 1) ||     /* Win2k on short names */
1605             broken(pidlFile->mkid.cb == 2 + 12 + strlen(szFile) + 1 + 12 + 1),  /* Win2k on long names */
1606             "Wrong offset value (%d) stored at the end of the PIDL\n", cbOffset);
1607
1608         if (cbOffset >= sizeof(struct FileStructA) &&
1609             cbOffset <= pidlFile->mkid.cb - sizeof(struct FileStructW))
1610         {
1611             struct FileStructW *pFileStructW = (struct FileStructW *)(((LPBYTE)pidlFile)+cbOffset);
1612
1613             ok(pidlFile->mkid.cb == cbOffset + pFileStructW->cbLen,
1614                 "FileStructW's offset and length should add up to the PIDL's length!\n");
1615
1616             if (pidlFile->mkid.cb == cbOffset + pFileStructW->cbLen) {
1617                 /* Since we just created the file, time of creation,
1618                  * time of last access and time of last write access just be the same.
1619                  * These tests seem to fail sometimes (on WinXP), if the test is run again shortly
1620                  * after the first run. I do remember something with NTFS keeping the creation time
1621                  * if a file is deleted and then created again within a couple of seconds or so.
1622                  * Might be the reason. */
1623                 ok (pFileStructA->uFileDate == pFileStructW->uDate &&
1624                     pFileStructA->uFileTime == pFileStructW->uTime,
1625                     "Last write time should match creation time!\n");
1626
1627                 /* On FAT filesystems the last access time is midnight
1628                    local time, so the values of uDate2 and uTime2 will
1629                    depend on the local timezone.  If the times are exactly
1630                    equal then the dates should be identical for both FAT
1631                    and NTFS as no timezone is more than 1 day away from UTC.
1632                 */
1633                 if (pFileStructA->uFileTime == pFileStructW->uTime2)
1634                 {
1635                     ok (pFileStructA->uFileDate == pFileStructW->uDate2,
1636                         "Last write date and time should match last access date and time!\n");
1637                 }
1638                 else
1639                 {
1640                     /* Filesystem may be FAT. Check date within 1 day
1641                        and seconds are zero. */
1642                     trace ("Filesystem may be FAT. Performing less strict atime test.\n");
1643                     ok ((pFileStructW->uTime2 & 0x1F) == 0,
1644                         "Last access time on FAT filesystems should have zero seconds.\n");
1645                     /* TODO: Perform check for date being within one day.*/
1646                 }
1647
1648                 ok (!lstrcmpW(wszFile[i], pFileStructW->wszName) ||
1649                     !lstrcmpW(wszFile[i], (WCHAR *)(pFileStructW->abFooBar2 + 22)) || /* Vista */
1650                     !lstrcmpW(wszFile[i], (WCHAR *)(pFileStructW->abFooBar2 + 26)), /* Win7 */
1651                     "The filename should be stored in unicode at this position!\n");
1652             }
1653         }
1654
1655         pILFree(pidlFile);
1656     }
1657
1658     IShellFolder_Release(psfPersonal);
1659 }
1660
1661 static void test_SHGetFolderPathAndSubDirA(void)
1662 {
1663     HRESULT ret;
1664     BOOL delret;
1665     DWORD dwret;
1666     int i;
1667     static char wine[] = "wine";
1668     static char winetemp[] = "wine\\temp";
1669     static char appdata[MAX_PATH];
1670     static char testpath[MAX_PATH];
1671     static char toolongpath[MAX_PATH+1];
1672
1673     if(!pSHGetFolderPathAndSubDirA)
1674     {
1675         win_skip("SHGetFolderPathAndSubDirA not present!\n");
1676         return;
1677     }
1678
1679     if(!pSHGetFolderPathA) {
1680         win_skip("SHGetFolderPathA not present!\n");
1681         return;
1682     }
1683     if(FAILED(pSHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, appdata)))
1684     {
1685         win_skip("SHGetFolderPathA failed for CSIDL_LOCAL_APPDATA!\n");
1686         return;
1687     }
1688
1689     sprintf(testpath, "%s\\%s", appdata, winetemp);
1690     delret = RemoveDirectoryA(testpath);
1691     if(!delret && (ERROR_PATH_NOT_FOUND != GetLastError()) ) {
1692         win_skip("RemoveDirectoryA(%s) failed with error %u\n", testpath, GetLastError());
1693         return;
1694     }
1695
1696     sprintf(testpath, "%s\\%s", appdata, wine);
1697     delret = RemoveDirectoryA(testpath);
1698     if(!delret && (ERROR_PATH_NOT_FOUND != GetLastError()) && (ERROR_FILE_NOT_FOUND != GetLastError())) {
1699         win_skip("RemoveDirectoryA(%s) failed with error %u\n", testpath, GetLastError());
1700         return;
1701     }
1702
1703     /* test invalid second parameter */
1704     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | 0xff, NULL, SHGFP_TYPE_CURRENT, wine, testpath);
1705     ok(E_INVALIDARG == ret, "expected E_INVALIDARG, got  %x\n", ret);
1706
1707     /* test fourth parameter */
1708     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, 2, winetemp, testpath);
1709     switch(ret) {
1710         case S_OK: /* winvista */
1711             ok(!strncmp(appdata, testpath, strlen(appdata)),
1712                 "expected %s to start with %s\n", testpath, appdata);
1713             ok(!lstrcmpA(&testpath[1 + strlen(appdata)], winetemp),
1714                 "expected %s to end with %s\n", testpath, winetemp);
1715             break;
1716         case E_INVALIDARG: /* winxp, win2k3 */
1717             break;
1718         default:
1719             ok(0, "expected S_OK or E_INVALIDARG, got  %x\n", ret);
1720     }
1721
1722     /* test fifth parameter */
1723     testpath[0] = '\0';
1724     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, NULL, testpath);
1725     ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1726     ok(!lstrcmpA(appdata, testpath), "expected %s, got %s\n", appdata, testpath);
1727
1728     testpath[0] = '\0';
1729     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, "", testpath);
1730     ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1731     ok(!lstrcmpA(appdata, testpath), "expected %s, got %s\n", appdata, testpath);
1732
1733     testpath[0] = '\0';
1734     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, "\\", testpath);
1735     ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1736     ok(!lstrcmpA(appdata, testpath), "expected %s, got %s\n", appdata, testpath);
1737
1738     for(i=0; i< MAX_PATH; i++)
1739         toolongpath[i] = '0' + i % 10;
1740     toolongpath[MAX_PATH] = '\0';
1741     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, toolongpath, testpath);
1742     ok(HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) == ret,
1743         "expected %x, got %x\n", HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), ret);
1744
1745     testpath[0] = '\0';
1746     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, wine, NULL);
1747     ok((S_OK == ret) || (E_INVALIDARG == ret), "expected S_OK or E_INVALIDARG, got %x\n", ret);
1748
1749     /* test a not existing path */
1750     testpath[0] = '\0';
1751     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, winetemp, testpath);
1752     ok(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == ret,
1753         "expected %x, got %x\n", HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), ret);
1754
1755     /* create a directory inside a not existing directory */
1756     testpath[0] = '\0';
1757     ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_CREATE | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, winetemp, testpath);
1758     ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1759     ok(!strncmp(appdata, testpath, strlen(appdata)),
1760         "expected %s to start with %s\n", testpath, appdata);
1761     ok(!lstrcmpA(&testpath[1 + strlen(appdata)], winetemp),
1762         "expected %s to end with %s\n", testpath, winetemp);
1763     dwret = GetFileAttributes(testpath);
1764     ok(FILE_ATTRIBUTE_DIRECTORY | dwret, "expected %x to contain FILE_ATTRIBUTE_DIRECTORY\n", dwret);
1765
1766     /* cleanup */
1767     sprintf(testpath, "%s\\%s", appdata, winetemp);
1768     RemoveDirectoryA(testpath);
1769     sprintf(testpath, "%s\\%s", appdata, wine);
1770     RemoveDirectoryA(testpath);
1771 }
1772
1773 static void test_LocalizedNames(void)
1774 {
1775     static char cCurrDirA[MAX_PATH];
1776     WCHAR cCurrDirW[MAX_PATH], tempbufW[25];
1777     IShellFolder *IDesktopFolder, *testIShellFolder;
1778     ITEMIDLIST *newPIDL;
1779     int len;
1780     HRESULT hr;
1781     static char resourcefile[MAX_PATH];
1782     DWORD res;
1783     HANDLE file;
1784     STRRET strret;
1785
1786     static const char desktopini_contents1[] =
1787         "[.ShellClassInfo]\r\n"
1788         "LocalizedResourceName=@";
1789     static const char desktopini_contents2[] =
1790         ",-1\r\n";
1791     static WCHAR foldernameW[] = {'t','e','s','t','f','o','l','d','e','r',0};
1792     static const WCHAR folderdisplayW[] = {'F','o','l','d','e','r',' ','N','a','m','e',' ','R','e','s','o','u','r','c','e',0};
1793
1794     /* create folder with desktop.ini and localized name in GetModuleFileNameA(NULL) */
1795     CreateDirectoryA(".\\testfolder", NULL);
1796
1797     SetFileAttributesA(".\\testfolder", GetFileAttributesA(".\\testfolder")|FILE_ATTRIBUTE_SYSTEM);
1798
1799     GetModuleFileNameA(NULL, resourcefile, MAX_PATH);
1800
1801     file = CreateFileA(".\\testfolder\\desktop.ini", GENERIC_WRITE, 0, NULL,
1802                          CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1803     ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %i\n", GetLastError());
1804     ok(WriteFile(file, desktopini_contents1, strlen(desktopini_contents1), &res, NULL) &&
1805        WriteFile(file, resourcefile, strlen(resourcefile), &res, NULL) &&
1806        WriteFile(file, desktopini_contents2, strlen(desktopini_contents2), &res, NULL),
1807        "WriteFile failed %i\n", GetLastError());
1808     CloseHandle(file);
1809
1810     /* get IShellFolder for parent */
1811     GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1812     len = lstrlenA(cCurrDirA);
1813
1814     if (len == 0) {
1815         win_skip("GetCurrentDirectoryA returned empty string. Skipping test_LocalizedNames\n");
1816         goto cleanup;
1817     }
1818     if(cCurrDirA[len-1] == '\\')
1819         cCurrDirA[len-1] = 0;
1820
1821     MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
1822
1823     hr = SHGetDesktopFolder(&IDesktopFolder);
1824     ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1825
1826     hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
1827     ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1828
1829     hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1830     ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1831
1832     IMalloc_Free(ppM, newPIDL);
1833
1834     /* windows reads the display name from the resource */
1835     hr = IShellFolder_ParseDisplayName(testIShellFolder, NULL, NULL, foldernameW, NULL, &newPIDL, 0);
1836     ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1837
1838     hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER, &strret);
1839     ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1840
1841     if (hr == S_OK && pStrRetToBufW)
1842     {
1843         hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
1844         ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
1845         todo_wine
1846         ok (!lstrcmpiW(tempbufW, folderdisplayW) ||
1847             broken(!lstrcmpiW(tempbufW, foldernameW)), /* W2K */
1848             "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1849     }
1850
1851     /* editing name is also read from the resource */
1852     hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FOREDITING, &strret);
1853     ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1854
1855     if (hr == S_OK && pStrRetToBufW)
1856     {
1857         hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
1858         ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
1859         todo_wine
1860         ok (!lstrcmpiW(tempbufW, folderdisplayW) ||
1861             broken(!lstrcmpiW(tempbufW, foldernameW)), /* W2K */
1862             "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1863     }
1864
1865     /* parsing name is unchanged */
1866     hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FORPARSING, &strret);
1867     ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1868
1869     if (hr == S_OK && pStrRetToBufW)
1870     {
1871         hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
1872         ok (hr == S_OK, "StrRetToBufW failed! hr = %08x\n", hr);
1873         ok (!lstrcmpiW(tempbufW, foldernameW), "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1874     }
1875
1876     IShellFolder_Release(IDesktopFolder);
1877     IShellFolder_Release(testIShellFolder);
1878
1879     IMalloc_Free(ppM, newPIDL);
1880
1881 cleanup:
1882     DeleteFileA(".\\testfolder\\desktop.ini");
1883     SetFileAttributesA(".\\testfolder", GetFileAttributesA(".\\testfolder")&~FILE_ATTRIBUTE_SYSTEM);
1884     RemoveDirectoryA(".\\testfolder");
1885 }
1886
1887 static void test_SHCreateShellItem(void)
1888 {
1889     IShellItem *shellitem, *shellitem2;
1890     IPersistIDList *persistidl;
1891     LPITEMIDLIST pidl_cwd=NULL, pidl_testfile, pidl_abstestfile, pidl_test;
1892     HRESULT ret;
1893     char curdirA[MAX_PATH];
1894     WCHAR curdirW[MAX_PATH];
1895     WCHAR fnbufW[MAX_PATH];
1896     IShellFolder *desktopfolder=NULL, *currentfolder=NULL;
1897     static WCHAR testfileW[] = {'t','e','s','t','f','i','l','e',0};
1898
1899     GetCurrentDirectoryA(MAX_PATH, curdirA);
1900
1901     if (!pSHCreateShellItem)
1902     {
1903         win_skip("SHCreateShellItem isn't available\n");
1904         return;
1905     }
1906
1907     if (!lstrlenA(curdirA))
1908     {
1909         win_skip("GetCurrentDirectoryA returned empty string, skipping test_SHCreateShellItem\n");
1910         return;
1911     }
1912
1913     MultiByteToWideChar(CP_ACP, 0, curdirA, -1, curdirW, MAX_PATH);
1914
1915     ret = SHGetDesktopFolder(&desktopfolder);
1916     ok(SUCCEEDED(ret), "SHGetShellFolder returned %x\n", ret);
1917
1918     ret = IShellFolder_ParseDisplayName(desktopfolder, NULL, NULL, curdirW, NULL, &pidl_cwd, NULL);
1919     ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
1920
1921     ret = IShellFolder_BindToObject(desktopfolder, pidl_cwd, NULL, &IID_IShellFolder, (void**)&currentfolder);
1922     ok(SUCCEEDED(ret), "BindToObject returned %x\n", ret);
1923
1924     CreateTestFile(".\\testfile");
1925
1926     ret = IShellFolder_ParseDisplayName(currentfolder, NULL, NULL, testfileW, NULL, &pidl_testfile, NULL);
1927     ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
1928
1929     pidl_abstestfile = pILCombine(pidl_cwd, pidl_testfile);
1930
1931     ret = pSHCreateShellItem(NULL, NULL, NULL, &shellitem);
1932     ok(ret == E_INVALIDARG, "SHCreateShellItem returned %x\n", ret);
1933
1934     if (0) /* crashes on Windows XP */
1935     {
1936         pSHCreateShellItem(NULL, NULL, pidl_cwd, NULL);
1937         pSHCreateShellItem(pidl_cwd, NULL, NULL, &shellitem);
1938         pSHCreateShellItem(NULL, currentfolder, NULL, &shellitem);
1939         pSHCreateShellItem(pidl_cwd, currentfolder, NULL, &shellitem);
1940     }
1941
1942     ret = pSHCreateShellItem(NULL, NULL, pidl_cwd, &shellitem);
1943     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1944     if (SUCCEEDED(ret))
1945     {
1946         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1947         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1948         if (SUCCEEDED(ret))
1949         {
1950             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1951             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1952             if (SUCCEEDED(ret))
1953             {
1954                 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
1955                 pILFree(pidl_test);
1956             }
1957             IPersistIDList_Release(persistidl);
1958         }
1959         IShellItem_Release(shellitem);
1960     }
1961
1962     ret = pSHCreateShellItem(pidl_cwd, NULL, pidl_testfile, &shellitem);
1963     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1964     if (SUCCEEDED(ret))
1965     {
1966         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1967         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1968         if (SUCCEEDED(ret))
1969         {
1970             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1971             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1972             if (SUCCEEDED(ret))
1973             {
1974                 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
1975                 pILFree(pidl_test);
1976             }
1977             IPersistIDList_Release(persistidl);
1978         }
1979
1980         ret = IShellItem_GetParent(shellitem, &shellitem2);
1981         ok(SUCCEEDED(ret), "GetParent returned %x\n", ret);
1982         if (SUCCEEDED(ret))
1983         {
1984             ret = IShellItem_QueryInterface(shellitem2, &IID_IPersistIDList, (void**)&persistidl);
1985             ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1986             if (SUCCEEDED(ret))
1987             {
1988                 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1989                 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1990                 if (SUCCEEDED(ret))
1991                 {
1992                     ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
1993                     pILFree(pidl_test);
1994                 }
1995                 IPersistIDList_Release(persistidl);
1996             }
1997             IShellItem_Release(shellitem2);
1998         }
1999
2000         IShellItem_Release(shellitem);
2001     }
2002
2003     ret = pSHCreateShellItem(NULL, currentfolder, pidl_testfile, &shellitem);
2004     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2005     if (SUCCEEDED(ret))
2006     {
2007         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2008         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2009         if (SUCCEEDED(ret))
2010         {
2011             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2012             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2013             if (SUCCEEDED(ret))
2014             {
2015                 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2016                 pILFree(pidl_test);
2017             }
2018             IPersistIDList_Release(persistidl);
2019         }
2020         IShellItem_Release(shellitem);
2021     }
2022
2023     /* if a parent pidl and shellfolder are specified, the shellfolder is ignored */
2024     ret = pSHCreateShellItem(pidl_cwd, desktopfolder, pidl_testfile, &shellitem);
2025     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2026     if (SUCCEEDED(ret))
2027     {
2028         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2029         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2030         if (SUCCEEDED(ret))
2031         {
2032             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2033             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2034             if (SUCCEEDED(ret))
2035             {
2036                 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2037                 pILFree(pidl_test);
2038             }
2039             IPersistIDList_Release(persistidl);
2040         }
2041         IShellItem_Release(shellitem);
2042     }
2043
2044     ret = pSHCreateShellItem(NULL, desktopfolder, pidl_testfile, &shellitem);
2045     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2046     if (SUCCEEDED(ret))
2047     {
2048         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2049         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2050         if (SUCCEEDED(ret))
2051         {
2052             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2053             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2054             if (SUCCEEDED(ret))
2055             {
2056                 ok(ILIsEqual(pidl_testfile, pidl_test), "id lists are not equal\n");
2057                 pILFree(pidl_test);
2058             }
2059             IPersistIDList_Release(persistidl);
2060         }
2061         IShellItem_Release(shellitem);
2062     }
2063
2064     /* SHCreateItemFromParsingName */
2065     if(pSHCreateItemFromParsingName)
2066     {
2067         if(0)
2068         {
2069             /* Crashes under windows 7 */
2070             ret = pSHCreateItemFromParsingName(NULL, NULL, &IID_IShellItem, NULL);
2071         }
2072
2073         shellitem = (void*)0xdeadbeef;
2074         ret = pSHCreateItemFromParsingName(NULL, NULL, &IID_IShellItem, (void**)&shellitem);
2075         ok(ret == E_INVALIDARG, "SHCreateItemFromParsingName returned %x\n", ret);
2076         ok(shellitem == NULL, "shellitem was %p.\n", shellitem);
2077
2078         ret = pSHCreateItemFromParsingName(testfileW, NULL, &IID_IShellItem, (void**)&shellitem);
2079         ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2080            "SHCreateItemFromParsingName returned %x\n", ret);
2081         if(SUCCEEDED(ret)) IShellItem_Release(shellitem);
2082
2083         lstrcpyW(fnbufW, curdirW);
2084         myPathAddBackslashW(fnbufW);
2085         lstrcatW(fnbufW, testfileW);
2086
2087         ret = pSHCreateItemFromParsingName(fnbufW, NULL, &IID_IShellItem, (void**)&shellitem);
2088         ok(ret == S_OK, "SHCreateItemFromParsingName returned %x\n", ret);
2089         if(SUCCEEDED(ret))
2090         {
2091             LPWSTR tmp_fname;
2092             ret = IShellItem_GetDisplayName(shellitem, SIGDN_FILESYSPATH, &tmp_fname);
2093             ok(ret == S_OK, "GetDisplayName returned %x\n", ret);
2094             if(SUCCEEDED(ret))
2095             {
2096                 ok(!lstrcmpW(fnbufW, tmp_fname), "strings not equal\n");
2097                 CoTaskMemFree(tmp_fname);
2098             }
2099             IShellItem_Release(shellitem);
2100         }
2101     }
2102     else
2103         win_skip("No SHCreateItemFromParsingName\n");
2104
2105
2106     /* SHCreateItemFromIDList */
2107     if(pSHCreateItemFromIDList)
2108     {
2109         if(0)
2110         {
2111             /* Crashes under win7 */
2112             ret = pSHCreateItemFromIDList(NULL, &IID_IShellItem, NULL);
2113         }
2114
2115         ret = pSHCreateItemFromIDList(NULL, &IID_IShellItem, (void**)&shellitem);
2116         ok(ret == E_INVALIDARG, "SHCreateItemFromIDList returned %x\n", ret);
2117
2118         ret = pSHCreateItemFromIDList(pidl_cwd, &IID_IShellItem, (void**)&shellitem);
2119         ok(ret == S_OK, "SHCreateItemFromIDList returned %x\n", ret);
2120         if (SUCCEEDED(ret))
2121         {
2122             ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2123             ok(ret == S_OK, "QueryInterface returned %x\n", ret);
2124             if (SUCCEEDED(ret))
2125             {
2126                 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2127                 ok(ret == S_OK, "GetIDList returned %x\n", ret);
2128                 if (SUCCEEDED(ret))
2129                 {
2130                     ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
2131                     pILFree(pidl_test);
2132                 }
2133                 IPersistIDList_Release(persistidl);
2134             }
2135             IShellItem_Release(shellitem);
2136         }
2137
2138         ret = pSHCreateItemFromIDList(pidl_testfile, &IID_IShellItem, (void**)&shellitem);
2139         ok(ret == S_OK, "SHCreateItemFromIDList returned %x\n", ret);
2140         if (SUCCEEDED(ret))
2141         {
2142             ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2143             ok(ret == S_OK, "QueryInterface returned %x\n", ret);
2144             if (SUCCEEDED(ret))
2145             {
2146                 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2147                 ok(ret == S_OK, "GetIDList returned %x\n", ret);
2148                 if (SUCCEEDED(ret))
2149                 {
2150                     ok(ILIsEqual(pidl_testfile, pidl_test), "id lists are not equal\n");
2151                     pILFree(pidl_test);
2152                 }
2153                 IPersistIDList_Release(persistidl);
2154             }
2155             IShellItem_Release(shellitem);
2156         }
2157     }
2158     else
2159         win_skip("No SHCreateItemFromIDList\n");
2160
2161     DeleteFileA(".\\testfile");
2162     pILFree(pidl_abstestfile);
2163     pILFree(pidl_testfile);
2164     pILFree(pidl_cwd);
2165     IShellFolder_Release(currentfolder);
2166     IShellFolder_Release(desktopfolder);
2167 }
2168
2169 static void test_SHGetNameFromIDList(void)
2170 {
2171     IShellItem *shellitem;
2172     LPITEMIDLIST pidl;
2173     LPWSTR name_string;
2174     HRESULT hres;
2175     UINT i;
2176     static const DWORD flags[] = {
2177         SIGDN_NORMALDISPLAY, SIGDN_PARENTRELATIVEPARSING,
2178         SIGDN_DESKTOPABSOLUTEPARSING,SIGDN_PARENTRELATIVEEDITING,
2179         SIGDN_DESKTOPABSOLUTEEDITING, /*SIGDN_FILESYSPATH, SIGDN_URL, */
2180         SIGDN_PARENTRELATIVEFORADDRESSBAR,SIGDN_PARENTRELATIVE, -1234};
2181
2182     if(!pSHGetNameFromIDList)
2183     {
2184         win_skip("SHGetNameFromIDList missing.\n");
2185         return;
2186     }
2187
2188     /* These should be available on any platform that passed the above test. */
2189     ok(pSHCreateShellItem != NULL, "SHCreateShellItem missing.\n");
2190     ok(pSHBindToParent != NULL, "SHBindToParent missing.\n");
2191     ok(pSHGetSpecialFolderLocation != NULL, "SHGetSpecialFolderLocation missing.\n");
2192     ok(pStrRetToBufW != NULL, "StrRetToBufW missing.\n");
2193
2194     if(0)
2195     {
2196         /* Crashes under win7 */
2197         hres = pSHGetNameFromIDList(NULL, 0, NULL);
2198     }
2199
2200     hres = pSHGetNameFromIDList(NULL, 0, &name_string);
2201     ok(hres == E_INVALIDARG, "Got 0x%08x\n", hres);
2202
2203     /* Test the desktop */
2204     hres = pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl);
2205     ok(hres == S_OK, "Got 0x%08x\n", hres);
2206     hres = pSHCreateShellItem(NULL, NULL, pidl, &shellitem);
2207     ok(hres == S_OK, "Got 0x%08x\n", hres);
2208     if(SUCCEEDED(hres))
2209     {
2210         WCHAR *nameSI, *nameSH;
2211         WCHAR buf[MAX_PATH];
2212         HRESULT hrSI, hrSH, hrSF;
2213         STRRET strret;
2214         IShellFolder *psf;
2215         BOOL res;
2216
2217         SHGetDesktopFolder(&psf);
2218         for(i = 0; flags[i] != -1234; i++)
2219         {
2220             hrSI = IShellItem_GetDisplayName(shellitem, flags[i], &nameSI);
2221             ok(hrSI == S_OK, "Got 0x%08x\n", hrSI);
2222             hrSH = pSHGetNameFromIDList(pidl, flags[i], &nameSH);
2223             ok(hrSH == S_OK, "Got 0x%08x\n", hrSH);
2224             hrSF = IShellFolder_GetDisplayNameOf(psf, pidl, flags[i] & 0xffff, &strret);
2225             ok(hrSF == S_OK, "Got 0x%08x\n", hrSF);
2226
2227             if(SUCCEEDED(hrSI) && SUCCEEDED(hrSH))
2228                 ok(!lstrcmpW(nameSI, nameSH), "Strings differ.\n");
2229
2230             if(SUCCEEDED(hrSF))
2231             {
2232                 pStrRetToBufW(&strret, NULL, buf, MAX_PATH);
2233                 if(SUCCEEDED(hrSI))
2234                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2235                 if(SUCCEEDED(hrSF))
2236                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2237             }
2238             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2239             if(SUCCEEDED(hrSH)) CoTaskMemFree(nameSH);
2240         }
2241         IShellFolder_Release(psf);
2242
2243         if(pSHGetPathFromIDListW){
2244             hrSI = pSHGetNameFromIDList(pidl, SIGDN_FILESYSPATH, &nameSI);
2245             ok(hrSI == S_OK, "Got 0x%08x\n", hrSI);
2246             res = pSHGetPathFromIDListW(pidl, buf);
2247             ok(res == TRUE, "Got %d\n", res);
2248             if(SUCCEEDED(hrSI) && res)
2249                 ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2250             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2251         }else
2252             win_skip("pSHGetPathFromIDListW not available\n");
2253
2254         hres = pSHGetNameFromIDList(pidl, SIGDN_URL, &name_string);
2255         todo_wine ok(hres == S_OK, "Got 0x%08x\n", hres);
2256         if(SUCCEEDED(hres)) CoTaskMemFree(name_string);
2257
2258         IShellItem_Release(shellitem);
2259     }
2260     pILFree(pidl);
2261
2262     /* Test the control panel */
2263     hres = pSHGetSpecialFolderLocation(NULL, CSIDL_CONTROLS, &pidl);
2264     ok(hres == S_OK, "Got 0x%08x\n", hres);
2265     hres = pSHCreateShellItem(NULL, NULL, pidl, &shellitem);
2266     ok(hres == S_OK, "Got 0x%08x\n", hres);
2267     if(SUCCEEDED(hres))
2268     {
2269         WCHAR *nameSI, *nameSH;
2270         WCHAR buf[MAX_PATH];
2271         HRESULT hrSI, hrSH, hrSF;
2272         STRRET strret;
2273         IShellFolder *psf;
2274         BOOL res;
2275
2276         SHGetDesktopFolder(&psf);
2277         for(i = 0; flags[i] != -1234; i++)
2278         {
2279             hrSI = IShellItem_GetDisplayName(shellitem, flags[i], &nameSI);
2280             ok(hrSI == S_OK, "Got 0x%08x\n", hrSI);
2281             hrSH = pSHGetNameFromIDList(pidl, flags[i], &nameSH);
2282             ok(hrSH == S_OK, "Got 0x%08x\n", hrSH);
2283             hrSF = IShellFolder_GetDisplayNameOf(psf, pidl, flags[i] & 0xffff, &strret);
2284             ok(hrSF == S_OK, "Got 0x%08x\n", hrSF);
2285
2286             if(SUCCEEDED(hrSI) && SUCCEEDED(hrSH))
2287                 ok(!lstrcmpW(nameSI, nameSH), "Strings differ.\n");
2288
2289             if(SUCCEEDED(hrSF))
2290             {
2291                 pStrRetToBufW(&strret, NULL, buf, MAX_PATH);
2292                 if(SUCCEEDED(hrSI))
2293                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2294                 if(SUCCEEDED(hrSF))
2295                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2296             }
2297             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2298             if(SUCCEEDED(hrSH)) CoTaskMemFree(nameSH);
2299         }
2300         IShellFolder_Release(psf);
2301
2302         if(pSHGetPathFromIDListW){
2303             hrSI = pSHGetNameFromIDList(pidl, SIGDN_FILESYSPATH, &nameSI);
2304             ok(hrSI == E_INVALIDARG, "Got 0x%08x\n", hrSI);
2305             res = pSHGetPathFromIDListW(pidl, buf);
2306             ok(res == FALSE, "Got %d\n", res);
2307             if(SUCCEEDED(hrSI) && res)
2308                 ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2309             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2310         }else
2311             win_skip("pSHGetPathFromIDListW not available\n");
2312
2313         hres = pSHGetNameFromIDList(pidl, SIGDN_URL, &name_string);
2314         todo_wine ok(hres == E_NOTIMPL /* Win7 */ || hres == S_OK /* Vista */,
2315                      "Got 0x%08x\n", hres);
2316         if(SUCCEEDED(hres)) CoTaskMemFree(name_string);
2317
2318         IShellItem_Release(shellitem);
2319     }
2320     pILFree(pidl);
2321 }
2322
2323 static void test_SHGetItemFromDataObject(void)
2324 {
2325     IShellFolder *psfdesktop;
2326     IShellItem *psi;
2327     IShellView *psv;
2328     HRESULT hres;
2329
2330     if(!pSHGetItemFromDataObject)
2331     {
2332         win_skip("No SHGetItemFromDataObject.\n");
2333         return;
2334     }
2335
2336     if(0)
2337     {
2338         /* Crashes under win7 */
2339         hres = pSHGetItemFromDataObject(NULL, 0, &IID_IShellItem, NULL);
2340     }
2341
2342     hres = pSHGetItemFromDataObject(NULL, 0, &IID_IShellItem, (void**)&psv);
2343     ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
2344
2345     SHGetDesktopFolder(&psfdesktop);
2346
2347     hres = IShellFolder_CreateViewObject(psfdesktop, NULL, &IID_IShellView, (void**)&psv);
2348     ok(hres == S_OK, "got 0x%08x\n", hres);
2349     if(SUCCEEDED(hres))
2350     {
2351         IEnumIDList *peidl;
2352         IDataObject *pdo;
2353         SHCONTF enum_flags;
2354
2355         enum_flags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
2356         hres = IShellFolder_EnumObjects(psfdesktop, NULL, enum_flags, &peidl);
2357         ok(hres == S_OK, "got 0x%08x\n", hres);
2358         if(SUCCEEDED(hres))
2359         {
2360             LPITEMIDLIST apidl[5];
2361             UINT count = 0, i;
2362
2363             for(count = 0; count < 5; count++)
2364                 if(IEnumIDList_Next(peidl, 1, &apidl[count], NULL) != S_OK)
2365                     break;
2366
2367             if(count)
2368             {
2369                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, 1, (LPCITEMIDLIST*)apidl,
2370                                                   &IID_IDataObject, NULL, (void**)&pdo);
2371                 ok(hres == S_OK, "got 0x%08x\n", hres);
2372                 if(SUCCEEDED(hres))
2373                 {
2374                     hres = pSHGetItemFromDataObject(pdo, DOGIF_DEFAULT, &IID_IShellItem, (void**)&psi);
2375                     ok(hres == S_OK, "got 0x%08x\n", hres);
2376                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2377                     hres = pSHGetItemFromDataObject(pdo, DOGIF_TRAVERSE_LINK, &IID_IShellItem, (void**)&psi);
2378                     ok(hres == S_OK, "got 0x%08x\n", hres);
2379                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2380                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_HDROP, &IID_IShellItem, (void**)&psi);
2381                     ok(hres == S_OK, "got 0x%08x\n", hres);
2382                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2383                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_URL, &IID_IShellItem, (void**)&psi);
2384                     ok(hres == S_OK, "got 0x%08x\n", hres);
2385                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2386                     hres = pSHGetItemFromDataObject(pdo, DOGIF_ONLY_IF_ONE, &IID_IShellItem, (void**)&psi);
2387                     ok(hres == S_OK, "got 0x%08x\n", hres);
2388                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2389
2390                     IDataObject_Release(pdo);
2391                 }
2392             }
2393             else
2394                 skip("No file(s) found - skipping single-file test.\n");
2395
2396             if(count > 1)
2397             {
2398                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, count, (LPCITEMIDLIST*)apidl,
2399                                                   &IID_IDataObject, NULL, (void**)&pdo);
2400                 ok(hres == S_OK, "got 0x%08x\n", hres);
2401                 if(SUCCEEDED(hres))
2402                 {
2403                     hres = pSHGetItemFromDataObject(pdo, DOGIF_DEFAULT, &IID_IShellItem, (void**)&psi);
2404                     ok(hres == S_OK, "got 0x%08x\n", hres);
2405                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2406                     hres = pSHGetItemFromDataObject(pdo, DOGIF_TRAVERSE_LINK, &IID_IShellItem, (void**)&psi);
2407                     ok(hres == S_OK, "got 0x%08x\n", hres);
2408                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2409                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_HDROP, &IID_IShellItem, (void**)&psi);
2410                     ok(hres == S_OK, "got 0x%08x\n", hres);
2411                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2412                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_URL, &IID_IShellItem, (void**)&psi);
2413                     ok(hres == S_OK, "got 0x%08x\n", hres);
2414                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2415                     hres = pSHGetItemFromDataObject(pdo, DOGIF_ONLY_IF_ONE, &IID_IShellItem, (void**)&psi);
2416                     ok(hres == E_FAIL, "got 0x%08x\n", hres);
2417                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2418                     IDataObject_Release(pdo);
2419                 }
2420             }
2421             else
2422                 skip("zero or one file found - skipping multi-file test.\n");
2423
2424             for(i = 0; i < count; i++)
2425                 pILFree(apidl[i]);
2426
2427             IEnumIDList_Release(peidl);
2428         }
2429
2430         IShellView_Release(psv);
2431     }
2432
2433     IShellFolder_Release(psfdesktop);
2434 }
2435
2436 static void test_ShellItemCompare(void)
2437 {
2438     IShellItem *psi[9]; /* a\a, a\b, a\c, b\a, .. */
2439     IShellItem *psi_a, *psi_b, *psi_c;
2440     IShellFolder *psf_desktop, *psf_current;
2441     LPITEMIDLIST pidl_cwd;
2442     WCHAR curdirW[MAX_PATH];
2443     BOOL failed;
2444     HRESULT hr;
2445     static const WCHAR filesW[][9] = {
2446         {'a','\\','a',0}, {'a','\\','b',0}, {'a','\\','c',0},
2447         {'b','\\','a',0}, {'b','\\','b',0}, {'b','\\','c',0},
2448         {'c','\\','a',0}, {'c','\\','b',0}, {'c','\\','c',0} };
2449     int order;
2450     UINT i;
2451
2452     if(!pSHCreateShellItem)
2453     {
2454         win_skip("SHCreateShellItem missing.\n");
2455         return;
2456     }
2457
2458     GetCurrentDirectoryW(MAX_PATH, curdirW);
2459     if(!lstrlenW(curdirW))
2460     {
2461         skip("Failed to get current directory, skipping.\n");
2462         return;
2463     }
2464
2465     CreateDirectoryA(".\\a", NULL);
2466     CreateDirectoryA(".\\b", NULL);
2467     CreateDirectoryA(".\\c", NULL);
2468     CreateTestFile(".\\a\\a");
2469     CreateTestFile(".\\a\\b");
2470     CreateTestFile(".\\a\\c");
2471     CreateTestFile(".\\b\\a");
2472     CreateTestFile(".\\b\\b");
2473     CreateTestFile(".\\b\\c");
2474     CreateTestFile(".\\c\\a");
2475     CreateTestFile(".\\c\\b");
2476     CreateTestFile(".\\c\\c");
2477
2478     SHGetDesktopFolder(&psf_desktop);
2479     hr = IShellFolder_ParseDisplayName(psf_desktop, NULL, NULL, curdirW, NULL, &pidl_cwd, NULL);
2480     ok(SUCCEEDED(hr), "ParseDisplayName returned %x\n", hr);
2481     hr = IShellFolder_BindToObject(psf_desktop, pidl_cwd, NULL, &IID_IShellFolder, (void**)&psf_current);
2482     ok(SUCCEEDED(hr), "BindToObject returned %x\n", hr);
2483     IShellFolder_Release(psf_desktop);
2484
2485     /* Generate ShellItems for the files */
2486     ZeroMemory(&psi, sizeof(IShellItem*)*9);
2487     failed = FALSE;
2488     for(i = 0; i < 9; i++)
2489     {
2490         LPITEMIDLIST pidl_testfile = NULL;
2491
2492         hr = IShellFolder_ParseDisplayName(psf_current, NULL, NULL, (LPWSTR)filesW[i],
2493                                            NULL, &pidl_testfile, NULL);
2494         ok(SUCCEEDED(hr), "ParseDisplayName returned %x\n", hr);
2495         if(SUCCEEDED(hr))
2496         {
2497             hr = pSHCreateShellItem(NULL, NULL, pidl_testfile, &psi[i]);
2498             ok(hr == S_OK, "Got 0x%08x\n", hr);
2499             pILFree(pidl_testfile);
2500         }
2501         if(FAILED(hr)) failed = TRUE;
2502     }
2503     if(failed)
2504     {
2505         skip("Failed to create all shellitems. \n");
2506         goto cleanup;
2507     }
2508
2509     /* Generate ShellItems for the folders */
2510     psi_a = psi_b = psi_c = NULL;
2511     hr = IShellItem_GetParent(psi[0], &psi_a);
2512     ok(hr == S_OK, "Got 0x%08x\n", hr);
2513     if(FAILED(hr)) failed = TRUE;
2514     hr = IShellItem_GetParent(psi[3], &psi_b);
2515     ok(hr == S_OK, "Got 0x%08x\n", hr);
2516     if(FAILED(hr)) failed = TRUE;
2517     hr = IShellItem_GetParent(psi[6], &psi_c);
2518     ok(hr == S_OK, "Got 0x%08x\n", hr);
2519     if(FAILED(hr)) failed = TRUE;
2520
2521     if(failed)
2522     {
2523         skip("Failed to create shellitems. \n");
2524         goto cleanup;
2525     }
2526
2527     if(0)
2528     {
2529         /* Crashes on native (win7, winxp) */
2530         hr = IShellItem_Compare(psi_a, NULL, 0, NULL);
2531         hr = IShellItem_Compare(psi_a, psi_b, 0, NULL);
2532         hr = IShellItem_Compare(psi_a, NULL, 0, &order);
2533     }
2534
2535     /* Basics */
2536     for(i = 0; i < 9; i++)
2537     {
2538         hr = IShellItem_Compare(psi[i], psi[i], SICHINT_DISPLAY, &order);
2539         ok(hr == S_OK, "Got 0x%08x\n", hr);
2540         ok(order == 0, "Got order %d\n", order);
2541         hr = IShellItem_Compare(psi[i], psi[i], SICHINT_CANONICAL, &order);
2542         ok(hr == S_OK, "Got 0x%08x\n", hr);
2543         ok(order == 0, "Got order %d\n", order);
2544         hr = IShellItem_Compare(psi[i], psi[i], SICHINT_ALLFIELDS, &order);
2545         ok(hr == S_OK, "Got 0x%08x\n", hr);
2546         ok(order == 0, "Got order %d\n", order);
2547     }
2548
2549     /* Order */
2550     /* a\b:a\a , a\b:a\c, a\b:a\b */
2551     hr = IShellItem_Compare(psi[1], psi[0], SICHINT_DISPLAY, &order);
2552     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2553     ok(order == 1, "Got order %d\n", order);
2554     hr = IShellItem_Compare(psi[1], psi[2], SICHINT_DISPLAY, &order);
2555     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2556     ok(order == -1, "Got order %d\n", order);
2557     hr = IShellItem_Compare(psi[1], psi[1], SICHINT_DISPLAY, &order);
2558     ok(hr == S_OK, "Got 0x%08x\n", hr);
2559     ok(order == 0, "Got order %d\n", order);
2560
2561     /* b\b:a\b, b\b:c\b, b\b:c\b */
2562     hr = IShellItem_Compare(psi[4], psi[1], SICHINT_DISPLAY, &order);
2563     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2564     ok(order == 1, "Got order %d\n", order);
2565     hr = IShellItem_Compare(psi[4], psi[7], SICHINT_DISPLAY, &order);
2566     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2567     ok(order == -1, "Got order %d\n", order);
2568     hr = IShellItem_Compare(psi[4], psi[4], SICHINT_DISPLAY, &order);
2569     ok(hr == S_OK, "Got 0x%08x\n", hr);
2570     ok(order == 0, "Got order %d\n", order);
2571
2572     /* b:a\a, b:a\c, b:a\b */
2573     hr = IShellItem_Compare(psi_b, psi[0], SICHINT_DISPLAY, &order);
2574     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2575     todo_wine ok(order == 1, "Got order %d\n", order);
2576     hr = IShellItem_Compare(psi_b, psi[2], SICHINT_DISPLAY, &order);
2577     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2578     todo_wine ok(order == 1, "Got order %d\n", order);
2579     hr = IShellItem_Compare(psi_b, psi[1], SICHINT_DISPLAY, &order);
2580     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2581     todo_wine ok(order == 1, "Got order %d\n", order);
2582
2583     /* b:c\a, b:c\c, b:c\b */
2584     hr = IShellItem_Compare(psi_b, psi[6], SICHINT_DISPLAY, &order);
2585     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2586     ok(order == -1, "Got order %d\n", order);
2587     hr = IShellItem_Compare(psi_b, psi[8], SICHINT_DISPLAY, &order);
2588     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2589     ok(order == -1, "Got order %d\n", order);
2590     hr = IShellItem_Compare(psi_b, psi[7], SICHINT_DISPLAY, &order);
2591     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2592     ok(order == -1, "Got order %d\n", order);
2593
2594     /* a\b:a\a , a\b:a\c, a\b:a\b */
2595     hr = IShellItem_Compare(psi[1], psi[0], SICHINT_CANONICAL, &order);
2596     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2597     ok(order == 1, "Got order %d\n", order);
2598     hr = IShellItem_Compare(psi[1], psi[2], SICHINT_CANONICAL, &order);
2599     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2600     ok(order == -1, "Got order %d\n", order);
2601     hr = IShellItem_Compare(psi[1], psi[1], SICHINT_CANONICAL, &order);
2602     ok(hr == S_OK, "Got 0x%08x\n", hr);
2603     ok(order == 0, "Got order %d\n", order);
2604
2605     /* b\b:a\b, b\b:c\b, b\b:c\b */
2606     hr = IShellItem_Compare(psi[4], psi[1], SICHINT_CANONICAL, &order);
2607     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2608     ok(order == 1, "Got order %d\n", order);
2609     hr = IShellItem_Compare(psi[4], psi[7], SICHINT_CANONICAL, &order);
2610     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2611     ok(order == -1, "Got order %d\n", order);
2612     hr = IShellItem_Compare(psi[4], psi[4], SICHINT_CANONICAL, &order);
2613     ok(hr == S_OK, "Got 0x%08x\n", hr);
2614     ok(order == 0, "Got order %d\n", order);
2615
2616     /* b:a\a, b:a\c, b:a\b */
2617     hr = IShellItem_Compare(psi_b, psi[0], SICHINT_CANONICAL, &order);
2618     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2619     todo_wine ok(order == 1, "Got order %d\n", order);
2620     hr = IShellItem_Compare(psi_b, psi[2], SICHINT_CANONICAL, &order);
2621     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2622     todo_wine ok(order == 1, "Got order %d\n", order);
2623     hr = IShellItem_Compare(psi_b, psi[1], SICHINT_CANONICAL, &order);
2624     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2625     todo_wine ok(order == 1, "Got order %d\n", order);
2626
2627     /* b:c\a, b:c\c, b:c\b */
2628     hr = IShellItem_Compare(psi_b, psi[6], SICHINT_CANONICAL, &order);
2629     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2630     ok(order == -1, "Got order %d\n", order);
2631     hr = IShellItem_Compare(psi_b, psi[8], SICHINT_CANONICAL, &order);
2632     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2633     ok(order == -1, "Got order %d\n", order);
2634     hr = IShellItem_Compare(psi_b, psi[7], SICHINT_CANONICAL, &order);
2635     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2636     ok(order == -1, "Got order %d\n", order);
2637
2638 cleanup:
2639     IShellFolder_Release(psf_current);
2640
2641     DeleteFileA(".\\a\\a");
2642     DeleteFileA(".\\a\\b");
2643     DeleteFileA(".\\a\\c");
2644     DeleteFileA(".\\b\\a");
2645     DeleteFileA(".\\b\\b");
2646     DeleteFileA(".\\b\\c");
2647     DeleteFileA(".\\c\\a");
2648     DeleteFileA(".\\c\\b");
2649     DeleteFileA(".\\c\\c");
2650     RemoveDirectoryA(".\\a");
2651     RemoveDirectoryA(".\\b");
2652     RemoveDirectoryA(".\\c");
2653
2654     if(psi_a) IShellItem_Release(psi_a);
2655     if(psi_b) IShellItem_Release(psi_b);
2656     if(psi_c) IShellItem_Release(psi_c);
2657
2658     for(i = 0; i < 9; i++)
2659         if(psi[i]) IShellItem_Release(psi[i]);
2660 }
2661
2662 /**************************************************************/
2663 /* IUnknown implementation for counting QueryInterface calls. */
2664 typedef struct {
2665     const IUnknownVtbl *lpVtbl;
2666     struct if_count {
2667         REFIID id;
2668         LONG count;
2669     } *ifaces;
2670     LONG unknown;
2671 } IUnknownImpl;
2672
2673 static HRESULT WINAPI unk_fnQueryInterface(IUnknown *iunk, REFIID riid, void** punk)
2674 {
2675     IUnknownImpl *This = (IUnknownImpl*)iunk;
2676     UINT i, found;
2677     for(i = found = 0; This->ifaces[i].id != NULL; i++)
2678     {
2679         if(IsEqualIID(This->ifaces[i].id, riid))
2680         {
2681             This->ifaces[i].count++;
2682             found = 1;
2683             break;
2684         }
2685     }
2686     if(!found)
2687         This->unknown++;
2688     return E_NOINTERFACE;
2689 }
2690
2691 static ULONG WINAPI unk_fnAddRef(IUnknown *iunk)
2692 {
2693     return 2;
2694 }
2695
2696 static ULONG WINAPI unk_fnRelease(IUnknown *iunk)
2697 {
2698     return 1;
2699 }
2700
2701 const IUnknownVtbl vt_IUnknown = {
2702     unk_fnQueryInterface,
2703     unk_fnAddRef,
2704     unk_fnRelease
2705 };
2706
2707 static void test_SHGetIDListFromObject(void)
2708 {
2709     IUnknownImpl *punkimpl;
2710     IShellFolder *psfdesktop;
2711     IShellView *psv;
2712     LPITEMIDLIST pidl, pidl_desktop;
2713     HRESULT hres;
2714     UINT i;
2715     struct if_count ifaces[] =
2716         { {&IID_IPersistIDList, 0},
2717           {&IID_IPersistFolder2, 0},
2718           {&IID_IDataObject, 0},
2719           {&IID_IParentAndItem, 0},
2720           {&IID_IFolderView, 0},
2721           {NULL, 0} };
2722
2723     if(!pSHGetIDListFromObject)
2724     {
2725         win_skip("SHGetIDListFromObject missing.\n");
2726         return;
2727     }
2728
2729     ok(pSHGetSpecialFolderLocation != NULL, "SHGetSpecialFolderLocation missing.\n");
2730
2731     if(0)
2732     {
2733         /* Crashes native */
2734         pSHGetIDListFromObject(NULL, NULL);
2735         pSHGetIDListFromObject((void*)0xDEADBEEF, NULL);
2736     }
2737
2738     hres = pSHGetIDListFromObject(NULL, &pidl);
2739     ok(hres == E_NOINTERFACE, "Got %x\n", hres);
2740
2741     punkimpl = HeapAlloc(GetProcessHeap(), 0, sizeof(IUnknownImpl));
2742     punkimpl->lpVtbl = &vt_IUnknown;
2743     punkimpl->ifaces = ifaces;
2744     punkimpl->unknown = 0;
2745
2746     hres = pSHGetIDListFromObject((IUnknown*)punkimpl, &pidl);
2747     ok(hres == E_NOINTERFACE, "Got %x\n", hres);
2748     ok(ifaces[0].count, "interface not requested.\n");
2749     ok(ifaces[1].count, "interface not requested.\n");
2750     ok(ifaces[2].count, "interface not requested.\n");
2751     todo_wine
2752         ok(ifaces[3].count || broken(!ifaces[3].count /*vista*/),
2753            "interface not requested.\n");
2754     ok(ifaces[4].count || broken(!ifaces[4].count /*vista*/),
2755        "interface not requested.\n");
2756
2757     ok(!punkimpl->unknown, "Got %d unknown.\n", punkimpl->unknown);
2758     HeapFree(GetProcessHeap(), 0, punkimpl);
2759
2760     pidl_desktop = NULL;
2761     pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl_desktop);
2762     ok(pidl_desktop != NULL, "Failed to get desktop pidl.\n");
2763
2764     SHGetDesktopFolder(&psfdesktop);
2765
2766     /* Test IShellItem */
2767     if(pSHCreateShellItem)
2768     {
2769         IShellItem *shellitem;
2770         hres = pSHCreateShellItem(NULL, NULL, pidl_desktop, &shellitem);
2771         ok(hres == S_OK, "got 0x%08x\n", hres);
2772         if(SUCCEEDED(hres))
2773         {
2774             hres = pSHGetIDListFromObject((IUnknown*)shellitem, &pidl);
2775             ok(hres == S_OK, "got 0x%08x\n", hres);
2776             if(SUCCEEDED(hres))
2777             {
2778                 ok(ILIsEqual(pidl_desktop, pidl), "pidl not equal.\n");
2779                 pILFree(pidl);
2780             }
2781             IShellItem_Release(shellitem);
2782         }
2783     }
2784     else
2785         skip("no SHCreateShellItem.\n");
2786
2787     /* Test IShellFolder */
2788     hres = pSHGetIDListFromObject((IUnknown*)psfdesktop, &pidl);
2789     ok(hres == S_OK, "got 0x%08x\n", hres);
2790     if(SUCCEEDED(hres))
2791     {
2792         ok(ILIsEqual(pidl_desktop, pidl), "pidl not equal.\n");
2793         pILFree(pidl);
2794     }
2795
2796     hres = IShellFolder_CreateViewObject(psfdesktop, NULL, &IID_IShellView, (void**)&psv);
2797     ok(hres == S_OK, "got 0x%08x\n", hres);
2798     if(SUCCEEDED(hres))
2799     {
2800         IEnumIDList *peidl;
2801         IDataObject *pdo;
2802         SHCONTF enum_flags;
2803
2804         /* Test IFolderView */
2805         hres = pSHGetIDListFromObject((IUnknown*)psv, &pidl);
2806         ok(hres == S_OK, "got 0x%08x\n", hres);
2807         if(SUCCEEDED(hres))
2808         {
2809             ok(ILIsEqual(pidl_desktop, pidl), "pidl not equal.\n");
2810             pILFree(pidl);
2811         }
2812
2813         /* Test IDataObject */
2814         enum_flags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
2815         hres = IShellFolder_EnumObjects(psfdesktop, NULL, enum_flags, &peidl);
2816         ok(hres == S_OK, "got 0x%08x\n", hres);
2817         if(SUCCEEDED(hres))
2818         {
2819             LPITEMIDLIST apidl[5];
2820             UINT count = 0;
2821             for(count = 0; count < 5; count++)
2822                 if(IEnumIDList_Next(peidl, 1, &apidl[count], NULL) != S_OK)
2823                     break;
2824
2825             if(count)
2826             {
2827                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, 1, (LPCITEMIDLIST*)apidl,
2828                                                   &IID_IDataObject, NULL, (void**)&pdo);
2829                 ok(hres == S_OK, "got 0x%08x\n", hres);
2830                 if(SUCCEEDED(hres))
2831                 {
2832                     pidl = (void*)0xDEADBEEF;
2833                     hres = pSHGetIDListFromObject((IUnknown*)pdo, &pidl);
2834                     ok(hres == S_OK, "got 0x%08x\n", hres);
2835                     ok(pidl != NULL, "pidl is NULL.\n");
2836                     ok(ILIsEqual(pidl, apidl[0]), "pidl not equal.\n");
2837                     pILFree(pidl);
2838
2839                     IDataObject_Release(pdo);
2840                 }
2841             }
2842             else
2843                 skip("No files found - skipping single-file test.\n");
2844
2845             if(count > 1)
2846             {
2847                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, count, (LPCITEMIDLIST*)apidl,
2848                                                   &IID_IDataObject, NULL, (void**)&pdo);
2849                 ok(hres == S_OK, "got 0x%08x\n", hres);
2850                 if(SUCCEEDED(hres))
2851                 {
2852                     pidl = (void*)0xDEADBEEF;
2853                     hres = pSHGetIDListFromObject((IUnknown*)pdo, &pidl);
2854                     ok(hres == E_NOINTERFACE || hres == E_FAIL /*Vista*/,
2855                        "got 0x%08x\n", hres);
2856                     ok(pidl == NULL, "pidl is not NULL.\n");
2857
2858                     IDataObject_Release(pdo);
2859                 }
2860             }
2861             else
2862                 skip("zero or one file found - skipping multi-file test.\n");
2863
2864             for(i = 0; i < count; i++)
2865                 pILFree(apidl[i]);
2866
2867             IEnumIDList_Release(peidl);
2868         }
2869
2870         IShellView_Release(psv);
2871     }
2872
2873     IShellFolder_Release(psfdesktop);
2874     pILFree(pidl_desktop);
2875 }
2876
2877 static void test_SHGetItemFromObject(void)
2878 {
2879     IUnknownImpl *punkimpl;
2880     IShellFolder *psfdesktop;
2881     LPITEMIDLIST pidl;
2882     IShellItem *psi;
2883     IUnknown *punk;
2884     HRESULT hres;
2885     struct if_count ifaces[] =
2886         { {&IID_IPersistIDList, 0},
2887           {&IID_IPersistFolder2, 0},
2888           {&IID_IDataObject, 0},
2889           {&IID_IParentAndItem, 0},
2890           {&IID_IFolderView, 0},
2891           {NULL, 0} };
2892
2893     if(!pSHGetItemFromObject)
2894     {
2895         skip("No SHGetItemFromObject.\n");
2896         return;
2897     }
2898
2899     SHGetDesktopFolder(&psfdesktop);
2900
2901     if(0)
2902     {
2903         /* Crashes with Windows 7 */
2904         hres = pSHGetItemFromObject((IUnknown*)psfdesktop, &IID_IUnknown, (void**)NULL);
2905         hres = pSHGetItemFromObject(NULL, &IID_IUnknown, (void**)NULL);
2906         hres = pSHGetItemFromObject((IUnknown*)psfdesktop, NULL, (void**)&punk);
2907     }
2908
2909     hres = pSHGetItemFromObject(NULL, &IID_IUnknown, (void**)&punk);
2910     ok(hres == E_NOINTERFACE, "Got 0x%08x\n", hres);
2911
2912     punkimpl = HeapAlloc(GetProcessHeap(), 0, sizeof(IUnknownImpl));
2913     punkimpl->lpVtbl = &vt_IUnknown;
2914     punkimpl->ifaces = ifaces;
2915     punkimpl->unknown = 0;
2916
2917     /* The same as SHGetIDListFromObject */
2918     hres = pSHGetIDListFromObject((IUnknown*)punkimpl, &pidl);
2919     ok(hres == E_NOINTERFACE, "Got %x\n", hres);
2920     ok(ifaces[0].count, "interface not requested.\n");
2921     ok(ifaces[1].count, "interface not requested.\n");
2922     ok(ifaces[2].count, "interface not requested.\n");
2923     todo_wine
2924         ok(ifaces[3].count || broken(!ifaces[3].count /*vista*/),
2925            "interface not requested.\n");
2926     ok(ifaces[4].count || broken(!ifaces[4].count /*vista*/),
2927        "interface not requested.\n");
2928
2929     ok(!punkimpl->unknown, "Got %d unknown.\n", punkimpl->unknown);
2930     HeapFree(GetProcessHeap(), 0, punkimpl);
2931
2932     /* Test IShellItem */
2933     hres = pSHGetItemFromObject((IUnknown*)psfdesktop, &IID_IShellItem, (void**)&psi);
2934     ok(hres == S_OK, "Got 0x%08x\n", hres);
2935     if(SUCCEEDED(hres))
2936     {
2937         IShellItem *psi2;
2938         hres = pSHGetItemFromObject((IUnknown*)psi, &IID_IShellItem, (void**)&psi2);
2939         ok(hres == S_OK, "Got 0x%08x\n", hres);
2940         if(SUCCEEDED(hres))
2941         {
2942             todo_wine
2943                 ok(psi == psi2, "Different instances (%p != %p).\n", psi, psi2);
2944             IShellItem_Release(psi2);
2945         }
2946         IShellItem_Release(psi);
2947     }
2948
2949     IShellFolder_Release(psfdesktop);
2950 }
2951
2952 static void test_SHCreateShellItemArray(void)
2953 {
2954     IShellFolder *pdesktopsf, *psf;
2955     IShellItemArray *psia;
2956     IEnumIDList *peidl;
2957     HRESULT hr;
2958     WCHAR cTestDirW[MAX_PATH];
2959     LPITEMIDLIST pidl_testdir, pidl;
2960     static const WCHAR testdirW[] = {'t','e','s','t','d','i','r',0};
2961
2962     if(!pSHCreateShellItemArray) {
2963         skip("No pSHCreateShellItemArray!\n");
2964         return;
2965     }
2966
2967     ok(pSHGetSpecialFolderLocation != NULL, "SHGetSpecialFolderLocation missing.\n");
2968
2969     if(0)
2970     {
2971         /* Crashes under native */
2972         pSHCreateShellItemArray(NULL, NULL, 0, NULL, NULL);
2973         pSHCreateShellItemArray(NULL, NULL, 1, NULL, NULL);
2974         pSHCreateShellItemArray(NULL, pdesktopsf, 0, NULL, NULL);
2975         pSHCreateShellItemArray(pidl, NULL, 0, NULL, NULL);
2976     }
2977
2978     hr = pSHCreateShellItemArray(NULL, NULL, 0, NULL, &psia);
2979     ok(hr == E_POINTER, "got 0x%08x\n", hr);
2980
2981     SHGetDesktopFolder(&pdesktopsf);
2982     hr = pSHCreateShellItemArray(NULL, pdesktopsf, 0, NULL, &psia);
2983     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
2984
2985     hr = pSHCreateShellItemArray(NULL, pdesktopsf, 1, NULL, &psia);
2986     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
2987
2988     pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl);
2989     hr = pSHCreateShellItemArray(pidl, NULL, 0, NULL, &psia);
2990     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
2991     pILFree(pidl);
2992
2993     GetCurrentDirectoryW(MAX_PATH, cTestDirW);
2994     myPathAddBackslashW(cTestDirW);
2995     lstrcatW(cTestDirW, testdirW);
2996
2997     CreateFilesFolders();
2998
2999     hr = IShellFolder_ParseDisplayName(pdesktopsf, NULL, NULL, cTestDirW, NULL, &pidl_testdir, 0);
3000     ok(hr == S_OK, "got 0x%08x\n", hr);
3001     if(SUCCEEDED(hr))
3002     {
3003         hr = IShellFolder_BindToObject(pdesktopsf, pidl_testdir, NULL, (REFIID)&IID_IShellFolder,
3004                                        (void**)&psf);
3005         ok(hr == S_OK, "Got 0x%08x\n", hr);
3006     }
3007     IShellFolder_Release(pdesktopsf);
3008
3009     if(FAILED(hr))
3010     {
3011         skip("Failed to set up environment for SHCreateShellItemArray tests.\n");
3012         pILFree(pidl_testdir);
3013         Cleanup();
3014         return;
3015     }
3016
3017     hr = IShellFolder_EnumObjects(psf, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &peidl);
3018     ok(hr == S_OK, "Got %08x\n", hr);
3019     if(SUCCEEDED(hr))
3020     {
3021         LPITEMIDLIST apidl[5];
3022         UINT done, numitems, i;
3023
3024         for(done = 0; done < 5; done++)
3025             if(IEnumIDList_Next(peidl, 1, &apidl[done], NULL) != S_OK)
3026                 break;
3027         ok(done == 5, "Got %d pidls\n", done);
3028         IEnumIDList_Release(peidl);
3029
3030         /* Create a ShellItemArray */
3031         hr = pSHCreateShellItemArray(NULL, psf, done, (LPCITEMIDLIST*)apidl, &psia);
3032         ok(hr == S_OK, "Got 0x%08x\n", hr);
3033         if(SUCCEEDED(hr))
3034         {
3035             IShellItem *psi;
3036
3037             if(0)
3038             {
3039                 /* Crashes in Windows 7 */
3040                 hr = IShellItemArray_GetCount(psia, NULL);
3041             }
3042
3043             IShellItemArray_GetCount(psia, &numitems);
3044             ok(numitems == done, "Got %d, expected %d\n", numitems, done);
3045
3046             hr = IShellItemArray_GetItemAt(psia, numitems, &psi);
3047             ok(hr == E_FAIL, "Got 0x%08x\n", hr);
3048
3049             /* Compare all the items */
3050             for(i = 0; i < numitems; i++)
3051             {
3052                 LPITEMIDLIST pidl_abs;
3053                 pidl_abs = ILCombine(pidl_testdir, apidl[i]);
3054
3055                 hr = IShellItemArray_GetItemAt(psia, i, &psi);
3056                 ok(hr == S_OK, "(%d) Failed with 0x%08x\n", i, hr);
3057                 if(SUCCEEDED(hr))
3058                 {
3059                     hr = pSHGetIDListFromObject((IUnknown*)psi, &pidl);
3060                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3061                     if(SUCCEEDED(hr))
3062                     {
3063                         ok(ILIsEqual(pidl_abs, pidl), "Pidl not equal.\n");
3064                         pILFree(pidl);
3065                     }
3066                     IShellItem_Release(psi);
3067                 }
3068                 pILFree(pidl_abs);
3069             }
3070             for(i = 0; i < done; i++)
3071                 pILFree(apidl[i]);
3072             IShellItemArray_Release(psia);
3073         }
3074     }
3075
3076     /* SHCreateShellItemArrayFromShellItem */
3077     if(pSHCreateShellItemArrayFromShellItem)
3078     {
3079         IShellItem *psi;
3080
3081         if(0)
3082         {
3083             /* Crashes under Windows 7 */
3084             hr = pSHCreateShellItemArrayFromShellItem(NULL, &IID_IShellItemArray, NULL);
3085             hr = pSHCreateShellItemArrayFromShellItem(NULL, &IID_IShellItemArray, (void**)&psia);
3086             hr = pSHCreateShellItemArrayFromShellItem(psi, &IID_IShellItemArray, NULL);
3087         }
3088
3089         hr = pSHCreateItemFromIDList(pidl_testdir, &IID_IShellItem, (void**)&psi);
3090         ok(hr == S_OK, "Got 0x%08x\n", hr);
3091         if(SUCCEEDED(hr))
3092         {
3093             hr = pSHCreateShellItemArrayFromShellItem(psi, &IID_IShellItemArray, (void**)&psia);
3094             ok(hr == S_OK, "Got 0x%08x\n", hr);
3095             if(SUCCEEDED(hr))
3096             {
3097                 IShellItem *psi2;
3098                 UINT count;
3099                 hr = IShellItemArray_GetCount(psia, &count);
3100                 ok(hr == S_OK, "Got 0x%08x\n", hr);
3101                 ok(count == 1, "Got count %d\n", count);
3102                 hr = IShellItemArray_GetItemAt(psia, 0, &psi2);
3103                 ok(hr == S_OK, "Got 0x%08x\n", hr);
3104                 todo_wine
3105                     ok(psi != psi2, "ShellItems are of the same instance.\n");
3106                 if(SUCCEEDED(hr))
3107                 {
3108                     LPITEMIDLIST pidl1, pidl2;
3109                     hr = pSHGetIDListFromObject((IUnknown*)psi, &pidl1);
3110                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3111                     ok(pidl1 != NULL, "pidl1 was null.\n");
3112                     hr = pSHGetIDListFromObject((IUnknown*)psi2, &pidl2);
3113                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3114                     ok(pidl2 != NULL, "pidl2 was null.\n");
3115                     ok(ILIsEqual(pidl1, pidl2), "pidls not equal.\n");
3116                     pILFree(pidl1);
3117                     pILFree(pidl2);
3118                     IShellItem_Release(psi2);
3119                 }
3120                 hr = IShellItemArray_GetItemAt(psia, 1, &psi2);
3121                 ok(hr == E_FAIL, "Got 0x%08x\n", hr);
3122                 IShellItemArray_Release(psia);
3123             }
3124             IShellItem_Release(psi);
3125         }
3126     }
3127     else
3128         skip("No SHCreateShellItemArrayFromShellItem.\n");
3129
3130     if(pSHCreateShellItemArrayFromDataObject)
3131     {
3132         IShellView *psv;
3133
3134         if(0)
3135         {
3136             /* Crashes under Windows 7 */
3137             hr = pSHCreateShellItemArrayFromDataObject(NULL, &IID_IShellItemArray, NULL);
3138         }
3139         hr = pSHCreateShellItemArrayFromDataObject(NULL, &IID_IShellItemArray, (void**)&psia);
3140         ok(hr == E_INVALIDARG, "Got 0x%08x\n", hr);
3141
3142         hr = IShellFolder_CreateViewObject(psf, NULL, &IID_IShellView, (void**)&psv);
3143         ok(hr == S_OK, "got 0x%08x\n", hr);
3144         if(SUCCEEDED(hr))
3145         {
3146             IEnumIDList *peidl;
3147             IDataObject *pdo;
3148             SHCONTF enum_flags;
3149
3150             enum_flags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
3151             hr = IShellFolder_EnumObjects(psf, NULL, enum_flags, &peidl);
3152             ok(hr == S_OK, "got 0x%08x\n", hr);
3153             if(SUCCEEDED(hr))
3154             {
3155                 LPITEMIDLIST apidl[5];
3156                 UINT count, i;
3157
3158                 for(count = 0; count < 5; count++)
3159                     if(IEnumIDList_Next(peidl, 1, &apidl[count], NULL) != S_OK)
3160                         break;
3161                 ok(count == 5, "Got %d\n", count);
3162
3163                 if(count)
3164                 {
3165                     hr = IShellFolder_GetUIObjectOf(psf, NULL, count, (LPCITEMIDLIST*)apidl,
3166                                                     &IID_IDataObject, NULL, (void**)&pdo);
3167                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3168                     if(SUCCEEDED(hr))
3169                     {
3170                         hr = pSHCreateShellItemArrayFromDataObject(pdo, &IID_IShellItemArray,
3171                                                                    (void**)&psia);
3172                         ok(hr == S_OK, "Got 0x%08x\n", hr);
3173                         if(SUCCEEDED(hr))
3174                         {
3175                             UINT count_sia, i;
3176                             hr = IShellItemArray_GetCount(psia, &count_sia);
3177                             ok(count_sia == count, "Counts differ (%d, %d)\n", count, count_sia);
3178                             for(i = 0; i < count_sia; i++)
3179                             {
3180                                 LPITEMIDLIST pidl_abs = ILCombine(pidl_testdir, apidl[i]);
3181                                 IShellItem *psi;
3182                                 hr = IShellItemArray_GetItemAt(psia, i, &psi);
3183                                 ok(hr == S_OK, "Got 0x%08x\n", hr);
3184                                 if(SUCCEEDED(hr))
3185                                 {
3186                                     LPITEMIDLIST pidl;
3187                                     hr = pSHGetIDListFromObject((IUnknown*)psi, &pidl);
3188                                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3189                                     ok(pidl != NULL, "pidl as NULL.\n");
3190                                     ok(ILIsEqual(pidl, pidl_abs), "pidls differ.\n");
3191                                     pILFree(pidl);
3192                                     IShellItem_Release(psi);
3193                                 }
3194                                 pILFree(pidl_abs);
3195                             }
3196
3197                             IShellItemArray_Release(psia);
3198                         }
3199
3200                         IDataObject_Release(pdo);
3201                     }
3202                     for(i = 0; i < count; i++)
3203                         pILFree(apidl[i]);
3204                 }
3205                 else
3206                     skip("No files found - skipping test.\n");
3207
3208                 IEnumIDList_Release(peidl);
3209             }
3210             IShellView_Release(psv);
3211         }
3212     }
3213     else
3214         skip("No SHCreateShellItemArrayFromDataObject.\n");
3215
3216     IShellFolder_Release(psf);
3217     pILFree(pidl_testdir);
3218     Cleanup();
3219 }
3220
3221 static void test_ShellItemBindToHandler(void)
3222 {
3223     IShellItem *psi;
3224     LPITEMIDLIST pidl_desktop;
3225     HRESULT hr;
3226
3227     if(!pSHCreateShellItem)
3228     {
3229         skip("SHCreateShellItem missing.\n");
3230         return;
3231     }
3232
3233     hr = pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl_desktop);
3234     ok(hr == S_OK, "Got 0x%08x\n", hr);
3235     if(SUCCEEDED(hr))
3236     {
3237         hr = pSHCreateShellItem(NULL, NULL, pidl_desktop, &psi);
3238         ok(hr == S_OK, "Got 0x%08x\n", hr);
3239     }
3240     if(SUCCEEDED(hr))
3241     {
3242         IPersistFolder2 *ppf2;
3243         IUnknown *punk;
3244
3245         if(0)
3246         {
3247             /* Crashes under Windows 7 */
3248             hr = IShellItem_BindToHandler(psi, NULL, NULL, NULL, NULL);
3249             hr = IShellItem_BindToHandler(psi, NULL, &IID_IUnknown, &IID_IUnknown, NULL);
3250         }
3251         hr = IShellItem_BindToHandler(psi, NULL, &IID_IUnknown, &IID_IUnknown, (void**)&punk);
3252         ok(hr == MK_E_NOOBJECT, "Got 0x%08x\n", hr);
3253
3254         /* BHID_SFObject */
3255         hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFObject, &IID_IShellFolder, (void**)&punk);
3256         ok(hr == S_OK, "Got 0x%08x\n", hr);
3257         if(SUCCEEDED(hr)) IUnknown_Release(punk);
3258         hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFObject, &IID_IPersistFolder2, (void**)&ppf2);
3259         ok(hr == S_OK, "Got 0x%08x\n", hr);
3260         if(SUCCEEDED(hr))
3261         {
3262             LPITEMIDLIST pidl_tmp;
3263             hr = IPersistFolder2_GetCurFolder(ppf2, &pidl_tmp);
3264             ok(hr == S_OK, "Got 0x%08x\n", hr);
3265             if(SUCCEEDED(hr))
3266             {
3267                 ok(ILIsEqual(pidl_desktop, pidl_tmp), "Pidl not equal (%p, %p)\n", pidl_desktop, pidl_tmp);
3268                 pILFree(pidl_tmp);
3269             }
3270             IPersistFolder2_Release(ppf2);
3271         }
3272
3273         todo_wine
3274         {
3275             /* BHID_SFUIObject */
3276             hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFUIObject, &IID_IDataObject, (void**)&punk);
3277             ok(hr == S_OK || broken(hr == E_NOINTERFACE /* XP */), "Got 0x%08x\n", hr);
3278             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3279             hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFUIObject, &IID_IContextMenu, (void**)&punk);
3280             ok(hr == S_OK || broken(hr == E_NOINTERFACE /* XP */), "Got 0x%08x\n", hr);
3281             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3282
3283             /* BHID_SFViewObject */
3284             hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFViewObject, &IID_IShellView, (void**)&punk);
3285             ok(hr == S_OK, "Got 0x%08x\n", hr);
3286             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3287             hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFViewObject, &IID_IShellFolderView, (void**)&punk);
3288             ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3289             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3290
3291             /* BHID_Storage */
3292             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Storage, &IID_IStream, (void**)&punk);
3293             ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3294             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3295             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Storage, &IID_IUnknown, (void**)&punk);
3296             ok(hr == S_OK, "Got 0x%08x\n", hr);
3297             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3298
3299             /* BHID_Stream */
3300             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Stream, &IID_IStream, (void**)&punk);
3301             ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3302             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3303             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Stream, &IID_IUnknown, (void**)&punk);
3304             ok(hr == S_OK, "Got 0x%08x\n", hr);
3305             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3306
3307             /* BHID_StorageEnum */
3308             hr = IShellItem_BindToHandler(psi, NULL, &BHID_StorageEnum, &IID_IEnumShellItems, (void**)&punk);
3309             ok(hr == S_OK, "Got 0x%08x\n", hr);
3310             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3311
3312             /* BHID_Transfer */
3313             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Transfer, &IID_IUnknown, (void**)&punk);
3314             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3315             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3316
3317             /* BHID_EnumItems */
3318             hr = IShellItem_BindToHandler(psi, NULL, &BHID_EnumItems, &IID_IEnumShellItems, (void**)&punk);
3319             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3320             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3321
3322             /* BHID_DataObject */
3323             hr = IShellItem_BindToHandler(psi, NULL, &BHID_DataObject, &IID_IDataObject, (void**)&punk);
3324             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3325             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3326
3327             /* BHID_Filter */
3328             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Filter, &IID_IUnknown, (void**)&punk);
3329             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3330             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3331
3332             /* BHID_LinkTargetItem */
3333             hr = IShellItem_BindToHandler(psi, NULL, &BHID_LinkTargetItem, &IID_IShellItem, (void**)&punk);
3334             ok(hr == E_NOINTERFACE || broken(hr == E_INVALIDARG /* XP */), "Got 0x%08x\n", hr);
3335             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3336             hr = IShellItem_BindToHandler(psi, NULL, &BHID_LinkTargetItem, &IID_IUnknown, (void**)&punk);
3337             ok(hr == E_NOINTERFACE || broken(hr == E_INVALIDARG /* XP */), "Got 0x%08x\n", hr);
3338             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3339
3340             /* BHID_PropertyStore */
3341             hr = IShellItem_BindToHandler(psi, NULL, &BHID_PropertyStore, &IID_IPropertyStore, (void**)&punk);
3342             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3343             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3344             hr = IShellItem_BindToHandler(psi, NULL, &BHID_PropertyStore, &IID_IPropertyStoreFactory, (void**)&punk);
3345             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3346             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3347
3348             /* BHID_ThumbnailHandler */
3349             hr = IShellItem_BindToHandler(psi, NULL, &BHID_ThumbnailHandler, &IID_IUnknown, (void**)&punk);
3350             ok(hr == E_INVALIDARG || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3351             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3352
3353             /* BHID_AssociationArray */
3354             hr = IShellItem_BindToHandler(psi, NULL, &BHID_AssociationArray, &IID_IQueryAssociations, (void**)&punk);
3355             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3356             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3357
3358             /* BHID_EnumAssocHandlers */
3359             hr = IShellItem_BindToHandler(psi, NULL, &BHID_EnumAssocHandlers, &IID_IUnknown, (void**)&punk);
3360             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3361             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3362         }
3363
3364         IShellItem_Release(psi);
3365     }
3366     else
3367         skip("Failed to create ShellItem.\n");
3368
3369     pILFree(pidl_desktop);
3370 }
3371
3372 static void test_SHParseDisplayName(void)
3373 {
3374     LPITEMIDLIST pidl1, pidl2;
3375     IShellFolder *desktop;
3376     WCHAR dirW[MAX_PATH];
3377     WCHAR nameW[10];
3378     HRESULT hr;
3379     BOOL ret;
3380
3381     if (!pSHParseDisplayName)
3382     {
3383         win_skip("SHParseDisplayName isn't available\n");
3384         return;
3385     }
3386
3387 if (0)
3388 {
3389     /* crashes on native */
3390     hr = pSHParseDisplayName(NULL, NULL, NULL, 0, NULL);
3391     nameW[0] = 0;
3392     hr = pSHParseDisplayName(nameW, NULL, NULL, 0, NULL);
3393 }
3394
3395     pidl1 = (LPITEMIDLIST)0xdeadbeef;
3396     hr = pSHParseDisplayName(NULL, NULL, &pidl1, 0, NULL);
3397     ok(broken(hr == E_OUTOFMEMORY) /* < Vista */ ||
3398        hr == E_INVALIDARG, "failed %08x\n", hr);
3399     ok(pidl1 == 0, "expected null ptr, got %p\n", pidl1);
3400
3401     /* dummy name */
3402     nameW[0] = 0;
3403     hr = pSHParseDisplayName(nameW, NULL, &pidl1, 0, NULL);
3404     ok(hr == S_OK, "failed %08x\n", hr);
3405     hr = SHGetDesktopFolder(&desktop);
3406     ok(hr == S_OK, "failed %08x\n", hr);
3407     hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, nameW, NULL, &pidl2, NULL);
3408     ok(hr == S_OK, "failed %08x\n", hr);
3409     ret = pILIsEqual(pidl1, pidl2);
3410     ok(ret == TRUE, "expected equal idls\n");
3411     pILFree(pidl1);
3412     pILFree(pidl2);
3413
3414     /* with path */
3415     GetWindowsDirectoryW( dirW, MAX_PATH );
3416
3417     hr = pSHParseDisplayName(dirW, NULL, &pidl1, 0, NULL);
3418     ok(hr == S_OK, "failed %08x\n", hr);
3419     hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, dirW, NULL, &pidl2, NULL);
3420     ok(hr == S_OK, "failed %08x\n", hr);
3421
3422     ret = pILIsEqual(pidl1, pidl2);
3423     ok(ret == TRUE, "expected equal idls\n");
3424     pILFree(pidl1);
3425     pILFree(pidl2);
3426
3427     IShellFolder_Release(desktop);
3428 }
3429
3430 static void test_desktop_IPersist(void)
3431 {
3432     IShellFolder *desktop;
3433     IPersist *persist;
3434     IPersistFolder2 *ppf2;
3435     CLSID clsid;
3436     HRESULT hr;
3437
3438     hr = SHGetDesktopFolder(&desktop);
3439     ok(hr == S_OK, "failed %08x\n", hr);
3440
3441     hr = IShellFolder_QueryInterface(desktop, &IID_IPersist, (void**)&persist);
3442     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* NT4, W9X */, "failed %08x\n", hr);
3443
3444     if (hr == S_OK)
3445     {
3446     if (0)
3447     {
3448         /* crashes on native */
3449         hr = IPersist_GetClassID(persist, NULL);
3450     }
3451         memset(&clsid, 0, sizeof(clsid));
3452         hr = IPersist_GetClassID(persist, &clsid);
3453         ok(hr == S_OK, "failed %08x\n", hr);
3454         ok(IsEqualIID(&CLSID_ShellDesktop, &clsid), "Expected CLSID_ShellDesktop\n");
3455         IPersist_Release(persist);
3456     }
3457
3458     hr = IShellFolder_QueryInterface(desktop, &IID_IPersistFolder2, (void**)&ppf2);
3459     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* pre-Vista */, "failed %08x\n", hr);
3460     if(SUCCEEDED(hr))
3461     {
3462         IPersistFolder *ppf;
3463         LPITEMIDLIST pidl;
3464         hr = IShellFolder_QueryInterface(desktop, &IID_IPersistFolder, (void**)&ppf);
3465         ok(hr == S_OK, "IID_IPersistFolder2 without IID_IPersistFolder.\n");
3466         if(SUCCEEDED(hr))
3467             IPersistFolder_Release(ppf);
3468
3469         todo_wine {
3470             hr = IPersistFolder2_Initialize(ppf2, NULL);
3471             ok(hr == S_OK, "got %08x\n", hr);
3472         }
3473
3474         pidl = NULL;
3475         hr = IPersistFolder2_GetCurFolder(ppf2, &pidl);
3476         ok(hr == S_OK, "got %08x\n", hr);
3477         ok(pidl != NULL, "pidl was NULL.\n");
3478         if(SUCCEEDED(hr)) pILFree(pidl);
3479
3480         IPersistFolder2_Release(ppf2);
3481     }
3482
3483     IShellFolder_Release(desktop);
3484 }
3485
3486 static void test_GetUIObject(void)
3487 {
3488     IShellFolder *psf_desktop;
3489     IContextMenu *pcm;
3490     LPITEMIDLIST pidl;
3491     HRESULT hr;
3492     WCHAR path[MAX_PATH];
3493     const WCHAR filename[] =
3494         {'\\','t','e','s','t','d','i','r','\\','t','e','s','t','1','.','t','x','t',0};
3495
3496     if(!pSHBindToParent)
3497     {
3498         win_skip("SHBindToParent missing.\n");
3499         return;
3500     }
3501
3502     GetCurrentDirectoryW(MAX_PATH, path);
3503     if(!lstrlenW(path))
3504     {
3505         skip("GetCurrentDirectoryW returned an empty string.\n");
3506         return;
3507     }
3508     lstrcatW(path, filename);
3509     SHGetDesktopFolder(&psf_desktop);
3510
3511     CreateFilesFolders();
3512
3513     hr = IShellFolder_ParseDisplayName(psf_desktop, NULL, NULL, path, NULL, &pidl, 0);
3514     ok(hr == S_OK || broken(hr == E_FAIL) /* WinME */, "Got 0x%08x\n", hr);
3515     if(SUCCEEDED(hr))
3516     {
3517         IShellFolder *psf;
3518         LPCITEMIDLIST pidl_child;
3519         hr = pSHBindToParent(pidl, &IID_IShellFolder, (void**)&psf, &pidl_child);
3520         ok(hr == S_OK, "Got 0x%08x\n", hr);
3521         if(SUCCEEDED(hr))
3522         {
3523             hr = IShellFolder_GetUIObjectOf(psf, NULL, 1, (LPCITEMIDLIST*)&pidl_child,
3524                                             &IID_IContextMenu, NULL, (void**)&pcm);
3525             ok(hr == S_OK, "Got 0x%08x\n", hr);
3526             if(SUCCEEDED(hr))
3527             {
3528                 HMENU hmenu = CreatePopupMenu();
3529                 INT max_id, max_id_check;
3530                 UINT count, i;
3531                 const int id_upper_limit = 32767;
3532                 hr = IContextMenu_QueryContextMenu(pcm, hmenu, 0, 0, id_upper_limit, CMF_NORMAL);
3533                 ok(SUCCEEDED(hr), "Got 0x%08x\n", hr);
3534                 max_id = HRESULT_CODE(hr) - 1; /* returns max_id + 1 */
3535                 ok(max_id <= id_upper_limit, "Got %d\n", max_id);
3536                 count = GetMenuItemCount(hmenu);
3537                 ok(count, "Got %d\n", count);
3538
3539                 max_id_check = 0;
3540                 for(i = 0; i < count; i++)
3541                 {
3542                     MENUITEMINFOA mii;
3543                     INT res;
3544                     ZeroMemory(&mii, sizeof(MENUITEMINFOA));
3545                     mii.cbSize = sizeof(MENUITEMINFOA);
3546                     mii.fMask = MIIM_ID | MIIM_FTYPE;
3547
3548                     SetLastError(0);
3549                     res = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
3550                     ok(res, "Failed (last error: %d).\n", GetLastError());
3551
3552                     ok( (mii.wID <= id_upper_limit) || (mii.fType & MFT_SEPARATOR),
3553                         "Got non-separator ID out of range: %d (type: %x) \n", mii.wID, mii.fType);
3554                     if(!(mii.fType & MFT_SEPARATOR))
3555                         max_id_check = (mii.wID>max_id_check)?mii.wID:max_id_check;
3556                 }
3557                 ok((max_id_check == max_id) ||
3558                    (max_id_check == max_id-1 /* Win 7 */),
3559                    "Not equal (or near equal), got %d and %d\n", max_id_check, max_id);
3560
3561 #define is_win2k() (pSHGetFolderPathA && !pSHGetFolderPathAndSubDirA)
3562
3563                 if(count && !is_win2k())   /* Test is interactive on w2k, so skip */
3564                 {
3565                     CMINVOKECOMMANDINFO cmi;
3566                     ZeroMemory(&cmi, sizeof(CMINVOKECOMMANDINFO));
3567                     cmi.cbSize = sizeof(CMINVOKECOMMANDINFO);
3568
3569                     /* Attempt to execute a nonexistent command */
3570                     cmi.lpVerb = MAKEINTRESOURCEA(9999);
3571                     hr = IContextMenu_InvokeCommand(pcm, &cmi);
3572                     ok(hr == E_INVALIDARG, "Got 0x%08x\n", hr);
3573
3574                     cmi.lpVerb = "foobar_wine_test";
3575                     hr = IContextMenu_InvokeCommand(pcm, &cmi);
3576                     ok( (hr == E_INVALIDARG) || (hr == E_FAIL /* Win7 */) ||
3577                         (hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) /* Vista */),
3578                         "Got 0x%08x\n", hr);
3579                 }
3580 #undef is_win2k
3581
3582                 DestroyMenu(hmenu);
3583                 IContextMenu_Release(pcm);
3584             }
3585             IShellFolder_Release(psf);
3586         }
3587         if(pILFree) pILFree(pidl);
3588     }
3589
3590     IShellFolder_Release(psf_desktop);
3591     Cleanup();
3592 }
3593
3594 #define verify_pidl(i,p) r_verify_pidl(__LINE__, i, p)
3595 static void r_verify_pidl(unsigned l, LPCITEMIDLIST pidl, const WCHAR *path)
3596 {
3597     LPCITEMIDLIST child;
3598     IShellFolder *parent;
3599     STRRET filename;
3600     HRESULT hr;
3601
3602     if(!pSHBindToParent){
3603         win_skip("SHBindToParent is not available, not performing full PIDL verification\n");
3604         if(path)
3605             ok_(__FILE__,l)(pidl != NULL, "Expected PIDL to be non-NULL\n");
3606         else
3607             ok_(__FILE__,l)(pidl == NULL, "Expected PIDL to be NULL\n");
3608         return;
3609     }
3610
3611     if(path){
3612         if(!pidl){
3613             ok_(__FILE__,l)(0, "didn't get expected path (%s), instead: NULL\n", wine_dbgstr_w(path));
3614             return;
3615         }
3616
3617         hr = pSHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&parent, &child);
3618         ok_(__FILE__,l)(hr == S_OK, "SHBindToParent failed: 0x%08x\n", hr);
3619         if(FAILED(hr))
3620             return;
3621
3622         hr = IShellFolder_GetDisplayNameOf(parent, child, SHGDN_FORPARSING, &filename);
3623         ok_(__FILE__,l)(hr == S_OK, "GetDisplayNameOf failed: 0x%08x\n", hr);
3624         if(FAILED(hr)){
3625             IShellFolder_Release(parent);
3626             return;
3627         }
3628
3629         ok_(__FILE__,l)(filename.uType == STRRET_WSTR || filename.uType == STRRET_CSTR,
3630                 "Got unexpected string type: %d\n", filename.uType);
3631         if(filename.uType == STRRET_WSTR){
3632             ok_(__FILE__,l)(lstrcmpW(path, filename.pOleStr) == 0,
3633                     "didn't get expected path (%s), instead: %s\n",
3634                      wine_dbgstr_w(path), wine_dbgstr_w(filename.pOleStr));
3635         }else if(filename.uType == STRRET_CSTR){
3636             ok_(__FILE__,l)(strcmp_wa(path, filename.cStr) == 0,
3637                     "didn't get expected path (%s), instead: %s\n",
3638                      wine_dbgstr_w(path), filename.cStr);
3639         }
3640
3641         IShellFolder_Release(parent);
3642     }else
3643         ok_(__FILE__,l)(pidl == NULL, "Expected PIDL to be NULL\n");
3644 }
3645
3646 static void test_SHSimpleIDListFromPath(void)
3647 {
3648     const WCHAR adirW[] = {'C',':','\\','s','i','d','l','f','p','d','i','r',0};
3649     const CHAR adirA[] = "C:\\sidlfpdir";
3650     BOOL br, is_unicode = !(GetVersion() & 0x80000000);
3651
3652     LPITEMIDLIST pidl = NULL;
3653
3654     if(!pSHSimpleIDListFromPathAW){
3655         win_skip("SHSimpleIDListFromPathAW not available\n");
3656         return;
3657     }
3658
3659     br = CreateDirectoryA(adirA, NULL);
3660     ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
3661
3662     if(is_unicode)
3663         pidl = pSHSimpleIDListFromPathAW(adirW);
3664     else
3665         pidl = pSHSimpleIDListFromPathAW(adirA);
3666     verify_pidl(pidl, adirW);
3667     pILFree(pidl);
3668
3669     br = RemoveDirectoryA(adirA);
3670     ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
3671
3672     if(is_unicode)
3673         pidl = pSHSimpleIDListFromPathAW(adirW);
3674     else
3675         pidl = pSHSimpleIDListFromPathAW(adirA);
3676     verify_pidl(pidl, adirW);
3677     pILFree(pidl);
3678 }
3679
3680 /* IFileSystemBindData impl */
3681 static HRESULT WINAPI fsbd_QueryInterface(IFileSystemBindData *fsbd,
3682         REFIID riid, void **ppv)
3683 {
3684     if(IsEqualIID(riid, &IID_IFileSystemBindData) ||
3685             IsEqualIID(riid, &IID_IUnknown)){
3686         *ppv = fsbd;
3687         return S_OK;
3688     }
3689     return E_NOINTERFACE;
3690 }
3691
3692 static ULONG WINAPI fsbd_AddRef(IFileSystemBindData *fsbd)
3693 {
3694     return 2;
3695 }
3696
3697 static ULONG WINAPI fsbd_Release(IFileSystemBindData *fsbd)
3698 {
3699     return 1;
3700 }
3701
3702 static HRESULT WINAPI fsbd_SetFindData(IFileSystemBindData *fsbd,
3703         const WIN32_FIND_DATAW *pfd)
3704 {
3705     ok(0, "SetFindData called\n");
3706     return E_NOTIMPL;
3707 }
3708
3709 static HRESULT WINAPI fsbd_GetFindData_nul(IFileSystemBindData *fsbd,
3710         WIN32_FIND_DATAW *pfd)
3711 {
3712     memset(pfd, 0, sizeof(WIN32_FIND_DATAW));
3713     return S_OK;
3714 }
3715
3716 static HRESULT WINAPI fsbd_GetFindData_junk(IFileSystemBindData *fsbd,
3717         WIN32_FIND_DATAW *pfd)
3718 {
3719     memset(pfd, 0xdeadbeef, sizeof(WIN32_FIND_DATAW));
3720     return S_OK;
3721 }
3722
3723 static HRESULT WINAPI fsbd_GetFindData_invalid(IFileSystemBindData *fsbd,
3724         WIN32_FIND_DATAW *pfd)
3725 {
3726     memset(pfd, 0, sizeof(WIN32_FIND_DATAW));
3727     *pfd->cFileName = 'a';
3728     *pfd->cAlternateFileName = 'a';
3729     return S_OK;
3730 }
3731
3732 static HRESULT WINAPI fsbd_GetFindData_valid(IFileSystemBindData *fsbd,
3733         WIN32_FIND_DATAW *pfd)
3734 {
3735     static const WCHAR adirW[] = {'C',':','\\','f','s','b','d','d','i','r',0};
3736     HANDLE handle = FindFirstFileW(adirW, pfd);
3737     FindClose(handle);
3738     return S_OK;
3739 }
3740
3741 static HRESULT WINAPI fsbd_GetFindData_fail(IFileSystemBindData *fsbd,
3742         WIN32_FIND_DATAW *pfd)
3743 {
3744     return E_FAIL;
3745 }
3746
3747 static IFileSystemBindDataVtbl fsbdVtbl = {
3748     fsbd_QueryInterface,
3749     fsbd_AddRef,
3750     fsbd_Release,
3751     fsbd_SetFindData,
3752     NULL
3753 };
3754
3755 static IFileSystemBindData fsbd = { &fsbdVtbl };
3756
3757 static void test_ParseDisplayNamePBC(void)
3758 {
3759     WCHAR wFileSystemBindData[] =
3760         {'F','i','l','e',' ','S','y','s','t','e','m',' ','B','i','n','d',' ','D','a','t','a',0};
3761     WCHAR adirW[] = {'C',':','\\','f','s','b','d','d','i','r',0};
3762     const HRESULT exp_err = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
3763
3764     IShellFolder *psf;
3765     IBindCtx *pbc;
3766     HRESULT hres;
3767     ITEMIDLIST *pidl;
3768
3769     /* Check if we support WCHAR functions */
3770     SetLastError(0xdeadbeef);
3771     lstrcmpiW(adirW, adirW);
3772     if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED){
3773         win_skip("Most W-calls are not implemented\n");
3774         return;
3775     }
3776
3777     hres = SHGetDesktopFolder(&psf);
3778     ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08x\n", hres);
3779     if(FAILED(hres)){
3780         win_skip("Failed to get IShellFolder, can't run tests\n");
3781         return;
3782     }
3783
3784     /* fails on unknown dir with no IBindCtx */
3785     hres = IShellFolder_ParseDisplayName(psf, NULL, NULL, adirW, NULL, &pidl, NULL);
3786     ok(hres == exp_err || broken(hres == E_FAIL) /* NT4 */,
3787             "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
3788
3789     /* fails on unknown dir with IBindCtx with no IFileSystemBindData */
3790     hres = CreateBindCtx(0, &pbc);
3791     ok(hres == S_OK, "CreateBindCtx failed: 0x%08x\n", hres);
3792
3793     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3794     ok(hres == exp_err || broken(hres == E_FAIL) /* NT4 */,
3795             "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
3796
3797     /* unknown dir with IBindCtx with IFileSystemBindData */
3798     hres = IBindCtx_RegisterObjectParam(pbc, wFileSystemBindData, (IUnknown*)&fsbd);
3799     ok(hres == S_OK, "RegisterObjectParam failed: 0x%08x\n", hres);
3800
3801     /* return E_FAIL from GetFindData */
3802     pidl = (ITEMIDLIST*)0xdeadbeef;
3803     fsbdVtbl.GetFindData = fsbd_GetFindData_fail;
3804     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3805     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3806             "ParseDisplayName failed: 0x%08x\n", hres);
3807     if(SUCCEEDED(hres)){
3808         verify_pidl(pidl, adirW);
3809         ILFree(pidl);
3810     }
3811
3812     /* set FIND_DATA struct to NULLs */
3813     pidl = (ITEMIDLIST*)0xdeadbeef;
3814     fsbdVtbl.GetFindData = fsbd_GetFindData_nul;
3815     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3816     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3817             "ParseDisplayName failed: 0x%08x\n", hres);
3818     if(SUCCEEDED(hres)){
3819         verify_pidl(pidl, adirW);
3820         ILFree(pidl);
3821     }
3822
3823     /* set FIND_DATA struct to junk */
3824     pidl = (ITEMIDLIST*)0xdeadbeef;
3825     fsbdVtbl.GetFindData = fsbd_GetFindData_junk;
3826     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3827     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3828             "ParseDisplayName failed: 0x%08x\n", hres);
3829     if(SUCCEEDED(hres)){
3830         verify_pidl(pidl, adirW);
3831         ILFree(pidl);
3832     }
3833
3834     /* set FIND_DATA struct to invalid data */
3835     pidl = (ITEMIDLIST*)0xdeadbeef;
3836     fsbdVtbl.GetFindData = fsbd_GetFindData_invalid;
3837     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3838     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3839             "ParseDisplayName failed: 0x%08x\n", hres);
3840     if(SUCCEEDED(hres)){
3841         verify_pidl(pidl, adirW);
3842         ILFree(pidl);
3843     }
3844
3845     /* set FIND_DATA struct to valid data */
3846     pidl = (ITEMIDLIST*)0xdeadbeef;
3847     fsbdVtbl.GetFindData = fsbd_GetFindData_valid;
3848     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3849     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3850             "ParseDisplayName failed: 0x%08x\n", hres);
3851     if(SUCCEEDED(hres)){
3852         verify_pidl(pidl, adirW);
3853         ILFree(pidl);
3854     }
3855
3856     IBindCtx_Release(pbc);
3857     IShellFolder_Release(psf);
3858 }
3859
3860 static const CHAR testwindow_class[] = "testwindow";
3861 #define WM_USER_NOTIFY (WM_APP+1)
3862
3863 static struct {
3864     const char *id;
3865     BOOL exp_notify;
3866     UINT signal;
3867     const WCHAR *path_1;
3868     const WCHAR *path_2;
3869 } exp_data;
3870
3871 static LRESULT CALLBACK testwindow_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
3872 {
3873     UINT signal = (UINT)lparam;
3874
3875     switch(msg){
3876     case WM_USER_NOTIFY:
3877         if(exp_data.exp_notify){
3878             LPCITEMIDLIST *pidls = (LPCITEMIDLIST*)wparam;
3879
3880             ok(exp_data.signal == signal,
3881                     "%s: expected notification type %x, got: %x\n",
3882                     exp_data.id, exp_data.signal, signal);
3883
3884             trace("verifying pidls for: %s\n", exp_data.id);
3885             verify_pidl(pidls[0], exp_data.path_1);
3886             verify_pidl(pidls[1], exp_data.path_2);
3887
3888             exp_data.exp_notify = FALSE;
3889         }else
3890             ok(exp_data.exp_notify, "Didn't expect a WM_USER_NOTIFY message (event: %x)\n", signal);
3891         return 0;
3892     }
3893     return DefWindowProc(hwnd, msg, wparam, lparam);
3894 }
3895
3896 static void register_testwindow_class(void)
3897 {
3898     WNDCLASSEXA cls;
3899     ATOM ret;
3900
3901     ZeroMemory(&cls, sizeof(cls));
3902     cls.cbSize = sizeof(cls);
3903     cls.style = 0;
3904     cls.lpfnWndProc = testwindow_wndproc;
3905     cls.hInstance = GetModuleHandleA(NULL);
3906     cls.lpszClassName = testwindow_class;
3907
3908     SetLastError(0);
3909     ret = RegisterClassExA(&cls);
3910     ok(ret != 0, "RegisterClassExA failed: %d\n", GetLastError());
3911 }
3912
3913 /* SHCNF_FLUSH doesn't seem to work as advertised for SHCNF_PATHA, so we
3914  * have to poll repeatedly for the message to appear */
3915 static void do_events(void)
3916 {
3917     int c = 0;
3918     while (exp_data.exp_notify && (c++ < 10)){
3919         MSG msg;
3920         while(PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)){
3921             TranslateMessage(&msg);
3922             DispatchMessageA(&msg);
3923         }
3924         if(exp_data.exp_notify)
3925             Sleep(500);
3926     }
3927     trace("%s: took %d tries\n", exp_data.id, c);
3928 }
3929
3930 static void test_SHChangeNotify(void)
3931 {
3932     HWND wnd;
3933     ULONG notifyID;
3934     HRESULT hr;
3935     BOOL br, has_unicode;
3936     SHChangeNotifyEntry entries[1];
3937     const CHAR root_dirA[] = "C:\\shell32_cn_test";
3938     const WCHAR root_dirW[] = {'C',':','\\','s','h','e','l','l','3','2','_','c','n','_','t','e','s','t',0};
3939     const CHAR test_dirA[] = "C:\\shell32_cn_test\\test";
3940     const WCHAR test_dirW[] = {'C',':','\\','s','h','e','l','l','3','2','_','c','n','_','t','e','s','t','\\','t','e','s','t',0};
3941
3942     CreateDirectoryW(NULL, NULL);
3943     has_unicode = !(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED);
3944
3945     /* set up the root directory & window */
3946     br = CreateDirectoryA(root_dirA, NULL);
3947     ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
3948
3949     register_testwindow_class();
3950
3951     wnd = CreateWindowExA(0, testwindow_class, testwindow_class, 0,
3952             CW_USEDEFAULT, CW_USEDEFAULT, 130, 105,
3953             NULL, NULL, GetModuleHandleA(NULL), 0);
3954     ok(wnd != NULL, "Failed to make a window\n");
3955
3956     entries[0].pidl = NULL;
3957     if(has_unicode)
3958         hr = SHILCreateFromPath(root_dirW, (LPITEMIDLIST*)&entries[0].pidl, 0);
3959     else
3960         hr = SHILCreateFromPath((LPCVOID)root_dirA, (LPITEMIDLIST*)&entries[0].pidl, 0);
3961     ok(hr == S_OK, "SHILCreateFromPath failed: 0x%08x\n", hr);
3962     entries[0].fRecursive = TRUE;
3963
3964     notifyID = SHChangeNotifyRegister(wnd, SHCNRF_ShellLevel,
3965             SHCNE_ALLEVENTS, WM_USER_NOTIFY, 1, entries);
3966     ok(notifyID != 0, "Failed to register a window for change notifications\n");
3967
3968     /* MKDIR */
3969     br = CreateDirectoryA(test_dirA, NULL);
3970     ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
3971
3972     if(has_unicode){
3973         exp_data.id = "MKDIR PATHW";
3974         exp_data.signal = SHCNE_MKDIR;
3975         exp_data.exp_notify = TRUE;
3976         exp_data.path_1 = test_dirW;
3977         exp_data.path_2 = NULL;
3978         SHChangeNotify(SHCNE_MKDIR, SHCNF_PATHW | SHCNF_FLUSH, test_dirW, NULL);
3979         do_events();
3980         ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
3981     }else
3982         win_skip("skipping WCHAR tests\n");
3983
3984     exp_data.id = "MKDIR PATHA";
3985     exp_data.signal = SHCNE_MKDIR;
3986     exp_data.exp_notify = TRUE;
3987     exp_data.path_1 = test_dirW;
3988     exp_data.path_2 = NULL;
3989     SHChangeNotify(SHCNE_MKDIR, SHCNF_PATHA | SHCNF_FLUSH, test_dirA, NULL);
3990     do_events();
3991     ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
3992
3993     /* RMDIR */
3994     br = RemoveDirectoryA(test_dirA);
3995     ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
3996
3997     if(has_unicode){
3998         exp_data.id = "RMDIR PATHW";
3999         exp_data.signal = SHCNE_RMDIR;
4000         exp_data.exp_notify = TRUE;
4001         exp_data.path_1 = test_dirW;
4002         exp_data.path_2 = NULL;
4003         SHChangeNotify(SHCNE_RMDIR, SHCNF_PATHW | SHCNF_FLUSH, test_dirW, NULL);
4004         do_events();
4005         ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
4006     }else
4007         win_skip("skipping WCHAR tests\n");
4008
4009     exp_data.id = "RMDIR PATHA";
4010     exp_data.signal = SHCNE_RMDIR;
4011     exp_data.exp_notify = TRUE;
4012     exp_data.path_1 = test_dirW;
4013     exp_data.path_2 = NULL;
4014     SHChangeNotify(SHCNE_RMDIR, SHCNF_PATHA | SHCNF_FLUSH, test_dirA, NULL);
4015     do_events();
4016     ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
4017
4018     SHChangeNotifyDeregister(notifyID);
4019     DestroyWindow(wnd);
4020
4021     br = RemoveDirectoryA(root_dirA);
4022     ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
4023 }
4024
4025 START_TEST(shlfolder)
4026 {
4027     init_function_pointers();
4028     /* if OleInitialize doesn't get called, ParseDisplayName returns
4029        CO_E_NOTINITIALIZED for malformed directory names on win2k. */
4030     OleInitialize(NULL);
4031
4032     test_ParseDisplayName();
4033     test_SHParseDisplayName();
4034     test_BindToObject();
4035     test_EnumObjects_and_CompareIDs();
4036     test_GetDisplayName();
4037     test_GetAttributesOf();
4038     test_SHGetPathFromIDList();
4039     test_CallForAttributes();
4040     test_FolderShortcut();
4041     test_ITEMIDLIST_format();
4042     test_SHGetFolderPathAndSubDirA();
4043     test_LocalizedNames();
4044     test_SHCreateShellItem();
4045     test_SHCreateShellItemArray();
4046     test_desktop_IPersist();
4047     test_GetUIObject();
4048     test_SHSimpleIDListFromPath();
4049     test_ParseDisplayNamePBC();
4050     test_SHGetNameFromIDList();
4051     test_SHGetItemFromDataObject();
4052     test_SHGetIDListFromObject();
4053     test_SHGetItemFromObject();
4054     test_ShellItemCompare();
4055     test_SHChangeNotify();
4056     test_ShellItemBindToHandler();
4057
4058     OleUninitialize();
4059 }