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, pidl_desktop;
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     if(pSHGetSpecialFolderLocation)
1914     {
1915         ret = pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl_desktop);
1916         ok(ret == S_OK, "Got 0x%08x\n", ret);
1917     }
1918     else
1919     {
1920         win_skip("pSHGetSpecialFolderLocation missing.\n");
1921         pidl_desktop = NULL;
1922     }
1923
1924     MultiByteToWideChar(CP_ACP, 0, curdirA, -1, curdirW, MAX_PATH);
1925
1926     ret = SHGetDesktopFolder(&desktopfolder);
1927     ok(SUCCEEDED(ret), "SHGetShellFolder returned %x\n", ret);
1928
1929     ret = IShellFolder_ParseDisplayName(desktopfolder, NULL, NULL, curdirW, NULL, &pidl_cwd, NULL);
1930     ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
1931
1932     ret = IShellFolder_BindToObject(desktopfolder, pidl_cwd, NULL, &IID_IShellFolder, (void**)&currentfolder);
1933     ok(SUCCEEDED(ret), "BindToObject returned %x\n", ret);
1934
1935     CreateTestFile(".\\testfile");
1936
1937     ret = IShellFolder_ParseDisplayName(currentfolder, NULL, NULL, testfileW, NULL, &pidl_testfile, NULL);
1938     ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
1939
1940     pidl_abstestfile = pILCombine(pidl_cwd, pidl_testfile);
1941
1942     ret = pSHCreateShellItem(NULL, NULL, NULL, &shellitem);
1943     ok(ret == E_INVALIDARG, "SHCreateShellItem returned %x\n", ret);
1944
1945     if (0) /* crashes on Windows XP */
1946     {
1947         pSHCreateShellItem(NULL, NULL, pidl_cwd, NULL);
1948         pSHCreateShellItem(pidl_cwd, NULL, NULL, &shellitem);
1949         pSHCreateShellItem(NULL, currentfolder, NULL, &shellitem);
1950         pSHCreateShellItem(pidl_cwd, currentfolder, NULL, &shellitem);
1951     }
1952
1953     ret = pSHCreateShellItem(NULL, NULL, pidl_cwd, &shellitem);
1954     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1955     if (SUCCEEDED(ret))
1956     {
1957         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1958         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1959         if (SUCCEEDED(ret))
1960         {
1961             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1962             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1963             if (SUCCEEDED(ret))
1964             {
1965                 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
1966                 pILFree(pidl_test);
1967             }
1968             IPersistIDList_Release(persistidl);
1969         }
1970         IShellItem_Release(shellitem);
1971     }
1972
1973     ret = pSHCreateShellItem(pidl_cwd, NULL, pidl_testfile, &shellitem);
1974     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1975     if (SUCCEEDED(ret))
1976     {
1977         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1978         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1979         if (SUCCEEDED(ret))
1980         {
1981             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1982             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1983             if (SUCCEEDED(ret))
1984             {
1985                 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
1986                 pILFree(pidl_test);
1987             }
1988             IPersistIDList_Release(persistidl);
1989         }
1990
1991         ret = IShellItem_GetParent(shellitem, &shellitem2);
1992         ok(SUCCEEDED(ret), "GetParent returned %x\n", ret);
1993         if (SUCCEEDED(ret))
1994         {
1995             ret = IShellItem_QueryInterface(shellitem2, &IID_IPersistIDList, (void**)&persistidl);
1996             ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1997             if (SUCCEEDED(ret))
1998             {
1999                 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2000                 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2001                 if (SUCCEEDED(ret))
2002                 {
2003                     ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
2004                     pILFree(pidl_test);
2005                 }
2006                 IPersistIDList_Release(persistidl);
2007             }
2008             IShellItem_Release(shellitem2);
2009         }
2010
2011         IShellItem_Release(shellitem);
2012     }
2013
2014     ret = pSHCreateShellItem(NULL, currentfolder, pidl_testfile, &shellitem);
2015     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2016     if (SUCCEEDED(ret))
2017     {
2018         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2019         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2020         if (SUCCEEDED(ret))
2021         {
2022             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2023             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2024             if (SUCCEEDED(ret))
2025             {
2026                 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2027                 pILFree(pidl_test);
2028             }
2029             IPersistIDList_Release(persistidl);
2030         }
2031         IShellItem_Release(shellitem);
2032     }
2033
2034     /* if a parent pidl and shellfolder are specified, the shellfolder is ignored */
2035     ret = pSHCreateShellItem(pidl_cwd, desktopfolder, pidl_testfile, &shellitem);
2036     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2037     if (SUCCEEDED(ret))
2038     {
2039         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2040         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2041         if (SUCCEEDED(ret))
2042         {
2043             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2044             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2045             if (SUCCEEDED(ret))
2046             {
2047                 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
2048                 pILFree(pidl_test);
2049             }
2050             IPersistIDList_Release(persistidl);
2051         }
2052         IShellItem_Release(shellitem);
2053     }
2054
2055     ret = pSHCreateShellItem(NULL, desktopfolder, pidl_testfile, &shellitem);
2056     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2057     if (SUCCEEDED(ret))
2058     {
2059         ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2060         ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
2061         if (SUCCEEDED(ret))
2062         {
2063             ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2064             ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
2065             if (SUCCEEDED(ret))
2066             {
2067                 ok(ILIsEqual(pidl_testfile, pidl_test), "id lists are not equal\n");
2068                 pILFree(pidl_test);
2069             }
2070             IPersistIDList_Release(persistidl);
2071         }
2072
2073         IShellItem_Release(shellitem);
2074     }
2075
2076     ret = pSHCreateShellItem(NULL, NULL, pidl_desktop, &shellitem);
2077     ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
2078     if (SUCCEEDED(ret))
2079     {
2080         ret = IShellItem_GetParent(shellitem, &shellitem2);
2081         ok(FAILED(ret), "Got 0x%08x\n", ret);
2082         if(SUCCEEDED(ret)) IShellItem_Release(shellitem2);
2083         IShellItem_Release(shellitem);
2084     }
2085
2086     /* SHCreateItemFromParsingName */
2087     if(pSHCreateItemFromParsingName)
2088     {
2089         if(0)
2090         {
2091             /* Crashes under windows 7 */
2092             ret = pSHCreateItemFromParsingName(NULL, NULL, &IID_IShellItem, NULL);
2093         }
2094
2095         shellitem = (void*)0xdeadbeef;
2096         ret = pSHCreateItemFromParsingName(NULL, NULL, &IID_IShellItem, (void**)&shellitem);
2097         ok(ret == E_INVALIDARG, "SHCreateItemFromParsingName returned %x\n", ret);
2098         ok(shellitem == NULL, "shellitem was %p.\n", shellitem);
2099
2100         ret = pSHCreateItemFromParsingName(testfileW, NULL, &IID_IShellItem, (void**)&shellitem);
2101         ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND),
2102            "SHCreateItemFromParsingName returned %x\n", ret);
2103         if(SUCCEEDED(ret)) IShellItem_Release(shellitem);
2104
2105         lstrcpyW(fnbufW, curdirW);
2106         myPathAddBackslashW(fnbufW);
2107         lstrcatW(fnbufW, testfileW);
2108
2109         ret = pSHCreateItemFromParsingName(fnbufW, NULL, &IID_IShellItem, (void**)&shellitem);
2110         ok(ret == S_OK, "SHCreateItemFromParsingName returned %x\n", ret);
2111         if(SUCCEEDED(ret))
2112         {
2113             LPWSTR tmp_fname;
2114             ret = IShellItem_GetDisplayName(shellitem, SIGDN_FILESYSPATH, &tmp_fname);
2115             ok(ret == S_OK, "GetDisplayName returned %x\n", ret);
2116             if(SUCCEEDED(ret))
2117             {
2118                 ok(!lstrcmpW(fnbufW, tmp_fname), "strings not equal\n");
2119                 CoTaskMemFree(tmp_fname);
2120             }
2121             IShellItem_Release(shellitem);
2122         }
2123     }
2124     else
2125         win_skip("No SHCreateItemFromParsingName\n");
2126
2127
2128     /* SHCreateItemFromIDList */
2129     if(pSHCreateItemFromIDList)
2130     {
2131         if(0)
2132         {
2133             /* Crashes under win7 */
2134             ret = pSHCreateItemFromIDList(NULL, &IID_IShellItem, NULL);
2135         }
2136
2137         ret = pSHCreateItemFromIDList(NULL, &IID_IShellItem, (void**)&shellitem);
2138         ok(ret == E_INVALIDARG, "SHCreateItemFromIDList returned %x\n", ret);
2139
2140         ret = pSHCreateItemFromIDList(pidl_cwd, &IID_IShellItem, (void**)&shellitem);
2141         ok(ret == S_OK, "SHCreateItemFromIDList returned %x\n", ret);
2142         if (SUCCEEDED(ret))
2143         {
2144             ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2145             ok(ret == S_OK, "QueryInterface returned %x\n", ret);
2146             if (SUCCEEDED(ret))
2147             {
2148                 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2149                 ok(ret == S_OK, "GetIDList returned %x\n", ret);
2150                 if (SUCCEEDED(ret))
2151                 {
2152                     ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
2153                     pILFree(pidl_test);
2154                 }
2155                 IPersistIDList_Release(persistidl);
2156             }
2157             IShellItem_Release(shellitem);
2158         }
2159
2160         ret = pSHCreateItemFromIDList(pidl_testfile, &IID_IShellItem, (void**)&shellitem);
2161         ok(ret == S_OK, "SHCreateItemFromIDList returned %x\n", ret);
2162         if (SUCCEEDED(ret))
2163         {
2164             ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
2165             ok(ret == S_OK, "QueryInterface returned %x\n", ret);
2166             if (SUCCEEDED(ret))
2167             {
2168                 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
2169                 ok(ret == S_OK, "GetIDList returned %x\n", ret);
2170                 if (SUCCEEDED(ret))
2171                 {
2172                     ok(ILIsEqual(pidl_testfile, pidl_test), "id lists are not equal\n");
2173                     pILFree(pidl_test);
2174                 }
2175                 IPersistIDList_Release(persistidl);
2176             }
2177             IShellItem_Release(shellitem);
2178         }
2179     }
2180     else
2181         win_skip("No SHCreateItemFromIDList\n");
2182
2183     DeleteFileA(".\\testfile");
2184     pILFree(pidl_abstestfile);
2185     pILFree(pidl_testfile);
2186     pILFree(pidl_desktop);
2187     pILFree(pidl_cwd);
2188     IShellFolder_Release(currentfolder);
2189     IShellFolder_Release(desktopfolder);
2190 }
2191
2192 static void test_SHGetNameFromIDList(void)
2193 {
2194     IShellItem *shellitem;
2195     LPITEMIDLIST pidl;
2196     LPWSTR name_string;
2197     HRESULT hres;
2198     UINT i;
2199     static const DWORD flags[] = {
2200         SIGDN_NORMALDISPLAY, SIGDN_PARENTRELATIVEPARSING,
2201         SIGDN_DESKTOPABSOLUTEPARSING,SIGDN_PARENTRELATIVEEDITING,
2202         SIGDN_DESKTOPABSOLUTEEDITING, /*SIGDN_FILESYSPATH, SIGDN_URL, */
2203         SIGDN_PARENTRELATIVEFORADDRESSBAR,SIGDN_PARENTRELATIVE, -1234};
2204
2205     if(!pSHGetNameFromIDList)
2206     {
2207         win_skip("SHGetNameFromIDList missing.\n");
2208         return;
2209     }
2210
2211     /* These should be available on any platform that passed the above test. */
2212     ok(pSHCreateShellItem != NULL, "SHCreateShellItem missing.\n");
2213     ok(pSHBindToParent != NULL, "SHBindToParent missing.\n");
2214     ok(pSHGetSpecialFolderLocation != NULL, "SHGetSpecialFolderLocation missing.\n");
2215     ok(pStrRetToBufW != NULL, "StrRetToBufW missing.\n");
2216
2217     if(0)
2218     {
2219         /* Crashes under win7 */
2220         hres = pSHGetNameFromIDList(NULL, 0, NULL);
2221     }
2222
2223     hres = pSHGetNameFromIDList(NULL, 0, &name_string);
2224     ok(hres == E_INVALIDARG, "Got 0x%08x\n", hres);
2225
2226     /* Test the desktop */
2227     hres = pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl);
2228     ok(hres == S_OK, "Got 0x%08x\n", hres);
2229     hres = pSHCreateShellItem(NULL, NULL, pidl, &shellitem);
2230     ok(hres == S_OK, "Got 0x%08x\n", hres);
2231     if(SUCCEEDED(hres))
2232     {
2233         WCHAR *nameSI, *nameSH;
2234         WCHAR buf[MAX_PATH];
2235         HRESULT hrSI, hrSH, hrSF;
2236         STRRET strret;
2237         IShellFolder *psf;
2238         BOOL res;
2239
2240         SHGetDesktopFolder(&psf);
2241         for(i = 0; flags[i] != -1234; i++)
2242         {
2243             hrSI = IShellItem_GetDisplayName(shellitem, flags[i], &nameSI);
2244             ok(hrSI == S_OK, "Got 0x%08x\n", hrSI);
2245             hrSH = pSHGetNameFromIDList(pidl, flags[i], &nameSH);
2246             ok(hrSH == S_OK, "Got 0x%08x\n", hrSH);
2247             hrSF = IShellFolder_GetDisplayNameOf(psf, pidl, flags[i] & 0xffff, &strret);
2248             ok(hrSF == S_OK, "Got 0x%08x\n", hrSF);
2249
2250             if(SUCCEEDED(hrSI) && SUCCEEDED(hrSH))
2251                 ok(!lstrcmpW(nameSI, nameSH), "Strings differ.\n");
2252
2253             if(SUCCEEDED(hrSF))
2254             {
2255                 pStrRetToBufW(&strret, NULL, buf, MAX_PATH);
2256                 if(SUCCEEDED(hrSI))
2257                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2258                 if(SUCCEEDED(hrSF))
2259                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2260             }
2261             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2262             if(SUCCEEDED(hrSH)) CoTaskMemFree(nameSH);
2263         }
2264         IShellFolder_Release(psf);
2265
2266         if(pSHGetPathFromIDListW){
2267             hrSI = pSHGetNameFromIDList(pidl, SIGDN_FILESYSPATH, &nameSI);
2268             ok(hrSI == S_OK, "Got 0x%08x\n", hrSI);
2269             res = pSHGetPathFromIDListW(pidl, buf);
2270             ok(res == TRUE, "Got %d\n", res);
2271             if(SUCCEEDED(hrSI) && res)
2272                 ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2273             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2274         }else
2275             win_skip("pSHGetPathFromIDListW not available\n");
2276
2277         hres = pSHGetNameFromIDList(pidl, SIGDN_URL, &name_string);
2278         todo_wine ok(hres == S_OK, "Got 0x%08x\n", hres);
2279         if(SUCCEEDED(hres)) CoTaskMemFree(name_string);
2280
2281         IShellItem_Release(shellitem);
2282     }
2283     pILFree(pidl);
2284
2285     /* Test the control panel */
2286     hres = pSHGetSpecialFolderLocation(NULL, CSIDL_CONTROLS, &pidl);
2287     ok(hres == S_OK, "Got 0x%08x\n", hres);
2288     hres = pSHCreateShellItem(NULL, NULL, pidl, &shellitem);
2289     ok(hres == S_OK, "Got 0x%08x\n", hres);
2290     if(SUCCEEDED(hres))
2291     {
2292         WCHAR *nameSI, *nameSH;
2293         WCHAR buf[MAX_PATH];
2294         HRESULT hrSI, hrSH, hrSF;
2295         STRRET strret;
2296         IShellFolder *psf;
2297         BOOL res;
2298
2299         SHGetDesktopFolder(&psf);
2300         for(i = 0; flags[i] != -1234; i++)
2301         {
2302             hrSI = IShellItem_GetDisplayName(shellitem, flags[i], &nameSI);
2303             ok(hrSI == S_OK, "Got 0x%08x\n", hrSI);
2304             hrSH = pSHGetNameFromIDList(pidl, flags[i], &nameSH);
2305             ok(hrSH == S_OK, "Got 0x%08x\n", hrSH);
2306             hrSF = IShellFolder_GetDisplayNameOf(psf, pidl, flags[i] & 0xffff, &strret);
2307             ok(hrSF == S_OK, "Got 0x%08x\n", hrSF);
2308
2309             if(SUCCEEDED(hrSI) && SUCCEEDED(hrSH))
2310                 ok(!lstrcmpW(nameSI, nameSH), "Strings differ.\n");
2311
2312             if(SUCCEEDED(hrSF))
2313             {
2314                 pStrRetToBufW(&strret, NULL, buf, MAX_PATH);
2315                 if(SUCCEEDED(hrSI))
2316                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2317                 if(SUCCEEDED(hrSF))
2318                     ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2319             }
2320             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2321             if(SUCCEEDED(hrSH)) CoTaskMemFree(nameSH);
2322         }
2323         IShellFolder_Release(psf);
2324
2325         if(pSHGetPathFromIDListW){
2326             hrSI = pSHGetNameFromIDList(pidl, SIGDN_FILESYSPATH, &nameSI);
2327             ok(hrSI == E_INVALIDARG, "Got 0x%08x\n", hrSI);
2328             res = pSHGetPathFromIDListW(pidl, buf);
2329             ok(res == FALSE, "Got %d\n", res);
2330             if(SUCCEEDED(hrSI) && res)
2331                 ok(!lstrcmpW(nameSI, buf), "Strings differ.\n");
2332             if(SUCCEEDED(hrSI)) CoTaskMemFree(nameSI);
2333         }else
2334             win_skip("pSHGetPathFromIDListW not available\n");
2335
2336         hres = pSHGetNameFromIDList(pidl, SIGDN_URL, &name_string);
2337         todo_wine ok(hres == E_NOTIMPL /* Win7 */ || hres == S_OK /* Vista */,
2338                      "Got 0x%08x\n", hres);
2339         if(SUCCEEDED(hres)) CoTaskMemFree(name_string);
2340
2341         IShellItem_Release(shellitem);
2342     }
2343     pILFree(pidl);
2344 }
2345
2346 static void test_SHGetItemFromDataObject(void)
2347 {
2348     IShellFolder *psfdesktop;
2349     IShellItem *psi;
2350     IShellView *psv;
2351     HRESULT hres;
2352
2353     if(!pSHGetItemFromDataObject)
2354     {
2355         win_skip("No SHGetItemFromDataObject.\n");
2356         return;
2357     }
2358
2359     if(0)
2360     {
2361         /* Crashes under win7 */
2362         hres = pSHGetItemFromDataObject(NULL, 0, &IID_IShellItem, NULL);
2363     }
2364
2365     hres = pSHGetItemFromDataObject(NULL, 0, &IID_IShellItem, (void**)&psv);
2366     ok(hres == E_INVALIDARG, "got 0x%08x\n", hres);
2367
2368     SHGetDesktopFolder(&psfdesktop);
2369
2370     hres = IShellFolder_CreateViewObject(psfdesktop, NULL, &IID_IShellView, (void**)&psv);
2371     ok(hres == S_OK, "got 0x%08x\n", hres);
2372     if(SUCCEEDED(hres))
2373     {
2374         IEnumIDList *peidl;
2375         IDataObject *pdo;
2376         SHCONTF enum_flags;
2377
2378         enum_flags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
2379         hres = IShellFolder_EnumObjects(psfdesktop, NULL, enum_flags, &peidl);
2380         ok(hres == S_OK, "got 0x%08x\n", hres);
2381         if(SUCCEEDED(hres))
2382         {
2383             LPITEMIDLIST apidl[5];
2384             UINT count = 0, i;
2385
2386             for(count = 0; count < 5; count++)
2387                 if(IEnumIDList_Next(peidl, 1, &apidl[count], NULL) != S_OK)
2388                     break;
2389
2390             if(count)
2391             {
2392                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, 1, (LPCITEMIDLIST*)apidl,
2393                                                   &IID_IDataObject, NULL, (void**)&pdo);
2394                 ok(hres == S_OK, "got 0x%08x\n", hres);
2395                 if(SUCCEEDED(hres))
2396                 {
2397                     hres = pSHGetItemFromDataObject(pdo, DOGIF_DEFAULT, &IID_IShellItem, (void**)&psi);
2398                     ok(hres == S_OK, "got 0x%08x\n", hres);
2399                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2400                     hres = pSHGetItemFromDataObject(pdo, DOGIF_TRAVERSE_LINK, &IID_IShellItem, (void**)&psi);
2401                     ok(hres == S_OK, "got 0x%08x\n", hres);
2402                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2403                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_HDROP, &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_NO_URL, &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_ONLY_IF_ONE, &IID_IShellItem, (void**)&psi);
2410                     ok(hres == S_OK, "got 0x%08x\n", hres);
2411                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2412
2413                     IDataObject_Release(pdo);
2414                 }
2415             }
2416             else
2417                 skip("No file(s) found - skipping single-file test.\n");
2418
2419             if(count > 1)
2420             {
2421                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, count, (LPCITEMIDLIST*)apidl,
2422                                                   &IID_IDataObject, NULL, (void**)&pdo);
2423                 ok(hres == S_OK, "got 0x%08x\n", hres);
2424                 if(SUCCEEDED(hres))
2425                 {
2426                     hres = pSHGetItemFromDataObject(pdo, DOGIF_DEFAULT, &IID_IShellItem, (void**)&psi);
2427                     ok(hres == S_OK, "got 0x%08x\n", hres);
2428                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2429                     hres = pSHGetItemFromDataObject(pdo, DOGIF_TRAVERSE_LINK, &IID_IShellItem, (void**)&psi);
2430                     ok(hres == S_OK, "got 0x%08x\n", hres);
2431                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2432                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_HDROP, &IID_IShellItem, (void**)&psi);
2433                     ok(hres == S_OK, "got 0x%08x\n", hres);
2434                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2435                     hres = pSHGetItemFromDataObject(pdo, DOGIF_NO_URL, &IID_IShellItem, (void**)&psi);
2436                     ok(hres == S_OK, "got 0x%08x\n", hres);
2437                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2438                     hres = pSHGetItemFromDataObject(pdo, DOGIF_ONLY_IF_ONE, &IID_IShellItem, (void**)&psi);
2439                     ok(hres == E_FAIL, "got 0x%08x\n", hres);
2440                     if(SUCCEEDED(hres)) IShellItem_Release(psi);
2441                     IDataObject_Release(pdo);
2442                 }
2443             }
2444             else
2445                 skip("zero or one file found - skipping multi-file test.\n");
2446
2447             for(i = 0; i < count; i++)
2448                 pILFree(apidl[i]);
2449
2450             IEnumIDList_Release(peidl);
2451         }
2452
2453         IShellView_Release(psv);
2454     }
2455
2456     IShellFolder_Release(psfdesktop);
2457 }
2458
2459 static void test_ShellItemCompare(void)
2460 {
2461     IShellItem *psi[9]; /* a\a, a\b, a\c, b\a, .. */
2462     IShellItem *psi_a, *psi_b, *psi_c;
2463     IShellFolder *psf_desktop, *psf_current;
2464     LPITEMIDLIST pidl_cwd;
2465     WCHAR curdirW[MAX_PATH];
2466     BOOL failed;
2467     HRESULT hr;
2468     static const WCHAR filesW[][9] = {
2469         {'a','\\','a',0}, {'a','\\','b',0}, {'a','\\','c',0},
2470         {'b','\\','a',0}, {'b','\\','b',0}, {'b','\\','c',0},
2471         {'c','\\','a',0}, {'c','\\','b',0}, {'c','\\','c',0} };
2472     int order;
2473     UINT i;
2474
2475     if(!pSHCreateShellItem)
2476     {
2477         win_skip("SHCreateShellItem missing.\n");
2478         return;
2479     }
2480
2481     GetCurrentDirectoryW(MAX_PATH, curdirW);
2482     if(!lstrlenW(curdirW))
2483     {
2484         skip("Failed to get current directory, skipping.\n");
2485         return;
2486     }
2487
2488     CreateDirectoryA(".\\a", NULL);
2489     CreateDirectoryA(".\\b", NULL);
2490     CreateDirectoryA(".\\c", NULL);
2491     CreateTestFile(".\\a\\a");
2492     CreateTestFile(".\\a\\b");
2493     CreateTestFile(".\\a\\c");
2494     CreateTestFile(".\\b\\a");
2495     CreateTestFile(".\\b\\b");
2496     CreateTestFile(".\\b\\c");
2497     CreateTestFile(".\\c\\a");
2498     CreateTestFile(".\\c\\b");
2499     CreateTestFile(".\\c\\c");
2500
2501     SHGetDesktopFolder(&psf_desktop);
2502     hr = IShellFolder_ParseDisplayName(psf_desktop, NULL, NULL, curdirW, NULL, &pidl_cwd, NULL);
2503     ok(SUCCEEDED(hr), "ParseDisplayName returned %x\n", hr);
2504     hr = IShellFolder_BindToObject(psf_desktop, pidl_cwd, NULL, &IID_IShellFolder, (void**)&psf_current);
2505     ok(SUCCEEDED(hr), "BindToObject returned %x\n", hr);
2506     IShellFolder_Release(psf_desktop);
2507
2508     /* Generate ShellItems for the files */
2509     ZeroMemory(&psi, sizeof(IShellItem*)*9);
2510     failed = FALSE;
2511     for(i = 0; i < 9; i++)
2512     {
2513         LPITEMIDLIST pidl_testfile = NULL;
2514
2515         hr = IShellFolder_ParseDisplayName(psf_current, NULL, NULL, (LPWSTR)filesW[i],
2516                                            NULL, &pidl_testfile, NULL);
2517         ok(SUCCEEDED(hr), "ParseDisplayName returned %x\n", hr);
2518         if(SUCCEEDED(hr))
2519         {
2520             hr = pSHCreateShellItem(NULL, NULL, pidl_testfile, &psi[i]);
2521             ok(hr == S_OK, "Got 0x%08x\n", hr);
2522             pILFree(pidl_testfile);
2523         }
2524         if(FAILED(hr)) failed = TRUE;
2525     }
2526     if(failed)
2527     {
2528         skip("Failed to create all shellitems.\n");
2529         goto cleanup;
2530     }
2531
2532     /* Generate ShellItems for the folders */
2533     psi_a = psi_b = psi_c = NULL;
2534     hr = IShellItem_GetParent(psi[0], &psi_a);
2535     ok(hr == S_OK, "Got 0x%08x\n", hr);
2536     if(FAILED(hr)) failed = TRUE;
2537     hr = IShellItem_GetParent(psi[3], &psi_b);
2538     ok(hr == S_OK, "Got 0x%08x\n", hr);
2539     if(FAILED(hr)) failed = TRUE;
2540     hr = IShellItem_GetParent(psi[6], &psi_c);
2541     ok(hr == S_OK, "Got 0x%08x\n", hr);
2542     if(FAILED(hr)) failed = TRUE;
2543
2544     if(failed)
2545     {
2546         skip("Failed to create shellitems.\n");
2547         goto cleanup;
2548     }
2549
2550     if(0)
2551     {
2552         /* Crashes on native (win7, winxp) */
2553         hr = IShellItem_Compare(psi_a, NULL, 0, NULL);
2554         hr = IShellItem_Compare(psi_a, psi_b, 0, NULL);
2555         hr = IShellItem_Compare(psi_a, NULL, 0, &order);
2556     }
2557
2558     /* Basics */
2559     for(i = 0; i < 9; i++)
2560     {
2561         hr = IShellItem_Compare(psi[i], psi[i], SICHINT_DISPLAY, &order);
2562         ok(hr == S_OK, "Got 0x%08x\n", hr);
2563         ok(order == 0, "Got order %d\n", order);
2564         hr = IShellItem_Compare(psi[i], psi[i], SICHINT_CANONICAL, &order);
2565         ok(hr == S_OK, "Got 0x%08x\n", hr);
2566         ok(order == 0, "Got order %d\n", order);
2567         hr = IShellItem_Compare(psi[i], psi[i], SICHINT_ALLFIELDS, &order);
2568         ok(hr == S_OK, "Got 0x%08x\n", hr);
2569         ok(order == 0, "Got order %d\n", order);
2570     }
2571
2572     /* Order */
2573     /* a\b:a\a , a\b:a\c, a\b:a\b */
2574     hr = IShellItem_Compare(psi[1], psi[0], SICHINT_DISPLAY, &order);
2575     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2576     ok(order == 1, "Got order %d\n", order);
2577     hr = IShellItem_Compare(psi[1], psi[2], SICHINT_DISPLAY, &order);
2578     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2579     ok(order == -1, "Got order %d\n", order);
2580     hr = IShellItem_Compare(psi[1], psi[1], SICHINT_DISPLAY, &order);
2581     ok(hr == S_OK, "Got 0x%08x\n", hr);
2582     ok(order == 0, "Got order %d\n", order);
2583
2584     /* b\b:a\b, b\b:c\b, b\b:c\b */
2585     hr = IShellItem_Compare(psi[4], psi[1], SICHINT_DISPLAY, &order);
2586     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2587     ok(order == 1, "Got order %d\n", order);
2588     hr = IShellItem_Compare(psi[4], psi[7], SICHINT_DISPLAY, &order);
2589     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2590     ok(order == -1, "Got order %d\n", order);
2591     hr = IShellItem_Compare(psi[4], psi[4], SICHINT_DISPLAY, &order);
2592     ok(hr == S_OK, "Got 0x%08x\n", hr);
2593     ok(order == 0, "Got order %d\n", order);
2594
2595     /* b:a\a, b:a\c, b:a\b */
2596     hr = IShellItem_Compare(psi_b, psi[0], SICHINT_DISPLAY, &order);
2597     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2598     todo_wine ok(order == 1, "Got order %d\n", order);
2599     hr = IShellItem_Compare(psi_b, psi[2], SICHINT_DISPLAY, &order);
2600     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2601     todo_wine ok(order == 1, "Got order %d\n", order);
2602     hr = IShellItem_Compare(psi_b, psi[1], SICHINT_DISPLAY, &order);
2603     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2604     todo_wine ok(order == 1, "Got order %d\n", order);
2605
2606     /* b:c\a, b:c\c, b:c\b */
2607     hr = IShellItem_Compare(psi_b, psi[6], SICHINT_DISPLAY, &order);
2608     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2609     ok(order == -1, "Got order %d\n", order);
2610     hr = IShellItem_Compare(psi_b, psi[8], SICHINT_DISPLAY, &order);
2611     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2612     ok(order == -1, "Got order %d\n", order);
2613     hr = IShellItem_Compare(psi_b, psi[7], SICHINT_DISPLAY, &order);
2614     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2615     ok(order == -1, "Got order %d\n", order);
2616
2617     /* a\b:a\a , a\b:a\c, a\b:a\b */
2618     hr = IShellItem_Compare(psi[1], psi[0], SICHINT_CANONICAL, &order);
2619     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2620     ok(order == 1, "Got order %d\n", order);
2621     hr = IShellItem_Compare(psi[1], psi[2], SICHINT_CANONICAL, &order);
2622     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2623     ok(order == -1, "Got order %d\n", order);
2624     hr = IShellItem_Compare(psi[1], psi[1], SICHINT_CANONICAL, &order);
2625     ok(hr == S_OK, "Got 0x%08x\n", hr);
2626     ok(order == 0, "Got order %d\n", order);
2627
2628     /* b\b:a\b, b\b:c\b, b\b:c\b */
2629     hr = IShellItem_Compare(psi[4], psi[1], SICHINT_CANONICAL, &order);
2630     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2631     ok(order == 1, "Got order %d\n", order);
2632     hr = IShellItem_Compare(psi[4], psi[7], SICHINT_CANONICAL, &order);
2633     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2634     ok(order == -1, "Got order %d\n", order);
2635     hr = IShellItem_Compare(psi[4], psi[4], SICHINT_CANONICAL, &order);
2636     ok(hr == S_OK, "Got 0x%08x\n", hr);
2637     ok(order == 0, "Got order %d\n", order);
2638
2639     /* b:a\a, b:a\c, b:a\b */
2640     hr = IShellItem_Compare(psi_b, psi[0], SICHINT_CANONICAL, &order);
2641     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2642     todo_wine ok(order == 1, "Got order %d\n", order);
2643     hr = IShellItem_Compare(psi_b, psi[2], SICHINT_CANONICAL, &order);
2644     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2645     todo_wine ok(order == 1, "Got order %d\n", order);
2646     hr = IShellItem_Compare(psi_b, psi[1], SICHINT_CANONICAL, &order);
2647     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2648     todo_wine ok(order == 1, "Got order %d\n", order);
2649
2650     /* b:c\a, b:c\c, b:c\b */
2651     hr = IShellItem_Compare(psi_b, psi[6], SICHINT_CANONICAL, &order);
2652     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2653     ok(order == -1, "Got order %d\n", order);
2654     hr = IShellItem_Compare(psi_b, psi[8], SICHINT_CANONICAL, &order);
2655     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2656     ok(order == -1, "Got order %d\n", order);
2657     hr = IShellItem_Compare(psi_b, psi[7], SICHINT_CANONICAL, &order);
2658     ok(hr == S_FALSE, "Got 0x%08x\n", hr);
2659     ok(order == -1, "Got order %d\n", order);
2660
2661 cleanup:
2662     IShellFolder_Release(psf_current);
2663
2664     DeleteFileA(".\\a\\a");
2665     DeleteFileA(".\\a\\b");
2666     DeleteFileA(".\\a\\c");
2667     DeleteFileA(".\\b\\a");
2668     DeleteFileA(".\\b\\b");
2669     DeleteFileA(".\\b\\c");
2670     DeleteFileA(".\\c\\a");
2671     DeleteFileA(".\\c\\b");
2672     DeleteFileA(".\\c\\c");
2673     RemoveDirectoryA(".\\a");
2674     RemoveDirectoryA(".\\b");
2675     RemoveDirectoryA(".\\c");
2676
2677     if(psi_a) IShellItem_Release(psi_a);
2678     if(psi_b) IShellItem_Release(psi_b);
2679     if(psi_c) IShellItem_Release(psi_c);
2680
2681     for(i = 0; i < 9; i++)
2682         if(psi[i]) IShellItem_Release(psi[i]);
2683 }
2684
2685 /**************************************************************/
2686 /* IUnknown implementation for counting QueryInterface calls. */
2687 typedef struct {
2688     const IUnknownVtbl *lpVtbl;
2689     struct if_count {
2690         REFIID id;
2691         LONG count;
2692     } *ifaces;
2693     LONG unknown;
2694 } IUnknownImpl;
2695
2696 static HRESULT WINAPI unk_fnQueryInterface(IUnknown *iunk, REFIID riid, void** punk)
2697 {
2698     IUnknownImpl *This = (IUnknownImpl*)iunk;
2699     UINT i, found;
2700     for(i = found = 0; This->ifaces[i].id != NULL; i++)
2701     {
2702         if(IsEqualIID(This->ifaces[i].id, riid))
2703         {
2704             This->ifaces[i].count++;
2705             found = 1;
2706             break;
2707         }
2708     }
2709     if(!found)
2710         This->unknown++;
2711     return E_NOINTERFACE;
2712 }
2713
2714 static ULONG WINAPI unk_fnAddRef(IUnknown *iunk)
2715 {
2716     return 2;
2717 }
2718
2719 static ULONG WINAPI unk_fnRelease(IUnknown *iunk)
2720 {
2721     return 1;
2722 }
2723
2724 const IUnknownVtbl vt_IUnknown = {
2725     unk_fnQueryInterface,
2726     unk_fnAddRef,
2727     unk_fnRelease
2728 };
2729
2730 static void test_SHGetIDListFromObject(void)
2731 {
2732     IUnknownImpl *punkimpl;
2733     IShellFolder *psfdesktop;
2734     IShellView *psv;
2735     LPITEMIDLIST pidl, pidl_desktop;
2736     HRESULT hres;
2737     UINT i;
2738     struct if_count ifaces[] =
2739         { {&IID_IPersistIDList, 0},
2740           {&IID_IPersistFolder2, 0},
2741           {&IID_IDataObject, 0},
2742           {&IID_IParentAndItem, 0},
2743           {&IID_IFolderView, 0},
2744           {NULL, 0} };
2745
2746     if(!pSHGetIDListFromObject)
2747     {
2748         win_skip("SHGetIDListFromObject missing.\n");
2749         return;
2750     }
2751
2752     ok(pSHGetSpecialFolderLocation != NULL, "SHGetSpecialFolderLocation missing.\n");
2753
2754     if(0)
2755     {
2756         /* Crashes native */
2757         pSHGetIDListFromObject(NULL, NULL);
2758         pSHGetIDListFromObject((void*)0xDEADBEEF, NULL);
2759     }
2760
2761     hres = pSHGetIDListFromObject(NULL, &pidl);
2762     ok(hres == E_NOINTERFACE, "Got %x\n", hres);
2763
2764     punkimpl = HeapAlloc(GetProcessHeap(), 0, sizeof(IUnknownImpl));
2765     punkimpl->lpVtbl = &vt_IUnknown;
2766     punkimpl->ifaces = ifaces;
2767     punkimpl->unknown = 0;
2768
2769     hres = pSHGetIDListFromObject((IUnknown*)punkimpl, &pidl);
2770     ok(hres == E_NOINTERFACE, "Got %x\n", hres);
2771     ok(ifaces[0].count, "interface not requested.\n");
2772     ok(ifaces[1].count, "interface not requested.\n");
2773     ok(ifaces[2].count, "interface not requested.\n");
2774     todo_wine
2775         ok(ifaces[3].count || broken(!ifaces[3].count /*vista*/),
2776            "interface not requested.\n");
2777     ok(ifaces[4].count || broken(!ifaces[4].count /*vista*/),
2778        "interface not requested.\n");
2779
2780     ok(!punkimpl->unknown, "Got %d unknown.\n", punkimpl->unknown);
2781     HeapFree(GetProcessHeap(), 0, punkimpl);
2782
2783     pidl_desktop = NULL;
2784     pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl_desktop);
2785     ok(pidl_desktop != NULL, "Failed to get desktop pidl.\n");
2786
2787     SHGetDesktopFolder(&psfdesktop);
2788
2789     /* Test IShellItem */
2790     if(pSHCreateShellItem)
2791     {
2792         IShellItem *shellitem;
2793         hres = pSHCreateShellItem(NULL, NULL, pidl_desktop, &shellitem);
2794         ok(hres == S_OK, "got 0x%08x\n", hres);
2795         if(SUCCEEDED(hres))
2796         {
2797             hres = pSHGetIDListFromObject((IUnknown*)shellitem, &pidl);
2798             ok(hres == S_OK, "got 0x%08x\n", hres);
2799             if(SUCCEEDED(hres))
2800             {
2801                 ok(ILIsEqual(pidl_desktop, pidl), "pidl not equal.\n");
2802                 pILFree(pidl);
2803             }
2804             IShellItem_Release(shellitem);
2805         }
2806     }
2807     else
2808         skip("no SHCreateShellItem.\n");
2809
2810     /* Test IShellFolder */
2811     hres = pSHGetIDListFromObject((IUnknown*)psfdesktop, &pidl);
2812     ok(hres == S_OK, "got 0x%08x\n", hres);
2813     if(SUCCEEDED(hres))
2814     {
2815         ok(ILIsEqual(pidl_desktop, pidl), "pidl not equal.\n");
2816         pILFree(pidl);
2817     }
2818
2819     hres = IShellFolder_CreateViewObject(psfdesktop, NULL, &IID_IShellView, (void**)&psv);
2820     ok(hres == S_OK, "got 0x%08x\n", hres);
2821     if(SUCCEEDED(hres))
2822     {
2823         IEnumIDList *peidl;
2824         IDataObject *pdo;
2825         SHCONTF enum_flags;
2826
2827         /* Test IFolderView */
2828         hres = pSHGetIDListFromObject((IUnknown*)psv, &pidl);
2829         ok(hres == S_OK, "got 0x%08x\n", hres);
2830         if(SUCCEEDED(hres))
2831         {
2832             ok(ILIsEqual(pidl_desktop, pidl), "pidl not equal.\n");
2833             pILFree(pidl);
2834         }
2835
2836         /* Test IDataObject */
2837         enum_flags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
2838         hres = IShellFolder_EnumObjects(psfdesktop, NULL, enum_flags, &peidl);
2839         ok(hres == S_OK, "got 0x%08x\n", hres);
2840         if(SUCCEEDED(hres))
2841         {
2842             LPITEMIDLIST apidl[5];
2843             UINT count = 0;
2844             for(count = 0; count < 5; count++)
2845                 if(IEnumIDList_Next(peidl, 1, &apidl[count], NULL) != S_OK)
2846                     break;
2847
2848             if(count)
2849             {
2850                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, 1, (LPCITEMIDLIST*)apidl,
2851                                                   &IID_IDataObject, NULL, (void**)&pdo);
2852                 ok(hres == S_OK, "got 0x%08x\n", hres);
2853                 if(SUCCEEDED(hres))
2854                 {
2855                     pidl = (void*)0xDEADBEEF;
2856                     hres = pSHGetIDListFromObject((IUnknown*)pdo, &pidl);
2857                     ok(hres == S_OK, "got 0x%08x\n", hres);
2858                     ok(pidl != NULL, "pidl is NULL.\n");
2859                     ok(ILIsEqual(pidl, apidl[0]), "pidl not equal.\n");
2860                     pILFree(pidl);
2861
2862                     IDataObject_Release(pdo);
2863                 }
2864             }
2865             else
2866                 skip("No files found - skipping single-file test.\n");
2867
2868             if(count > 1)
2869             {
2870                 hres = IShellFolder_GetUIObjectOf(psfdesktop, NULL, count, (LPCITEMIDLIST*)apidl,
2871                                                   &IID_IDataObject, NULL, (void**)&pdo);
2872                 ok(hres == S_OK, "got 0x%08x\n", hres);
2873                 if(SUCCEEDED(hres))
2874                 {
2875                     pidl = (void*)0xDEADBEEF;
2876                     hres = pSHGetIDListFromObject((IUnknown*)pdo, &pidl);
2877                     ok(hres == E_NOINTERFACE || hres == E_FAIL /*Vista*/,
2878                        "got 0x%08x\n", hres);
2879                     ok(pidl == NULL, "pidl is not NULL.\n");
2880
2881                     IDataObject_Release(pdo);
2882                 }
2883             }
2884             else
2885                 skip("zero or one file found - skipping multi-file test.\n");
2886
2887             for(i = 0; i < count; i++)
2888                 pILFree(apidl[i]);
2889
2890             IEnumIDList_Release(peidl);
2891         }
2892
2893         IShellView_Release(psv);
2894     }
2895
2896     IShellFolder_Release(psfdesktop);
2897     pILFree(pidl_desktop);
2898 }
2899
2900 static void test_SHGetItemFromObject(void)
2901 {
2902     IUnknownImpl *punkimpl;
2903     IShellFolder *psfdesktop;
2904     LPITEMIDLIST pidl;
2905     IShellItem *psi;
2906     IUnknown *punk;
2907     HRESULT hres;
2908     struct if_count ifaces[] =
2909         { {&IID_IPersistIDList, 0},
2910           {&IID_IPersistFolder2, 0},
2911           {&IID_IDataObject, 0},
2912           {&IID_IParentAndItem, 0},
2913           {&IID_IFolderView, 0},
2914           {NULL, 0} };
2915
2916     if(!pSHGetItemFromObject)
2917     {
2918         skip("No SHGetItemFromObject.\n");
2919         return;
2920     }
2921
2922     SHGetDesktopFolder(&psfdesktop);
2923
2924     if(0)
2925     {
2926         /* Crashes with Windows 7 */
2927         hres = pSHGetItemFromObject((IUnknown*)psfdesktop, &IID_IUnknown, NULL);
2928         hres = pSHGetItemFromObject(NULL, &IID_IUnknown, NULL);
2929         hres = pSHGetItemFromObject((IUnknown*)psfdesktop, NULL, (void**)&punk);
2930     }
2931
2932     hres = pSHGetItemFromObject(NULL, &IID_IUnknown, (void**)&punk);
2933     ok(hres == E_NOINTERFACE, "Got 0x%08x\n", hres);
2934
2935     punkimpl = HeapAlloc(GetProcessHeap(), 0, sizeof(IUnknownImpl));
2936     punkimpl->lpVtbl = &vt_IUnknown;
2937     punkimpl->ifaces = ifaces;
2938     punkimpl->unknown = 0;
2939
2940     /* The same as SHGetIDListFromObject */
2941     hres = pSHGetIDListFromObject((IUnknown*)punkimpl, &pidl);
2942     ok(hres == E_NOINTERFACE, "Got %x\n", hres);
2943     ok(ifaces[0].count, "interface not requested.\n");
2944     ok(ifaces[1].count, "interface not requested.\n");
2945     ok(ifaces[2].count, "interface not requested.\n");
2946     todo_wine
2947         ok(ifaces[3].count || broken(!ifaces[3].count /*vista*/),
2948            "interface not requested.\n");
2949     ok(ifaces[4].count || broken(!ifaces[4].count /*vista*/),
2950        "interface not requested.\n");
2951
2952     ok(!punkimpl->unknown, "Got %d unknown.\n", punkimpl->unknown);
2953     HeapFree(GetProcessHeap(), 0, punkimpl);
2954
2955     /* Test IShellItem */
2956     hres = pSHGetItemFromObject((IUnknown*)psfdesktop, &IID_IShellItem, (void**)&psi);
2957     ok(hres == S_OK, "Got 0x%08x\n", hres);
2958     if(SUCCEEDED(hres))
2959     {
2960         IShellItem *psi2;
2961         hres = pSHGetItemFromObject((IUnknown*)psi, &IID_IShellItem, (void**)&psi2);
2962         ok(hres == S_OK, "Got 0x%08x\n", hres);
2963         if(SUCCEEDED(hres))
2964         {
2965             todo_wine
2966                 ok(psi == psi2, "Different instances (%p != %p).\n", psi, psi2);
2967             IShellItem_Release(psi2);
2968         }
2969         IShellItem_Release(psi);
2970     }
2971
2972     IShellFolder_Release(psfdesktop);
2973 }
2974
2975 static void test_SHCreateShellItemArray(void)
2976 {
2977     IShellFolder *pdesktopsf, *psf;
2978     IShellItemArray *psia;
2979     IEnumIDList *peidl;
2980     HRESULT hr;
2981     WCHAR cTestDirW[MAX_PATH];
2982     LPITEMIDLIST pidl_testdir, pidl;
2983     static const WCHAR testdirW[] = {'t','e','s','t','d','i','r',0};
2984
2985     if(!pSHCreateShellItemArray) {
2986         skip("No pSHCreateShellItemArray!\n");
2987         return;
2988     }
2989
2990     ok(pSHGetSpecialFolderLocation != NULL, "SHGetSpecialFolderLocation missing.\n");
2991
2992     if(0)
2993     {
2994         /* Crashes under native */
2995         pSHCreateShellItemArray(NULL, NULL, 0, NULL, NULL);
2996         pSHCreateShellItemArray(NULL, NULL, 1, NULL, NULL);
2997         pSHCreateShellItemArray(NULL, pdesktopsf, 0, NULL, NULL);
2998         pSHCreateShellItemArray(pidl, NULL, 0, NULL, NULL);
2999     }
3000
3001     hr = pSHCreateShellItemArray(NULL, NULL, 0, NULL, &psia);
3002     ok(hr == E_POINTER, "got 0x%08x\n", hr);
3003
3004     SHGetDesktopFolder(&pdesktopsf);
3005     hr = pSHCreateShellItemArray(NULL, pdesktopsf, 0, NULL, &psia);
3006     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3007
3008     hr = pSHCreateShellItemArray(NULL, pdesktopsf, 1, NULL, &psia);
3009     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3010
3011     pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl);
3012     hr = pSHCreateShellItemArray(pidl, NULL, 0, NULL, &psia);
3013     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3014     pILFree(pidl);
3015
3016     GetCurrentDirectoryW(MAX_PATH, cTestDirW);
3017     myPathAddBackslashW(cTestDirW);
3018     lstrcatW(cTestDirW, testdirW);
3019
3020     CreateFilesFolders();
3021
3022     hr = IShellFolder_ParseDisplayName(pdesktopsf, NULL, NULL, cTestDirW, NULL, &pidl_testdir, 0);
3023     ok(hr == S_OK, "got 0x%08x\n", hr);
3024     if(SUCCEEDED(hr))
3025     {
3026         hr = IShellFolder_BindToObject(pdesktopsf, pidl_testdir, NULL, (REFIID)&IID_IShellFolder,
3027                                        (void**)&psf);
3028         ok(hr == S_OK, "Got 0x%08x\n", hr);
3029     }
3030     IShellFolder_Release(pdesktopsf);
3031
3032     if(FAILED(hr))
3033     {
3034         skip("Failed to set up environment for SHCreateShellItemArray tests.\n");
3035         pILFree(pidl_testdir);
3036         Cleanup();
3037         return;
3038     }
3039
3040     hr = IShellFolder_EnumObjects(psf, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &peidl);
3041     ok(hr == S_OK, "Got %08x\n", hr);
3042     if(SUCCEEDED(hr))
3043     {
3044         LPITEMIDLIST apidl[5];
3045         UINT done, numitems, i;
3046
3047         for(done = 0; done < 5; done++)
3048             if(IEnumIDList_Next(peidl, 1, &apidl[done], NULL) != S_OK)
3049                 break;
3050         ok(done == 5, "Got %d pidls\n", done);
3051         IEnumIDList_Release(peidl);
3052
3053         /* Create a ShellItemArray */
3054         hr = pSHCreateShellItemArray(NULL, psf, done, (LPCITEMIDLIST*)apidl, &psia);
3055         ok(hr == S_OK, "Got 0x%08x\n", hr);
3056         if(SUCCEEDED(hr))
3057         {
3058             IShellItem *psi;
3059
3060             if(0)
3061             {
3062                 /* Crashes in Windows 7 */
3063                 hr = IShellItemArray_GetCount(psia, NULL);
3064             }
3065
3066             IShellItemArray_GetCount(psia, &numitems);
3067             ok(numitems == done, "Got %d, expected %d\n", numitems, done);
3068
3069             hr = IShellItemArray_GetItemAt(psia, numitems, &psi);
3070             ok(hr == E_FAIL, "Got 0x%08x\n", hr);
3071
3072             /* Compare all the items */
3073             for(i = 0; i < numitems; i++)
3074             {
3075                 LPITEMIDLIST pidl_abs;
3076                 pidl_abs = ILCombine(pidl_testdir, apidl[i]);
3077
3078                 hr = IShellItemArray_GetItemAt(psia, i, &psi);
3079                 ok(hr == S_OK, "(%d) Failed with 0x%08x\n", i, hr);
3080                 if(SUCCEEDED(hr))
3081                 {
3082                     hr = pSHGetIDListFromObject((IUnknown*)psi, &pidl);
3083                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3084                     if(SUCCEEDED(hr))
3085                     {
3086                         ok(ILIsEqual(pidl_abs, pidl), "Pidl not equal.\n");
3087                         pILFree(pidl);
3088                     }
3089                     IShellItem_Release(psi);
3090                 }
3091                 pILFree(pidl_abs);
3092             }
3093             for(i = 0; i < done; i++)
3094                 pILFree(apidl[i]);
3095             IShellItemArray_Release(psia);
3096         }
3097     }
3098
3099     /* SHCreateShellItemArrayFromShellItem */
3100     if(pSHCreateShellItemArrayFromShellItem)
3101     {
3102         IShellItem *psi;
3103
3104         if(0)
3105         {
3106             /* Crashes under Windows 7 */
3107             hr = pSHCreateShellItemArrayFromShellItem(NULL, &IID_IShellItemArray, NULL);
3108             hr = pSHCreateShellItemArrayFromShellItem(NULL, &IID_IShellItemArray, (void**)&psia);
3109             hr = pSHCreateShellItemArrayFromShellItem(psi, &IID_IShellItemArray, NULL);
3110         }
3111
3112         hr = pSHCreateItemFromIDList(pidl_testdir, &IID_IShellItem, (void**)&psi);
3113         ok(hr == S_OK, "Got 0x%08x\n", hr);
3114         if(SUCCEEDED(hr))
3115         {
3116             hr = pSHCreateShellItemArrayFromShellItem(psi, &IID_IShellItemArray, (void**)&psia);
3117             ok(hr == S_OK, "Got 0x%08x\n", hr);
3118             if(SUCCEEDED(hr))
3119             {
3120                 IShellItem *psi2;
3121                 UINT count;
3122                 hr = IShellItemArray_GetCount(psia, &count);
3123                 ok(hr == S_OK, "Got 0x%08x\n", hr);
3124                 ok(count == 1, "Got count %d\n", count);
3125                 hr = IShellItemArray_GetItemAt(psia, 0, &psi2);
3126                 ok(hr == S_OK, "Got 0x%08x\n", hr);
3127                 todo_wine
3128                     ok(psi != psi2, "ShellItems are of the same instance.\n");
3129                 if(SUCCEEDED(hr))
3130                 {
3131                     LPITEMIDLIST pidl1, pidl2;
3132                     hr = pSHGetIDListFromObject((IUnknown*)psi, &pidl1);
3133                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3134                     ok(pidl1 != NULL, "pidl1 was null.\n");
3135                     hr = pSHGetIDListFromObject((IUnknown*)psi2, &pidl2);
3136                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3137                     ok(pidl2 != NULL, "pidl2 was null.\n");
3138                     ok(ILIsEqual(pidl1, pidl2), "pidls not equal.\n");
3139                     pILFree(pidl1);
3140                     pILFree(pidl2);
3141                     IShellItem_Release(psi2);
3142                 }
3143                 hr = IShellItemArray_GetItemAt(psia, 1, &psi2);
3144                 ok(hr == E_FAIL, "Got 0x%08x\n", hr);
3145                 IShellItemArray_Release(psia);
3146             }
3147             IShellItem_Release(psi);
3148         }
3149     }
3150     else
3151         skip("No SHCreateShellItemArrayFromShellItem.\n");
3152
3153     if(pSHCreateShellItemArrayFromDataObject)
3154     {
3155         IShellView *psv;
3156
3157         if(0)
3158         {
3159             /* Crashes under Windows 7 */
3160             hr = pSHCreateShellItemArrayFromDataObject(NULL, &IID_IShellItemArray, NULL);
3161         }
3162         hr = pSHCreateShellItemArrayFromDataObject(NULL, &IID_IShellItemArray, (void**)&psia);
3163         ok(hr == E_INVALIDARG, "Got 0x%08x\n", hr);
3164
3165         hr = IShellFolder_CreateViewObject(psf, NULL, &IID_IShellView, (void**)&psv);
3166         ok(hr == S_OK, "got 0x%08x\n", hr);
3167         if(SUCCEEDED(hr))
3168         {
3169             IEnumIDList *peidl;
3170             IDataObject *pdo;
3171             SHCONTF enum_flags;
3172
3173             enum_flags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS | SHCONTF_INCLUDEHIDDEN;
3174             hr = IShellFolder_EnumObjects(psf, NULL, enum_flags, &peidl);
3175             ok(hr == S_OK, "got 0x%08x\n", hr);
3176             if(SUCCEEDED(hr))
3177             {
3178                 LPITEMIDLIST apidl[5];
3179                 UINT count, i;
3180
3181                 for(count = 0; count < 5; count++)
3182                     if(IEnumIDList_Next(peidl, 1, &apidl[count], NULL) != S_OK)
3183                         break;
3184                 ok(count == 5, "Got %d\n", count);
3185
3186                 if(count)
3187                 {
3188                     hr = IShellFolder_GetUIObjectOf(psf, NULL, count, (LPCITEMIDLIST*)apidl,
3189                                                     &IID_IDataObject, NULL, (void**)&pdo);
3190                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3191                     if(SUCCEEDED(hr))
3192                     {
3193                         hr = pSHCreateShellItemArrayFromDataObject(pdo, &IID_IShellItemArray,
3194                                                                    (void**)&psia);
3195                         ok(hr == S_OK, "Got 0x%08x\n", hr);
3196                         if(SUCCEEDED(hr))
3197                         {
3198                             UINT count_sia, i;
3199                             hr = IShellItemArray_GetCount(psia, &count_sia);
3200                             ok(count_sia == count, "Counts differ (%d, %d)\n", count, count_sia);
3201                             for(i = 0; i < count_sia; i++)
3202                             {
3203                                 LPITEMIDLIST pidl_abs = ILCombine(pidl_testdir, apidl[i]);
3204                                 IShellItem *psi;
3205                                 hr = IShellItemArray_GetItemAt(psia, i, &psi);
3206                                 ok(hr == S_OK, "Got 0x%08x\n", hr);
3207                                 if(SUCCEEDED(hr))
3208                                 {
3209                                     LPITEMIDLIST pidl;
3210                                     hr = pSHGetIDListFromObject((IUnknown*)psi, &pidl);
3211                                     ok(hr == S_OK, "Got 0x%08x\n", hr);
3212                                     ok(pidl != NULL, "pidl as NULL.\n");
3213                                     ok(ILIsEqual(pidl, pidl_abs), "pidls differ.\n");
3214                                     pILFree(pidl);
3215                                     IShellItem_Release(psi);
3216                                 }
3217                                 pILFree(pidl_abs);
3218                             }
3219
3220                             IShellItemArray_Release(psia);
3221                         }
3222
3223                         IDataObject_Release(pdo);
3224                     }
3225                     for(i = 0; i < count; i++)
3226                         pILFree(apidl[i]);
3227                 }
3228                 else
3229                     skip("No files found - skipping test.\n");
3230
3231                 IEnumIDList_Release(peidl);
3232             }
3233             IShellView_Release(psv);
3234         }
3235     }
3236     else
3237         skip("No SHCreateShellItemArrayFromDataObject.\n");
3238
3239     IShellFolder_Release(psf);
3240     pILFree(pidl_testdir);
3241     Cleanup();
3242 }
3243
3244 static void test_ShellItemBindToHandler(void)
3245 {
3246     IShellItem *psi;
3247     LPITEMIDLIST pidl_desktop;
3248     HRESULT hr;
3249
3250     if(!pSHCreateShellItem)
3251     {
3252         skip("SHCreateShellItem missing.\n");
3253         return;
3254     }
3255
3256     hr = pSHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidl_desktop);
3257     ok(hr == S_OK, "Got 0x%08x\n", hr);
3258     if(SUCCEEDED(hr))
3259     {
3260         hr = pSHCreateShellItem(NULL, NULL, pidl_desktop, &psi);
3261         ok(hr == S_OK, "Got 0x%08x\n", hr);
3262     }
3263     if(SUCCEEDED(hr))
3264     {
3265         IPersistFolder2 *ppf2;
3266         IUnknown *punk;
3267
3268         if(0)
3269         {
3270             /* Crashes under Windows 7 */
3271             hr = IShellItem_BindToHandler(psi, NULL, NULL, NULL, NULL);
3272             hr = IShellItem_BindToHandler(psi, NULL, &IID_IUnknown, &IID_IUnknown, NULL);
3273         }
3274         hr = IShellItem_BindToHandler(psi, NULL, &IID_IUnknown, &IID_IUnknown, (void**)&punk);
3275         ok(hr == MK_E_NOOBJECT, "Got 0x%08x\n", hr);
3276
3277         /* BHID_SFObject */
3278         hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFObject, &IID_IShellFolder, (void**)&punk);
3279         ok(hr == S_OK, "Got 0x%08x\n", hr);
3280         if(SUCCEEDED(hr)) IUnknown_Release(punk);
3281         hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFObject, &IID_IPersistFolder2, (void**)&ppf2);
3282         ok(hr == S_OK, "Got 0x%08x\n", hr);
3283         if(SUCCEEDED(hr))
3284         {
3285             LPITEMIDLIST pidl_tmp;
3286             hr = IPersistFolder2_GetCurFolder(ppf2, &pidl_tmp);
3287             ok(hr == S_OK, "Got 0x%08x\n", hr);
3288             if(SUCCEEDED(hr))
3289             {
3290                 ok(ILIsEqual(pidl_desktop, pidl_tmp), "Pidl not equal (%p, %p)\n", pidl_desktop, pidl_tmp);
3291                 pILFree(pidl_tmp);
3292             }
3293             IPersistFolder2_Release(ppf2);
3294         }
3295
3296         /* BHID_SFUIObject */
3297         hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFUIObject, &IID_IDataObject, (void**)&punk);
3298         ok(hr == S_OK || broken(hr == E_NOINTERFACE /* XP */), "Got 0x%08x\n", hr);
3299         if(SUCCEEDED(hr)) IUnknown_Release(punk);
3300         hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFUIObject, &IID_IContextMenu, (void**)&punk);
3301         ok(hr == S_OK || broken(hr == E_NOINTERFACE /* XP */), "Got 0x%08x\n", hr);
3302         if(SUCCEEDED(hr)) IUnknown_Release(punk);
3303
3304         /* BHID_DataObject */
3305         hr = IShellItem_BindToHandler(psi, NULL, &BHID_DataObject, &IID_IDataObject, (void**)&punk);
3306         ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3307         if(SUCCEEDED(hr)) IUnknown_Release(punk);
3308
3309         todo_wine
3310         {
3311             /* BHID_SFViewObject */
3312             hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFViewObject, &IID_IShellView, (void**)&punk);
3313             ok(hr == S_OK, "Got 0x%08x\n", hr);
3314             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3315             hr = IShellItem_BindToHandler(psi, NULL, &BHID_SFViewObject, &IID_IShellFolderView, (void**)&punk);
3316             ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3317             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3318
3319             /* BHID_Storage */
3320             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Storage, &IID_IStream, (void**)&punk);
3321             ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3322             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3323             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Storage, &IID_IUnknown, (void**)&punk);
3324             ok(hr == S_OK, "Got 0x%08x\n", hr);
3325             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3326
3327             /* BHID_Stream */
3328             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Stream, &IID_IStream, (void**)&punk);
3329             ok(hr == E_NOINTERFACE, "Got 0x%08x\n", hr);
3330             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3331             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Stream, &IID_IUnknown, (void**)&punk);
3332             ok(hr == S_OK, "Got 0x%08x\n", hr);
3333             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3334
3335             /* BHID_StorageEnum */
3336             hr = IShellItem_BindToHandler(psi, NULL, &BHID_StorageEnum, &IID_IEnumShellItems, (void**)&punk);
3337             ok(hr == S_OK, "Got 0x%08x\n", hr);
3338             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3339
3340             /* BHID_Transfer */
3341             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Transfer, &IID_IUnknown, (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
3345             /* BHID_EnumItems */
3346             hr = IShellItem_BindToHandler(psi, NULL, &BHID_EnumItems, &IID_IEnumShellItems, (void**)&punk);
3347             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3348             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3349
3350             /* BHID_Filter */
3351             hr = IShellItem_BindToHandler(psi, NULL, &BHID_Filter, &IID_IUnknown, (void**)&punk);
3352             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3353             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3354
3355             /* BHID_LinkTargetItem */
3356             hr = IShellItem_BindToHandler(psi, NULL, &BHID_LinkTargetItem, &IID_IShellItem, (void**)&punk);
3357             ok(hr == E_NOINTERFACE || broken(hr == E_INVALIDARG /* XP */), "Got 0x%08x\n", hr);
3358             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3359             hr = IShellItem_BindToHandler(psi, NULL, &BHID_LinkTargetItem, &IID_IUnknown, (void**)&punk);
3360             ok(hr == E_NOINTERFACE || broken(hr == E_INVALIDARG /* XP */), "Got 0x%08x\n", hr);
3361             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3362
3363             /* BHID_PropertyStore */
3364             hr = IShellItem_BindToHandler(psi, NULL, &BHID_PropertyStore, &IID_IPropertyStore, (void**)&punk);
3365             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3366             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3367             hr = IShellItem_BindToHandler(psi, NULL, &BHID_PropertyStore, &IID_IPropertyStoreFactory, (void**)&punk);
3368             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3369             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3370
3371             /* BHID_ThumbnailHandler */
3372             hr = IShellItem_BindToHandler(psi, NULL, &BHID_ThumbnailHandler, &IID_IUnknown, (void**)&punk);
3373             ok(hr == E_INVALIDARG || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3374             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3375
3376             /* BHID_AssociationArray */
3377             hr = IShellItem_BindToHandler(psi, NULL, &BHID_AssociationArray, &IID_IQueryAssociations, (void**)&punk);
3378             ok(hr == S_OK || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3379             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3380
3381             /* BHID_EnumAssocHandlers */
3382             hr = IShellItem_BindToHandler(psi, NULL, &BHID_EnumAssocHandlers, &IID_IUnknown, (void**)&punk);
3383             ok(hr == E_NOINTERFACE || broken(hr == MK_E_NOOBJECT /* XP */), "Got 0x%08x\n", hr);
3384             if(SUCCEEDED(hr)) IUnknown_Release(punk);
3385         }
3386
3387         IShellItem_Release(psi);
3388     }
3389     else
3390         skip("Failed to create ShellItem.\n");
3391
3392     pILFree(pidl_desktop);
3393 }
3394
3395 static void test_SHParseDisplayName(void)
3396 {
3397     LPITEMIDLIST pidl1, pidl2;
3398     IShellFolder *desktop;
3399     WCHAR dirW[MAX_PATH];
3400     WCHAR nameW[10];
3401     HRESULT hr;
3402     BOOL ret;
3403
3404     if (!pSHParseDisplayName)
3405     {
3406         win_skip("SHParseDisplayName isn't available\n");
3407         return;
3408     }
3409
3410 if (0)
3411 {
3412     /* crashes on native */
3413     hr = pSHParseDisplayName(NULL, NULL, NULL, 0, NULL);
3414     nameW[0] = 0;
3415     hr = pSHParseDisplayName(nameW, NULL, NULL, 0, NULL);
3416 }
3417
3418     pidl1 = (LPITEMIDLIST)0xdeadbeef;
3419     hr = pSHParseDisplayName(NULL, NULL, &pidl1, 0, NULL);
3420     ok(broken(hr == E_OUTOFMEMORY) /* < Vista */ ||
3421        hr == E_INVALIDARG, "failed %08x\n", hr);
3422     ok(pidl1 == 0, "expected null ptr, got %p\n", pidl1);
3423
3424     /* dummy name */
3425     nameW[0] = 0;
3426     hr = pSHParseDisplayName(nameW, NULL, &pidl1, 0, NULL);
3427     ok(hr == S_OK, "failed %08x\n", hr);
3428     hr = SHGetDesktopFolder(&desktop);
3429     ok(hr == S_OK, "failed %08x\n", hr);
3430     hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, nameW, NULL, &pidl2, NULL);
3431     ok(hr == S_OK, "failed %08x\n", hr);
3432     ret = pILIsEqual(pidl1, pidl2);
3433     ok(ret == TRUE, "expected equal idls\n");
3434     pILFree(pidl1);
3435     pILFree(pidl2);
3436
3437     /* with path */
3438     GetWindowsDirectoryW( dirW, MAX_PATH );
3439
3440     hr = pSHParseDisplayName(dirW, NULL, &pidl1, 0, NULL);
3441     ok(hr == S_OK, "failed %08x\n", hr);
3442     hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, dirW, NULL, &pidl2, NULL);
3443     ok(hr == S_OK, "failed %08x\n", hr);
3444
3445     ret = pILIsEqual(pidl1, pidl2);
3446     ok(ret == TRUE, "expected equal idls\n");
3447     pILFree(pidl1);
3448     pILFree(pidl2);
3449
3450     IShellFolder_Release(desktop);
3451 }
3452
3453 static void test_desktop_IPersist(void)
3454 {
3455     IShellFolder *desktop;
3456     IPersist *persist;
3457     IPersistFolder2 *ppf2;
3458     CLSID clsid;
3459     HRESULT hr;
3460
3461     hr = SHGetDesktopFolder(&desktop);
3462     ok(hr == S_OK, "failed %08x\n", hr);
3463
3464     hr = IShellFolder_QueryInterface(desktop, &IID_IPersist, (void**)&persist);
3465     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* NT4, W9X */, "failed %08x\n", hr);
3466
3467     if (hr == S_OK)
3468     {
3469     if (0)
3470     {
3471         /* crashes on native */
3472         hr = IPersist_GetClassID(persist, NULL);
3473     }
3474         memset(&clsid, 0, sizeof(clsid));
3475         hr = IPersist_GetClassID(persist, &clsid);
3476         ok(hr == S_OK, "failed %08x\n", hr);
3477         ok(IsEqualIID(&CLSID_ShellDesktop, &clsid), "Expected CLSID_ShellDesktop\n");
3478         IPersist_Release(persist);
3479     }
3480
3481     hr = IShellFolder_QueryInterface(desktop, &IID_IPersistFolder2, (void**)&ppf2);
3482     ok(hr == S_OK || broken(hr == E_NOINTERFACE) /* pre-Vista */, "failed %08x\n", hr);
3483     if(SUCCEEDED(hr))
3484     {
3485         IPersistFolder *ppf;
3486         LPITEMIDLIST pidl;
3487         hr = IShellFolder_QueryInterface(desktop, &IID_IPersistFolder, (void**)&ppf);
3488         ok(hr == S_OK, "IID_IPersistFolder2 without IID_IPersistFolder.\n");
3489         if(SUCCEEDED(hr))
3490             IPersistFolder_Release(ppf);
3491
3492         todo_wine {
3493             hr = IPersistFolder2_Initialize(ppf2, NULL);
3494             ok(hr == S_OK, "got %08x\n", hr);
3495         }
3496
3497         pidl = NULL;
3498         hr = IPersistFolder2_GetCurFolder(ppf2, &pidl);
3499         ok(hr == S_OK, "got %08x\n", hr);
3500         ok(pidl != NULL, "pidl was NULL.\n");
3501         if(SUCCEEDED(hr)) pILFree(pidl);
3502
3503         IPersistFolder2_Release(ppf2);
3504     }
3505
3506     IShellFolder_Release(desktop);
3507 }
3508
3509 static void test_GetUIObject(void)
3510 {
3511     IShellFolder *psf_desktop;
3512     IContextMenu *pcm;
3513     LPITEMIDLIST pidl;
3514     HRESULT hr;
3515     WCHAR path[MAX_PATH];
3516     const WCHAR filename[] =
3517         {'\\','t','e','s','t','d','i','r','\\','t','e','s','t','1','.','t','x','t',0};
3518
3519     if(!pSHBindToParent)
3520     {
3521         win_skip("SHBindToParent missing.\n");
3522         return;
3523     }
3524
3525     GetCurrentDirectoryW(MAX_PATH, path);
3526     if(!lstrlenW(path))
3527     {
3528         skip("GetCurrentDirectoryW returned an empty string.\n");
3529         return;
3530     }
3531     lstrcatW(path, filename);
3532     SHGetDesktopFolder(&psf_desktop);
3533
3534     CreateFilesFolders();
3535
3536     hr = IShellFolder_ParseDisplayName(psf_desktop, NULL, NULL, path, NULL, &pidl, 0);
3537     ok(hr == S_OK || broken(hr == E_FAIL) /* WinME */, "Got 0x%08x\n", hr);
3538     if(SUCCEEDED(hr))
3539     {
3540         IShellFolder *psf;
3541         LPCITEMIDLIST pidl_child;
3542         hr = pSHBindToParent(pidl, &IID_IShellFolder, (void**)&psf, &pidl_child);
3543         ok(hr == S_OK, "Got 0x%08x\n", hr);
3544         if(SUCCEEDED(hr))
3545         {
3546             hr = IShellFolder_GetUIObjectOf(psf, NULL, 1, (LPCITEMIDLIST*)&pidl_child,
3547                                             &IID_IContextMenu, NULL, (void**)&pcm);
3548             ok(hr == S_OK, "Got 0x%08x\n", hr);
3549             if(SUCCEEDED(hr))
3550             {
3551                 HMENU hmenu = CreatePopupMenu();
3552                 INT max_id, max_id_check;
3553                 UINT count, i;
3554                 const int id_upper_limit = 32767;
3555                 hr = IContextMenu_QueryContextMenu(pcm, hmenu, 0, 0, id_upper_limit, CMF_NORMAL);
3556                 ok(SUCCEEDED(hr), "Got 0x%08x\n", hr);
3557                 max_id = HRESULT_CODE(hr) - 1; /* returns max_id + 1 */
3558                 ok(max_id <= id_upper_limit, "Got %d\n", max_id);
3559                 count = GetMenuItemCount(hmenu);
3560                 ok(count, "Got %d\n", count);
3561
3562                 max_id_check = 0;
3563                 for(i = 0; i < count; i++)
3564                 {
3565                     MENUITEMINFOA mii;
3566                     INT res;
3567                     ZeroMemory(&mii, sizeof(MENUITEMINFOA));
3568                     mii.cbSize = sizeof(MENUITEMINFOA);
3569                     mii.fMask = MIIM_ID | MIIM_FTYPE;
3570
3571                     SetLastError(0);
3572                     res = GetMenuItemInfoA(hmenu, i, TRUE, &mii);
3573                     ok(res, "Failed (last error: %d).\n", GetLastError());
3574
3575                     ok( (mii.wID <= id_upper_limit) || (mii.fType & MFT_SEPARATOR),
3576                         "Got non-separator ID out of range: %d (type: %x)\n", mii.wID, mii.fType);
3577                     if(!(mii.fType & MFT_SEPARATOR))
3578                         max_id_check = (mii.wID>max_id_check)?mii.wID:max_id_check;
3579                 }
3580                 ok((max_id_check == max_id) ||
3581                    (max_id_check == max_id-1 /* Win 7 */),
3582                    "Not equal (or near equal), got %d and %d\n", max_id_check, max_id);
3583
3584 #define is_win2k() (pSHGetFolderPathA && !pSHGetFolderPathAndSubDirA)
3585
3586                 if(count && !is_win2k())   /* Test is interactive on w2k, so skip */
3587                 {
3588                     CMINVOKECOMMANDINFO cmi;
3589                     ZeroMemory(&cmi, sizeof(CMINVOKECOMMANDINFO));
3590                     cmi.cbSize = sizeof(CMINVOKECOMMANDINFO);
3591
3592                     /* Attempt to execute a nonexistent command */
3593                     cmi.lpVerb = MAKEINTRESOURCEA(9999);
3594                     hr = IContextMenu_InvokeCommand(pcm, &cmi);
3595                     ok(hr == E_INVALIDARG, "Got 0x%08x\n", hr);
3596
3597                     cmi.lpVerb = "foobar_wine_test";
3598                     hr = IContextMenu_InvokeCommand(pcm, &cmi);
3599                     ok( (hr == E_INVALIDARG) || (hr == E_FAIL /* Win7 */) ||
3600                         (hr == HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION) /* Vista */),
3601                         "Got 0x%08x\n", hr);
3602                 }
3603 #undef is_win2k
3604
3605                 DestroyMenu(hmenu);
3606                 IContextMenu_Release(pcm);
3607             }
3608             IShellFolder_Release(psf);
3609         }
3610         if(pILFree) pILFree(pidl);
3611     }
3612
3613     IShellFolder_Release(psf_desktop);
3614     Cleanup();
3615 }
3616
3617 #define verify_pidl(i,p) r_verify_pidl(__LINE__, i, p)
3618 static void r_verify_pidl(unsigned l, LPCITEMIDLIST pidl, const WCHAR *path)
3619 {
3620     LPCITEMIDLIST child;
3621     IShellFolder *parent;
3622     STRRET filename;
3623     HRESULT hr;
3624
3625     if(!pSHBindToParent){
3626         win_skip("SHBindToParent is not available, not performing full PIDL verification\n");
3627         if(path)
3628             ok_(__FILE__,l)(pidl != NULL, "Expected PIDL to be non-NULL\n");
3629         else
3630             ok_(__FILE__,l)(pidl == NULL, "Expected PIDL to be NULL\n");
3631         return;
3632     }
3633
3634     if(path){
3635         if(!pidl){
3636             ok_(__FILE__,l)(0, "didn't get expected path (%s), instead: NULL\n", wine_dbgstr_w(path));
3637             return;
3638         }
3639
3640         hr = pSHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&parent, &child);
3641         ok_(__FILE__,l)(hr == S_OK, "SHBindToParent failed: 0x%08x\n", hr);
3642         if(FAILED(hr))
3643             return;
3644
3645         hr = IShellFolder_GetDisplayNameOf(parent, child, SHGDN_FORPARSING, &filename);
3646         ok_(__FILE__,l)(hr == S_OK, "GetDisplayNameOf failed: 0x%08x\n", hr);
3647         if(FAILED(hr)){
3648             IShellFolder_Release(parent);
3649             return;
3650         }
3651
3652         ok_(__FILE__,l)(filename.uType == STRRET_WSTR || filename.uType == STRRET_CSTR,
3653                 "Got unexpected string type: %d\n", filename.uType);
3654         if(filename.uType == STRRET_WSTR){
3655             ok_(__FILE__,l)(lstrcmpW(path, U(filename).pOleStr) == 0,
3656                     "didn't get expected path (%s), instead: %s\n",
3657                      wine_dbgstr_w(path), wine_dbgstr_w(U(filename).pOleStr));
3658         }else if(filename.uType == STRRET_CSTR){
3659             ok_(__FILE__,l)(strcmp_wa(path, U(filename).cStr) == 0,
3660                     "didn't get expected path (%s), instead: %s\n",
3661                      wine_dbgstr_w(path), U(filename).cStr);
3662         }
3663
3664         IShellFolder_Release(parent);
3665     }else
3666         ok_(__FILE__,l)(pidl == NULL, "Expected PIDL to be NULL\n");
3667 }
3668
3669 static void test_SHSimpleIDListFromPath(void)
3670 {
3671     const WCHAR adirW[] = {'C',':','\\','s','i','d','l','f','p','d','i','r',0};
3672     const CHAR adirA[] = "C:\\sidlfpdir";
3673     BOOL br, is_unicode = !(GetVersion() & 0x80000000);
3674
3675     LPITEMIDLIST pidl = NULL;
3676
3677     if(!pSHSimpleIDListFromPathAW){
3678         win_skip("SHSimpleIDListFromPathAW not available\n");
3679         return;
3680     }
3681
3682     br = CreateDirectoryA(adirA, NULL);
3683     ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
3684
3685     if(is_unicode)
3686         pidl = pSHSimpleIDListFromPathAW(adirW);
3687     else
3688         pidl = pSHSimpleIDListFromPathAW(adirA);
3689     verify_pidl(pidl, adirW);
3690     pILFree(pidl);
3691
3692     br = RemoveDirectoryA(adirA);
3693     ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
3694
3695     if(is_unicode)
3696         pidl = pSHSimpleIDListFromPathAW(adirW);
3697     else
3698         pidl = pSHSimpleIDListFromPathAW(adirA);
3699     verify_pidl(pidl, adirW);
3700     pILFree(pidl);
3701 }
3702
3703 /* IFileSystemBindData impl */
3704 static HRESULT WINAPI fsbd_QueryInterface(IFileSystemBindData *fsbd,
3705         REFIID riid, void **ppv)
3706 {
3707     if(IsEqualIID(riid, &IID_IFileSystemBindData) ||
3708             IsEqualIID(riid, &IID_IUnknown)){
3709         *ppv = fsbd;
3710         return S_OK;
3711     }
3712     return E_NOINTERFACE;
3713 }
3714
3715 static ULONG WINAPI fsbd_AddRef(IFileSystemBindData *fsbd)
3716 {
3717     return 2;
3718 }
3719
3720 static ULONG WINAPI fsbd_Release(IFileSystemBindData *fsbd)
3721 {
3722     return 1;
3723 }
3724
3725 static HRESULT WINAPI fsbd_SetFindData(IFileSystemBindData *fsbd,
3726         const WIN32_FIND_DATAW *pfd)
3727 {
3728     ok(0, "SetFindData called\n");
3729     return E_NOTIMPL;
3730 }
3731
3732 static HRESULT WINAPI fsbd_GetFindData_nul(IFileSystemBindData *fsbd,
3733         WIN32_FIND_DATAW *pfd)
3734 {
3735     memset(pfd, 0, sizeof(WIN32_FIND_DATAW));
3736     return S_OK;
3737 }
3738
3739 static HRESULT WINAPI fsbd_GetFindData_junk(IFileSystemBindData *fsbd,
3740         WIN32_FIND_DATAW *pfd)
3741 {
3742     memset(pfd, 0xdeadbeef, sizeof(WIN32_FIND_DATAW));
3743     return S_OK;
3744 }
3745
3746 static HRESULT WINAPI fsbd_GetFindData_invalid(IFileSystemBindData *fsbd,
3747         WIN32_FIND_DATAW *pfd)
3748 {
3749     memset(pfd, 0, sizeof(WIN32_FIND_DATAW));
3750     *pfd->cFileName = 'a';
3751     *pfd->cAlternateFileName = 'a';
3752     return S_OK;
3753 }
3754
3755 static HRESULT WINAPI fsbd_GetFindData_valid(IFileSystemBindData *fsbd,
3756         WIN32_FIND_DATAW *pfd)
3757 {
3758     static const WCHAR adirW[] = {'C',':','\\','f','s','b','d','d','i','r',0};
3759     HANDLE handle = FindFirstFileW(adirW, pfd);
3760     FindClose(handle);
3761     return S_OK;
3762 }
3763
3764 static HRESULT WINAPI fsbd_GetFindData_fail(IFileSystemBindData *fsbd,
3765         WIN32_FIND_DATAW *pfd)
3766 {
3767     return E_FAIL;
3768 }
3769
3770 static IFileSystemBindDataVtbl fsbdVtbl = {
3771     fsbd_QueryInterface,
3772     fsbd_AddRef,
3773     fsbd_Release,
3774     fsbd_SetFindData,
3775     NULL
3776 };
3777
3778 static IFileSystemBindData fsbd = { &fsbdVtbl };
3779
3780 static void test_ParseDisplayNamePBC(void)
3781 {
3782     WCHAR wFileSystemBindData[] =
3783         {'F','i','l','e',' ','S','y','s','t','e','m',' ','B','i','n','d',' ','D','a','t','a',0};
3784     WCHAR adirW[] = {'C',':','\\','f','s','b','d','d','i','r',0};
3785     const HRESULT exp_err = HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
3786
3787     IShellFolder *psf;
3788     IBindCtx *pbc;
3789     HRESULT hres;
3790     ITEMIDLIST *pidl;
3791
3792     /* Check if we support WCHAR functions */
3793     SetLastError(0xdeadbeef);
3794     lstrcmpiW(adirW, adirW);
3795     if(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED){
3796         win_skip("Most W-calls are not implemented\n");
3797         return;
3798     }
3799
3800     hres = SHGetDesktopFolder(&psf);
3801     ok(hres == S_OK, "SHGetDesktopFolder failed: 0x%08x\n", hres);
3802     if(FAILED(hres)){
3803         win_skip("Failed to get IShellFolder, can't run tests\n");
3804         return;
3805     }
3806
3807     /* fails on unknown dir with no IBindCtx */
3808     hres = IShellFolder_ParseDisplayName(psf, NULL, NULL, adirW, NULL, &pidl, NULL);
3809     ok(hres == exp_err || broken(hres == E_FAIL) /* NT4 */,
3810             "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
3811
3812     /* fails on unknown dir with IBindCtx with no IFileSystemBindData */
3813     hres = CreateBindCtx(0, &pbc);
3814     ok(hres == S_OK, "CreateBindCtx failed: 0x%08x\n", hres);
3815
3816     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3817     ok(hres == exp_err || broken(hres == E_FAIL) /* NT4 */,
3818             "ParseDisplayName failed with wrong error: 0x%08x\n", hres);
3819
3820     /* unknown dir with IBindCtx with IFileSystemBindData */
3821     hres = IBindCtx_RegisterObjectParam(pbc, wFileSystemBindData, (IUnknown*)&fsbd);
3822     ok(hres == S_OK, "RegisterObjectParam failed: 0x%08x\n", hres);
3823
3824     /* return E_FAIL from GetFindData */
3825     pidl = (ITEMIDLIST*)0xdeadbeef;
3826     fsbdVtbl.GetFindData = fsbd_GetFindData_fail;
3827     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3828     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3829             "ParseDisplayName failed: 0x%08x\n", hres);
3830     if(SUCCEEDED(hres)){
3831         verify_pidl(pidl, adirW);
3832         ILFree(pidl);
3833     }
3834
3835     /* set FIND_DATA struct to NULLs */
3836     pidl = (ITEMIDLIST*)0xdeadbeef;
3837     fsbdVtbl.GetFindData = fsbd_GetFindData_nul;
3838     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3839     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3840             "ParseDisplayName failed: 0x%08x\n", hres);
3841     if(SUCCEEDED(hres)){
3842         verify_pidl(pidl, adirW);
3843         ILFree(pidl);
3844     }
3845
3846     /* set FIND_DATA struct to junk */
3847     pidl = (ITEMIDLIST*)0xdeadbeef;
3848     fsbdVtbl.GetFindData = fsbd_GetFindData_junk;
3849     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3850     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3851             "ParseDisplayName failed: 0x%08x\n", hres);
3852     if(SUCCEEDED(hres)){
3853         verify_pidl(pidl, adirW);
3854         ILFree(pidl);
3855     }
3856
3857     /* set FIND_DATA struct to invalid data */
3858     pidl = (ITEMIDLIST*)0xdeadbeef;
3859     fsbdVtbl.GetFindData = fsbd_GetFindData_invalid;
3860     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3861     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3862             "ParseDisplayName failed: 0x%08x\n", hres);
3863     if(SUCCEEDED(hres)){
3864         verify_pidl(pidl, adirW);
3865         ILFree(pidl);
3866     }
3867
3868     /* set FIND_DATA struct to valid data */
3869     pidl = (ITEMIDLIST*)0xdeadbeef;
3870     fsbdVtbl.GetFindData = fsbd_GetFindData_valid;
3871     hres = IShellFolder_ParseDisplayName(psf, NULL, pbc, adirW, NULL, &pidl, NULL);
3872     ok(hres == S_OK || broken(hres == E_FAIL) /* NT4 */,
3873             "ParseDisplayName failed: 0x%08x\n", hres);
3874     if(SUCCEEDED(hres)){
3875         verify_pidl(pidl, adirW);
3876         ILFree(pidl);
3877     }
3878
3879     IBindCtx_Release(pbc);
3880     IShellFolder_Release(psf);
3881 }
3882
3883 static const CHAR testwindow_class[] = "testwindow";
3884 #define WM_USER_NOTIFY (WM_APP+1)
3885
3886 static struct {
3887     const char *id;
3888     BOOL exp_notify;
3889     UINT signal;
3890     const WCHAR *path_1;
3891     const WCHAR *path_2;
3892 } exp_data;
3893
3894 static LRESULT CALLBACK testwindow_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
3895 {
3896     UINT signal = (UINT)lparam;
3897
3898     switch(msg){
3899     case WM_USER_NOTIFY:
3900         if(exp_data.exp_notify){
3901             LPCITEMIDLIST *pidls = (LPCITEMIDLIST*)wparam;
3902
3903             ok(exp_data.signal == signal,
3904                     "%s: expected notification type %x, got: %x\n",
3905                     exp_data.id, exp_data.signal, signal);
3906
3907             trace("verifying pidls for: %s\n", exp_data.id);
3908             verify_pidl(pidls[0], exp_data.path_1);
3909             verify_pidl(pidls[1], exp_data.path_2);
3910
3911             exp_data.exp_notify = FALSE;
3912         }else
3913             ok(exp_data.exp_notify, "Didn't expect a WM_USER_NOTIFY message (event: %x)\n", signal);
3914         return 0;
3915     }
3916     return DefWindowProc(hwnd, msg, wparam, lparam);
3917 }
3918
3919 static void register_testwindow_class(void)
3920 {
3921     WNDCLASSEXA cls;
3922     ATOM ret;
3923
3924     ZeroMemory(&cls, sizeof(cls));
3925     cls.cbSize = sizeof(cls);
3926     cls.style = 0;
3927     cls.lpfnWndProc = testwindow_wndproc;
3928     cls.hInstance = GetModuleHandleA(NULL);
3929     cls.lpszClassName = testwindow_class;
3930
3931     SetLastError(0);
3932     ret = RegisterClassExA(&cls);
3933     ok(ret != 0, "RegisterClassExA failed: %d\n", GetLastError());
3934 }
3935
3936 /* SHCNF_FLUSH doesn't seem to work as advertised for SHCNF_PATHA, so we
3937  * have to poll repeatedly for the message to appear */
3938 static void do_events(void)
3939 {
3940     int c = 0;
3941     while (exp_data.exp_notify && (c++ < 10)){
3942         MSG msg;
3943         while(PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)){
3944             TranslateMessage(&msg);
3945             DispatchMessageA(&msg);
3946         }
3947         if(exp_data.exp_notify)
3948             Sleep(500);
3949     }
3950     trace("%s: took %d tries\n", exp_data.id, c);
3951 }
3952
3953 static void test_SHChangeNotify(void)
3954 {
3955     HWND wnd;
3956     ULONG notifyID;
3957     HRESULT hr;
3958     BOOL br, has_unicode;
3959     SHChangeNotifyEntry entries[1];
3960     const CHAR root_dirA[] = "C:\\shell32_cn_test";
3961     const WCHAR root_dirW[] = {'C',':','\\','s','h','e','l','l','3','2','_','c','n','_','t','e','s','t',0};
3962     const CHAR test_dirA[] = "C:\\shell32_cn_test\\test";
3963     const WCHAR test_dirW[] = {'C',':','\\','s','h','e','l','l','3','2','_','c','n','_','t','e','s','t','\\','t','e','s','t',0};
3964
3965     CreateDirectoryW(NULL, NULL);
3966     has_unicode = !(GetLastError() == ERROR_CALL_NOT_IMPLEMENTED);
3967
3968     /* set up the root directory & window */
3969     br = CreateDirectoryA(root_dirA, NULL);
3970     ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
3971
3972     register_testwindow_class();
3973
3974     wnd = CreateWindowExA(0, testwindow_class, testwindow_class, 0,
3975             CW_USEDEFAULT, CW_USEDEFAULT, 130, 105,
3976             NULL, NULL, GetModuleHandleA(NULL), 0);
3977     ok(wnd != NULL, "Failed to make a window\n");
3978
3979     entries[0].pidl = NULL;
3980     if(has_unicode)
3981         hr = SHILCreateFromPath(root_dirW, (LPITEMIDLIST*)&entries[0].pidl, 0);
3982     else
3983         hr = SHILCreateFromPath((LPCVOID)root_dirA, (LPITEMIDLIST*)&entries[0].pidl, 0);
3984     ok(hr == S_OK, "SHILCreateFromPath failed: 0x%08x\n", hr);
3985     entries[0].fRecursive = TRUE;
3986
3987     notifyID = SHChangeNotifyRegister(wnd, SHCNRF_ShellLevel,
3988             SHCNE_ALLEVENTS, WM_USER_NOTIFY, 1, entries);
3989     ok(notifyID != 0, "Failed to register a window for change notifications\n");
3990
3991     /* MKDIR */
3992     br = CreateDirectoryA(test_dirA, NULL);
3993     ok(br == TRUE, "CreateDirectory failed: %d\n", GetLastError());
3994
3995     if(has_unicode){
3996         exp_data.id = "MKDIR PATHW";
3997         exp_data.signal = SHCNE_MKDIR;
3998         exp_data.exp_notify = TRUE;
3999         exp_data.path_1 = test_dirW;
4000         exp_data.path_2 = NULL;
4001         SHChangeNotify(SHCNE_MKDIR, SHCNF_PATHW | SHCNF_FLUSH, test_dirW, NULL);
4002         do_events();
4003         ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
4004     }else
4005         win_skip("skipping WCHAR tests\n");
4006
4007     exp_data.id = "MKDIR PATHA";
4008     exp_data.signal = SHCNE_MKDIR;
4009     exp_data.exp_notify = TRUE;
4010     exp_data.path_1 = test_dirW;
4011     exp_data.path_2 = NULL;
4012     SHChangeNotify(SHCNE_MKDIR, SHCNF_PATHA | SHCNF_FLUSH, test_dirA, NULL);
4013     do_events();
4014     ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
4015
4016     /* RMDIR */
4017     br = RemoveDirectoryA(test_dirA);
4018     ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
4019
4020     if(has_unicode){
4021         exp_data.id = "RMDIR PATHW";
4022         exp_data.signal = SHCNE_RMDIR;
4023         exp_data.exp_notify = TRUE;
4024         exp_data.path_1 = test_dirW;
4025         exp_data.path_2 = NULL;
4026         SHChangeNotify(SHCNE_RMDIR, SHCNF_PATHW | SHCNF_FLUSH, test_dirW, NULL);
4027         do_events();
4028         ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
4029     }else
4030         win_skip("skipping WCHAR tests\n");
4031
4032     exp_data.id = "RMDIR PATHA";
4033     exp_data.signal = SHCNE_RMDIR;
4034     exp_data.exp_notify = TRUE;
4035     exp_data.path_1 = test_dirW;
4036     exp_data.path_2 = NULL;
4037     SHChangeNotify(SHCNE_RMDIR, SHCNF_PATHA | SHCNF_FLUSH, test_dirA, NULL);
4038     do_events();
4039     ok(exp_data.exp_notify == FALSE, "Expected wndproc to be called\n");
4040
4041     SHChangeNotifyDeregister(notifyID);
4042     DestroyWindow(wnd);
4043
4044     br = RemoveDirectoryA(root_dirA);
4045     ok(br == TRUE, "RemoveDirectory failed: %d\n", GetLastError());
4046 }
4047
4048 START_TEST(shlfolder)
4049 {
4050     init_function_pointers();
4051     /* if OleInitialize doesn't get called, ParseDisplayName returns
4052        CO_E_NOTINITIALIZED for malformed directory names on win2k. */
4053     OleInitialize(NULL);
4054
4055     test_ParseDisplayName();
4056     test_SHParseDisplayName();
4057     test_BindToObject();
4058     test_EnumObjects_and_CompareIDs();
4059     test_GetDisplayName();
4060     test_GetAttributesOf();
4061     test_SHGetPathFromIDList();
4062     test_CallForAttributes();
4063     test_FolderShortcut();
4064     test_ITEMIDLIST_format();
4065     test_SHGetFolderPathAndSubDirA();
4066     test_LocalizedNames();
4067     test_SHCreateShellItem();
4068     test_SHCreateShellItemArray();
4069     test_desktop_IPersist();
4070     test_GetUIObject();
4071     test_SHSimpleIDListFromPath();
4072     test_ParseDisplayNamePBC();
4073     test_SHGetNameFromIDList();
4074     test_SHGetItemFromDataObject();
4075     test_SHGetIDListFromObject();
4076     test_SHGetItemFromObject();
4077     test_ShellItemCompare();
4078     test_SHChangeNotify();
4079     test_ShellItemBindToHandler();
4080
4081     OleUninitialize();
4082 }