?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 6e61d6ca5bcaf95ac09a664b4ba4f88238c927be
[wine/hacks.git] / dlls / shell32 / tests / shlfolder.c
blobbce7c3ebe441c016572e7877fe57ae08b4e749a7
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
43 static IMalloc *ppM;
44
45 static HRESULT (WINAPI *pSHBindToParent)(LPCITEMIDLIST, REFIID, LPVOID*, LPCITEMIDLIST*);
46 static HRESULT (WINAPI *pSHGetFolderPathA)(HWND, int, HANDLE, DWORD, LPSTR);
47 static HRESULT (WINAPI *pSHGetFolderPathAndSubDirA)(HWND, int, HANDLE, DWORD, LPCSTR, LPSTR);
48 static BOOL (WINAPI *pSHGetPathFromIDListW)(LPCITEMIDLIST,LPWSTR);
49 static BOOL (WINAPI *pSHGetSpecialFolderPathA)(HWND, LPSTR, int, BOOL);
50 static BOOL (WINAPI *pSHGetSpecialFolderPathW)(HWND, LPWSTR, int, BOOL);
51 static HRESULT (WINAPI *pStrRetToBufW)(STRRET*,LPCITEMIDLIST,LPWSTR,UINT);
52 static LPITEMIDLIST (WINAPI *pILFindLastID)(LPCITEMIDLIST);
53 static void (WINAPI *pILFree)(LPITEMIDLIST);
54 static BOOL (WINAPI *pILIsEqual)(LPCITEMIDLIST, LPCITEMIDLIST);
55 static HRESULT (WINAPI *pSHCreateShellItem)(LPCITEMIDLIST,IShellFolder*,LPCITEMIDLIST,IShellItem**);
56 static LPITEMIDLIST (WINAPI *pILCombine)(LPCITEMIDLIST,LPCITEMIDLIST);
57 static HRESULT (WINAPI *pSHParseDisplayName)(LPCWSTR,IBindCtx*,LPITEMIDLIST*,SFGAOF,SFGAOF*);
58
59 static void init_function_pointers(void)
60 {
61 HMODULE hmod;
62 HRESULT hr;
63
64 hmod = GetModuleHandleA("shell32.dll");
65
66 #define MAKEFUNC(f) (p##f = (void*)GetProcAddress(hmod, #f))
67 MAKEFUNC(SHBindToParent);
68 MAKEFUNC(SHCreateShellItem);
69 MAKEFUNC(SHGetFolderPathA);
70 MAKEFUNC(SHGetFolderPathAndSubDirA);
71 MAKEFUNC(SHGetPathFromIDListW);
72 MAKEFUNC(SHGetSpecialFolderPathA);
73 MAKEFUNC(SHGetSpecialFolderPathW);
74 MAKEFUNC(SHParseDisplayName);
75 #undef MAKEFUNC
76
77 #define MAKEFUNC_ORD(f, ord) (p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))
78 MAKEFUNC_ORD(ILFindLastID, 16);
79 MAKEFUNC_ORD(ILIsEqual, 21);
80 MAKEFUNC_ORD(ILCombine, 25);
81 MAKEFUNC_ORD(ILFree, 155);
82 #undef MAKEFUNC_ORD
83
84 hmod = GetModuleHandleA("shlwapi.dll");
85 pStrRetToBufW = (void*)GetProcAddress(hmod, "StrRetToBufW");
86
87 hr = SHGetMalloc(&ppM);
88 ok(hr == S_OK, "SHGetMalloc failed %08x\n", hr);
89 }
90
91 static void test_ParseDisplayName(void)
92 {
93 HRESULT hr;
94 IShellFolder *IDesktopFolder;
95 static const char *cNonExistDir1A = "c:\\nonexist_subdir";
96 static const char *cNonExistDir2A = "c:\\\\nonexist_subdir";
97 static const char *cInetTestA = "http:\\yyy";
98 static const char *cInetTest2A = "xx:yyy";
99 DWORD res;
100 WCHAR cTestDirW [MAX_PATH] = {0};
101 ITEMIDLIST *newPIDL;
102 BOOL bRes;
103
104 hr = SHGetDesktopFolder(&IDesktopFolder);
105 if(hr != S_OK) return;
106
107 /* Tests crash on W2K and below (SHCreateShellItem available as of XP) */
108 if (pSHCreateShellItem)
109 {
110 /* null name and pidl */
111 hr = IShellFolder_ParseDisplayName(IDesktopFolder,
112 NULL, NULL, NULL, NULL, NULL, 0);
113 ok(hr == E_INVALIDARG, "returned %08x, expected E_INVALIDARG\n", hr);
114
115 /* null name */
116 newPIDL = (ITEMIDLIST*)0xdeadbeef;
117 hr = IShellFolder_ParseDisplayName(IDesktopFolder,
118 NULL, NULL, NULL, NULL, &newPIDL, 0);
119 ok(newPIDL == 0, "expected null, got %p\n", newPIDL);
120 ok(hr == E_INVALIDARG, "returned %08x, expected E_INVALIDARG\n", hr);
121 }
122 else
123 win_skip("Tests would crash on W2K and below\n");
124
125 MultiByteToWideChar(CP_ACP, 0, cInetTestA, -1, cTestDirW, MAX_PATH);
126 hr = IShellFolder_ParseDisplayName(IDesktopFolder,
127 NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
128 todo_wine ok((SUCCEEDED(hr) || broken(hr == E_FAIL) /* NT4 */),
129 "ParseDisplayName returned %08x, expected SUCCESS or E_FAIL\n", hr);
130 if (SUCCEEDED(hr))
131 {
132 ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x61, "Last pidl should be of type "
133 "PT_IESPECIAL1, but is: %02x\n", pILFindLastID(newPIDL)->mkid.abID[0]);
134 IMalloc_Free(ppM, newPIDL);
135 }
136
137 MultiByteToWideChar(CP_ACP, 0, cInetTest2A, -1, cTestDirW, MAX_PATH);
138 hr = IShellFolder_ParseDisplayName(IDesktopFolder,
139 NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
140 todo_wine ok((SUCCEEDED(hr) || broken(hr == E_FAIL) /* NT4 */),
141 "ParseDisplayName returned %08x, expected SUCCESS or E_FAIL\n", hr);
142 if (SUCCEEDED(hr))
143 {
144 ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x61, "Last pidl should be of type "
145 "PT_IESPECIAL1, but is: %02x\n", pILFindLastID(newPIDL)->mkid.abID[0]);
146 IMalloc_Free(ppM, newPIDL);
147 }
148
149 res = GetFileAttributesA(cNonExistDir1A);
150 if(res != INVALID_FILE_ATTRIBUTES) return;
151
152 MultiByteToWideChar(CP_ACP, 0, cNonExistDir1A, -1, cTestDirW, MAX_PATH);
153 hr = IShellFolder_ParseDisplayName(IDesktopFolder,
154 NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
155 ok((hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) || (hr == E_FAIL),
156 "ParseDisplayName returned %08x, expected 80070002 or E_FAIL\n", hr);
157
158 res = GetFileAttributesA(cNonExistDir2A);
159 if(res != INVALID_FILE_ATTRIBUTES) return;
160
161 MultiByteToWideChar(CP_ACP, 0, cNonExistDir2A, -1, cTestDirW, MAX_PATH);
162 hr = IShellFolder_ParseDisplayName(IDesktopFolder,
163 NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
164 ok((hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) || (hr == E_FAIL) || (hr == E_INVALIDARG),
165 "ParseDisplayName returned %08x, expected 80070002, E_FAIL or E_INVALIDARG\n", hr);
166
167 /* I thought that perhaps the DesktopFolder's ParseDisplayName would recognize the
168 * path corresponding to CSIDL_PERSONAL and return a CLSID_MyDocuments PIDL. Turns
169 * out it doesn't. The magic seems to happen in the file dialogs, then. */
170 if (!pSHGetSpecialFolderPathW || !pILFindLastID) goto finished;
171
172 bRes = pSHGetSpecialFolderPathW(NULL, cTestDirW, CSIDL_PERSONAL, FALSE);
173 ok(bRes, "SHGetSpecialFolderPath(CSIDL_PERSONAL) failed! %u\n", GetLastError());
174 if (!bRes) goto finished;
175
176 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
177 ok(SUCCEEDED(hr), "DesktopFolder->ParseDisplayName failed. hr = %08x.\n", hr);
178 if (FAILED(hr)) goto finished;
179
180 ok(pILFindLastID(newPIDL)->mkid.abID[0] == 0x31 ||
181 pILFindLastID(newPIDL)->mkid.abID[0] == 0xb1, /* Win98 */
182 "Last pidl should be of type PT_FOLDER or PT_IESPECIAL2, but is: %02x\n",
183 pILFindLastID(newPIDL)->mkid.abID[0]);
184 IMalloc_Free(ppM, newPIDL);
185
186 finished:
187 IShellFolder_Release(IDesktopFolder);
188 }
189
190 /* creates a file with the specified name for tests */
191 static void CreateTestFile(const CHAR *name)
192 {
193 HANDLE file;
194 DWORD written;
195
196 file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
197 if (file != INVALID_HANDLE_VALUE)
198 {
199 WriteFile(file, name, strlen(name), &written, NULL);
200 WriteFile(file, "\n", strlen("\n"), &written, NULL);
201 CloseHandle(file);
202 }
203 }
204
205
206 /* initializes the tests */
207 static void CreateFilesFolders(void)
208 {
209 CreateDirectoryA(".\\testdir", NULL);
210 CreateDirectoryA(".\\testdir\\test.txt", NULL);
211 CreateTestFile (".\\testdir\\test1.txt ");
212 CreateTestFile (".\\testdir\\test2.txt ");
213 CreateTestFile (".\\testdir\\test3.txt ");
214 CreateDirectoryA(".\\testdir\\testdir2 ", NULL);
215 CreateDirectoryA(".\\testdir\\testdir2\\subdir", NULL);
216 }
217
218 /* cleans after tests */
219 static void Cleanup(void)
220 {
221 DeleteFileA(".\\testdir\\test1.txt");
222 DeleteFileA(".\\testdir\\test2.txt");
223 DeleteFileA(".\\testdir\\test3.txt");
224 RemoveDirectoryA(".\\testdir\\test.txt");
225 RemoveDirectoryA(".\\testdir\\testdir2\\subdir");
226 RemoveDirectoryA(".\\testdir\\testdir2");
227 RemoveDirectoryA(".\\testdir");
228 }
229
230
231 /* perform test */
232 static void test_EnumObjects(IShellFolder *iFolder)
233 {
234 IEnumIDList *iEnumList;
235 LPITEMIDLIST newPIDL, idlArr[10];
236 ULONG NumPIDLs;
237 int i=0, j;
238 HRESULT hr;
239
240 static const WORD iResults [5][5] =
241 {
242 { 0,-1,-1,-1,-1},
243 { 1, 0,-1,-1,-1},
244 { 1, 1, 0,-1,-1},
245 { 1, 1, 1, 0,-1},
246 { 1, 1, 1, 1, 0}
247 };
248
249 #define SFGAO_testfor SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_CAPABILITYMASK
250 /* Don't test for SFGAO_HASSUBFOLDER since we return real state and native cached */
251 static const ULONG attrs[5] =
252 {
253 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
254 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR,
255 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
256 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
257 SFGAO_CAPABILITYMASK | SFGAO_FILESYSTEM,
258 };
259
260 hr = IShellFolder_EnumObjects(iFolder, NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &iEnumList);
261 ok(hr == S_OK, "EnumObjects failed %08x\n", hr);
262
263 /* This is to show that, contrary to what is said on MSDN, on IEnumIDList::Next,
264 * the filesystem shellfolders return S_OK even if less than 'celt' items are
265 * returned (in contrast to S_FALSE). We have to do it in a loop since WinXP
266 * only ever returns a single entry per call. */
267 while (IEnumIDList_Next(iEnumList, 10-i, &idlArr[i], &NumPIDLs) == S_OK)
268 i += NumPIDLs;
269 ok (i == 5, "i: %d\n", i);
270
271 hr = IEnumIDList_Release(iEnumList);
272 ok(hr == S_OK, "IEnumIDList_Release failed %08x\n", hr);
273
274 /* Sort them first in case of wrong order from system */
275 for (i=0;i<5;i++) for (j=0;j<5;j++)
276 if ((SHORT)IShellFolder_CompareIDs(iFolder, 0, idlArr[i], idlArr[j]) < 0)
277 {
278 newPIDL = idlArr[i];
279 idlArr[i] = idlArr[j];
280 idlArr[j] = newPIDL;
281 }
282
283 for (i=0;i<5;i++) for (j=0;j<5;j++)
284 {
285 hr = IShellFolder_CompareIDs(iFolder, 0, idlArr[i], idlArr[j]);
286 ok(hr == iResults[i][j], "Got %x expected [%d]-[%d]=%x\n", hr, i, j, iResults[i][j]);
287 }
288
289
290 for (i = 0; i < 5; i++)
291 {
292 SFGAOF flags;
293 #define SFGAO_VISTA SFGAO_DROPTARGET | SFGAO_CANLINK | SFGAO_CANCOPY
294 /* Native returns all flags no matter what we ask for */
295 flags = SFGAO_CANCOPY;
296 hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
297 flags &= SFGAO_testfor;
298 ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
299 ok(flags == (attrs[i]) ||
300 flags == (attrs[i] & ~SFGAO_FILESYSANCESTOR) || /* Win9x, NT4 */
301 flags == ((attrs[i] & ~SFGAO_CAPABILITYMASK) | SFGAO_VISTA), /* Vista and higher */
302 "GetAttributesOf[%i] got %08x, expected %08x\n", i, flags, attrs[i]);
303
304 flags = SFGAO_testfor;
305 hr = IShellFolder_GetAttributesOf(iFolder, 1, (LPCITEMIDLIST*)(idlArr + i), &flags);
306 flags &= SFGAO_testfor;
307 ok(hr == S_OK, "GetAttributesOf returns %08x\n", hr);
308 ok(flags == attrs[i] ||
309 flags == (attrs[i] & ~SFGAO_FILESYSANCESTOR), /* Win9x, NT4 */
310 "GetAttributesOf[%i] got %08x, expected %08x\n", i, flags, attrs[i]);
311 }
312
313 for (i=0;i<5;i++)
314 IMalloc_Free(ppM, idlArr[i]);
315 }
316
317 static void test_BindToObject(void)
318 {
319 HRESULT hr;
320 UINT cChars;
321 IShellFolder *psfDesktop, *psfChild, *psfMyComputer, *psfSystemDir;
322 SHITEMID emptyitem = { 0, { 0 } };
323 LPITEMIDLIST pidlMyComputer, pidlSystemDir, pidlEmpty = (LPITEMIDLIST)&emptyitem;
324 WCHAR wszSystemDir[MAX_PATH];
325 char szSystemDir[MAX_PATH];
326 WCHAR wszMyComputer[] = {
327 ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
328 'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
329
330 /* The following tests shows that BindToObject should fail with E_INVALIDARG if called
331 * with an empty pidl. This is tested for Desktop, MyComputer and the FS ShellFolder
332 */
333 hr = SHGetDesktopFolder(&psfDesktop);
334 ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
335 if (FAILED(hr)) return;
336
337 hr = IShellFolder_BindToObject(psfDesktop, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
338 ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
339
340 hr = IShellFolder_BindToObject(psfDesktop, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
341 ok (hr == E_INVALIDARG, "Desktop's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
342
343 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
344 ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
345 if (FAILED(hr)) {
346 IShellFolder_Release(psfDesktop);
347 return;
348 }
349
350 hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
351 ok (SUCCEEDED(hr), "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
352 IShellFolder_Release(psfDesktop);
353 IMalloc_Free(ppM, pidlMyComputer);
354 if (FAILED(hr)) return;
355
356 hr = IShellFolder_BindToObject(psfMyComputer, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
357 ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
358
359 if (0)
360 {
361 /* this call segfaults on 98SE */
362 hr = IShellFolder_BindToObject(psfMyComputer, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
363 ok (hr == E_INVALIDARG, "MyComputers's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
364 }
365
366 cChars = GetSystemDirectoryA(szSystemDir, MAX_PATH);
367 ok (cChars > 0 && cChars < MAX_PATH, "GetSystemDirectoryA failed! LastError: %u\n", GetLastError());
368 if (cChars == 0 || cChars >= MAX_PATH) {
369 IShellFolder_Release(psfMyComputer);
370 return;
371 }
372 MultiByteToWideChar(CP_ACP, 0, szSystemDir, -1, wszSystemDir, MAX_PATH);
373
374 hr = IShellFolder_ParseDisplayName(psfMyComputer, NULL, NULL, wszSystemDir, NULL, &pidlSystemDir, NULL);
375 ok (SUCCEEDED(hr), "MyComputers's ParseDisplayName failed to parse the SystemDirectory! hr = %08x\n", hr);
376 if (FAILED(hr)) {
377 IShellFolder_Release(psfMyComputer);
378 return;
379 }
380
381 hr = IShellFolder_BindToObject(psfMyComputer, pidlSystemDir, NULL, &IID_IShellFolder, (LPVOID*)&psfSystemDir);
382 ok (SUCCEEDED(hr), "MyComputer failed to bind to a FileSystem ShellFolder! hr = %08x\n", hr);
383 IShellFolder_Release(psfMyComputer);
384 IMalloc_Free(ppM, pidlSystemDir);
385 if (FAILED(hr)) return;
386
387 hr = IShellFolder_BindToObject(psfSystemDir, pidlEmpty, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
388 ok (hr == E_INVALIDARG,
389 "FileSystem ShellFolder's BindToObject should fail, when called with empty pidl! hr = %08x\n", hr);
390
391 if (0)
392 {
393 /* this call segfaults on 98SE */
394 hr = IShellFolder_BindToObject(psfSystemDir, NULL, NULL, &IID_IShellFolder, (LPVOID*)&psfChild);
395 ok (hr == E_INVALIDARG,
396 "FileSystem ShellFolder's BindToObject should fail, when called with NULL pidl! hr = %08x\n", hr);
397 }
398
399 IShellFolder_Release(psfSystemDir);
400 }
401
402 /* Based on PathAddBackslashW from dlls/shlwapi/path.c */
403 static LPWSTR myPathAddBackslashW( LPWSTR lpszPath )
404 {
405 size_t iLen;
406
407 if (!lpszPath || (iLen = lstrlenW(lpszPath)) >= MAX_PATH)
408 return NULL;
409
410 if (iLen)
411 {
412 lpszPath += iLen;
413 if (lpszPath[-1] != '\\')
414 {
415 *lpszPath++ = '\\';
416 *lpszPath = '\0';
417 }
418 }
419 return lpszPath;
420 }
421
422 static void test_GetDisplayName(void)
423 {
424 BOOL result;
425 HRESULT hr;
426 HANDLE hTestFile;
427 WCHAR wszTestFile[MAX_PATH], wszTestFile2[MAX_PATH];
428 char szTestFile[MAX_PATH], szTestDir[MAX_PATH];
429 DWORD attr;
430 STRRET strret;
431 LPSHELLFOLDER psfDesktop, psfPersonal;
432 IUnknown *psfFile;
433 SHITEMID emptyitem = { 0, { 0 } };
434 LPITEMIDLIST pidlTestFile, pidlEmpty = (LPITEMIDLIST)&emptyitem;
435 LPCITEMIDLIST pidlLast;
436 static const CHAR szFileName[] = "winetest.foo";
437 static const WCHAR wszFileName[] = { 'w','i','n','e','t','e','s','t','.','f','o','o',0 };
438 static const WCHAR wszDirName[] = { 'w','i','n','e','t','e','s','t',0 };
439
440 /* I'm trying to figure if there is a functional difference between calling
441 * SHGetPathFromIDListW and calling GetDisplayNameOf(SHGDN_FORPARSING) after
442 * binding to the shellfolder. One thing I thought of was that perhaps
443 * SHGetPathFromIDListW would be able to get the path to a file, which does
444 * not exist anymore, while the other method wouldn't. It turns out there's
445 * no functional difference in this respect.
446 */
447
448 if(!pSHGetSpecialFolderPathA) {
449 win_skip("SHGetSpecialFolderPathA is not available\n");
450 return;
451 }
452
453 /* First creating a directory in MyDocuments and a file in this directory. */
454 result = pSHGetSpecialFolderPathA(NULL, szTestDir, CSIDL_PERSONAL, FALSE);
455 ok(result, "SHGetSpecialFolderPathA failed! Last error: %u\n", GetLastError());
456 if (!result) return;
457
458 /* Use ANSI file functions so this works on Windows 9x */
459 lstrcatA(szTestDir, "\\winetest");
460 CreateDirectoryA(szTestDir, NULL);
461 attr=GetFileAttributesA(szTestDir);
462 if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_DIRECTORY))
463 {
464 ok(0, "unable to create the '%s' directory\n", szTestDir);
465 return;
466 }
467
468 lstrcpyA(szTestFile, szTestDir);
469 lstrcatA(szTestFile, "\\");
470 lstrcatA(szTestFile, szFileName);
471 hTestFile = CreateFileA(szTestFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
472 ok((hTestFile != INVALID_HANDLE_VALUE), "CreateFileA failed! Last error: %u\n", GetLastError());
473 if (hTestFile == INVALID_HANDLE_VALUE) return;
474 CloseHandle(hTestFile);
475
476 /* Getting an itemidlist for the file. */
477 hr = SHGetDesktopFolder(&psfDesktop);
478 ok(SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
479 if (FAILED(hr)) return;
480
481 MultiByteToWideChar(CP_ACP, 0, szTestFile, -1, wszTestFile, MAX_PATH);
482
483 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
484 ok(SUCCEEDED(hr), "Desktop->ParseDisplayName failed! hr = %08x\n", hr);
485 if (FAILED(hr)) {
486 IShellFolder_Release(psfDesktop);
487 return;
488 }
489
490 pidlLast = pILFindLastID(pidlTestFile);
491 ok(pidlLast->mkid.cb >=76 ||
492 broken(pidlLast->mkid.cb == 28) || /* W2K */
493 broken(pidlLast->mkid.cb == 40), /* Win9x, WinME */
494 "Expected pidl length of at least 76, got %d.\n", pidlLast->mkid.cb);
495 if (pidlLast->mkid.cb >= 28) {
496 ok(!lstrcmpA((CHAR*)&pidlLast->mkid.abID[12], szFileName),
497 "Filename should be stored as ansi-string at this position!\n");
498 }
499 /* WinXP and up store the filenames as both ANSI and UNICODE in the pidls */
500 if (pidlLast->mkid.cb >= 76) {
501 ok(!lstrcmpW((WCHAR*)&pidlLast->mkid.abID[46], wszFileName) ||
502 (pidlLast->mkid.cb >= 94 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[64], wszFileName)) || /* Vista */
503 (pidlLast->mkid.cb >= 98 && !lstrcmpW((WCHAR*)&pidlLast->mkid.abID[68], wszFileName)), /* Win7 */
504 "Filename should be stored as wchar-string at this position!\n");
505 }
506
507 /* It seems as if we cannot bind to regular files on windows, but only directories.
508 */
509 hr = IShellFolder_BindToObject(psfDesktop, pidlTestFile, NULL, &IID_IUnknown, (VOID**)&psfFile);
510 todo_wine
511 ok (hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
512 hr == E_NOTIMPL || /* Vista */
513 broken(SUCCEEDED(hr)), /* Win9x, W2K */
514 "hr = %08x\n", hr);
515 if (SUCCEEDED(hr)) {
516 IShellFolder_Release(psfFile);
517 }
518
519 if (!pSHBindToParent)
520 {
521 win_skip("SHBindToParent is missing\n");
522 DeleteFileA(szTestFile);
523 RemoveDirectoryA(szTestDir);
524 return;
525 }
526
527 /* Some tests for IShellFolder::SetNameOf */
528 if (pSHGetFolderPathAndSubDirA)
529 {
530 hr = pSHBindToParent(pidlTestFile, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
531 ok(SUCCEEDED(hr), "SHBindToParent failed! hr = %08x\n", hr);
532 if (SUCCEEDED(hr)) {
533 /* It's ok to use this fixed path. Call will fail anyway. */
534 WCHAR wszAbsoluteFilename[] = { 'C',':','\\','w','i','n','e','t','e','s','t', 0 };
535 LPITEMIDLIST pidlNew;
536
537 /* The pidl returned through the last parameter of SetNameOf is a simple one. */
538 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlLast, wszDirName, SHGDN_NORMAL, &pidlNew);
539 ok (SUCCEEDED(hr), "SetNameOf failed! hr = %08x\n", hr);
540 if (hr == S_OK)
541 {
542 ok (((LPITEMIDLIST)((LPBYTE)pidlNew+pidlNew->mkid.cb))->mkid.cb == 0,
543 "pidl returned from SetNameOf should be simple!\n");
544
545 /* Passing an absolute path to SetNameOf fails. The HRESULT code indicates that SetNameOf
546 * is implemented on top of SHFileOperation in WinXP. */
547 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszAbsoluteFilename,
548 SHGDN_FORPARSING, NULL);
549 ok (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED), "SetNameOf succeeded! hr = %08x\n", hr);
550
551 /* Rename the file back to its original name. SetNameOf ignores the fact, that the
552 * SHGDN flags specify an absolute path. */
553 hr = IShellFolder_SetNameOf(psfPersonal, NULL, pidlNew, wszFileName, SHGDN_FORPARSING, NULL);
554 ok (SUCCEEDED(hr), "SetNameOf failed! hr = %08x\n", hr);
555
556 pILFree(pidlNew);
557 }
558
559 IShellFolder_Release(psfPersonal);
560 }
561 }
562 else
563 win_skip("Avoid needs of interaction on Win2k\n");
564
565 /* Deleting the file and the directory */
566 DeleteFileA(szTestFile);
567 RemoveDirectoryA(szTestDir);
568
569 /* SHGetPathFromIDListW still works, although the file is not present anymore. */
570 if (pSHGetPathFromIDListW)
571 {
572 result = pSHGetPathFromIDListW(pidlTestFile, wszTestFile2);
573 ok (result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
574 ok (!lstrcmpiW(wszTestFile, wszTestFile2), "SHGetPathFromIDListW returns incorrect path!\n");
575 }
576
577 /* SHBindToParent fails, if called with a NULL PIDL. */
578 hr = pSHBindToParent(NULL, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
579 ok (FAILED(hr), "SHBindToParent(NULL) should fail!\n");
580
581 /* But it succeeds with an empty PIDL. */
582 hr = pSHBindToParent(pidlEmpty, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
583 ok (SUCCEEDED(hr), "SHBindToParent(empty PIDL) should succeed! hr = %08x\n", hr);
584 ok (pidlLast == pidlEmpty, "The last element of an empty PIDL should be the PIDL itself!\n");
585 if (SUCCEEDED(hr))
586 IShellFolder_Release(psfPersonal);
587
588 /* Binding to the folder and querying the display name of the file also works. */
589 hr = pSHBindToParent(pidlTestFile, &IID_IShellFolder, (VOID**)&psfPersonal, &pidlLast);
590 ok (SUCCEEDED(hr), "SHBindToParent failed! hr = %08x\n", hr);
591 if (FAILED(hr)) {
592 IShellFolder_Release(psfDesktop);
593 return;
594 }
595
596 /* This test shows that Windows doesn't allocate a new pidlLast, but returns a pointer into
597 * pidlTestFile (In accordance with MSDN). */
598 ok (pILFindLastID(pidlTestFile) == pidlLast,
599 "SHBindToParent doesn't return the last id of the pidl param!\n");
600
601 hr = IShellFolder_GetDisplayNameOf(psfPersonal, pidlLast, SHGDN_FORPARSING, &strret);
602 ok (SUCCEEDED(hr), "Personal->GetDisplayNameOf failed! hr = %08x\n", hr);
603 if (FAILED(hr)) {
604 IShellFolder_Release(psfDesktop);
605 IShellFolder_Release(psfPersonal);
606 return;
607 }
608
609 if (pStrRetToBufW)
610 {
611 hr = pStrRetToBufW(&strret, pidlLast, wszTestFile2, MAX_PATH);
612 ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
613 ok (!lstrcmpiW(wszTestFile, wszTestFile2), "GetDisplayNameOf returns incorrect path!\n");
614 }
615
616 ILFree(pidlTestFile);
617 IShellFolder_Release(psfDesktop);
618 IShellFolder_Release(psfPersonal);
619 }
620
621 static void test_CallForAttributes(void)
622 {
623 HKEY hKey;
624 LONG lResult;
625 HRESULT hr;
626 DWORD dwSize;
627 LPSHELLFOLDER psfDesktop;
628 LPITEMIDLIST pidlMyDocuments;
629 DWORD dwAttributes, dwCallForAttributes, dwOrigAttributes, dwOrigCallForAttributes;
630 static const WCHAR wszAttributes[] = { 'A','t','t','r','i','b','u','t','e','s',0 };
631 static const WCHAR wszCallForAttributes[] = {
632 'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0 };
633 static const WCHAR wszMyDocumentsKey[] = {
634 'C','L','S','I','D','\\','{','4','5','0','D','8','F','B','A','-','A','D','2','5','-',
635 '1','1','D','0','-','9','8','A','8','-','0','8','0','0','3','6','1','B','1','1','0','3','}',
636 '\\','S','h','e','l','l','F','o','l','d','e','r',0 };
637 WCHAR wszMyDocuments[] = {
638 ':',':','{','4','5','0','D','8','F','B','A','-','A','D','2','5','-','1','1','D','0','-',
639 '9','8','A','8','-','0','8','0','0','3','6','1','B','1','1','0','3','}',0 };
640
641 /* For the root of a namespace extension, the attributes are not queried by binding
642 * to the object and calling GetAttributesOf. Instead, the attributes are read from
643 * the registry value HKCR/CLSID/{...}/ShellFolder/Attributes. This is documented on MSDN.
644 *
645 * The MyDocuments shellfolder on WinXP has a HKCR/CLSID/{...}/ShellFolder/CallForAttributes
646 * value. It seems that if the folder is queried for one of the flags set in CallForAttributes,
647 * the shell does bind to the folder object and calls GetAttributesOf. This is not documented
648 * on MSDN. This test is meant to document the observed behaviour on WinXP SP2.
649 */
650 hr = SHGetDesktopFolder(&psfDesktop);
651 ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
652 if (FAILED(hr)) return;
653
654 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyDocuments, NULL,
655 &pidlMyDocuments, NULL);
656 ok (SUCCEEDED(hr) ||
657 broken(hr == E_INVALIDARG), /* Win95, NT4 */
658 "Desktop's ParseDisplayName failed to parse MyDocuments's CLSID! hr = %08x\n", hr);
659 if (FAILED(hr)) {
660 IShellFolder_Release(psfDesktop);
661 return;
662 }
663
664 dwAttributes = 0xffffffff;
665 hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
666 (LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
667 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
668
669 /* We need the following setup (as observed on WinXP SP2), for the tests to make sense. */
670 ok (dwAttributes & SFGAO_FILESYSTEM, "SFGAO_FILESYSTEM attribute is not set for MyDocuments!\n");
671 ok (!(dwAttributes & SFGAO_ISSLOW), "SFGAO_ISSLOW attribute is set for MyDocuments!\n");
672 ok (!(dwAttributes & SFGAO_GHOSTED), "SFGAO_GHOSTED attribute is set for MyDocuments!\n");
673
674 /* We don't have the MyDocuments shellfolder in wine yet, and thus we don't have the registry
675 * key. So the test will return at this point, if run on wine.
676 */
677 lResult = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszMyDocumentsKey, 0, KEY_WRITE|KEY_READ, &hKey);
678 ok (lResult == ERROR_SUCCESS ||
679 lResult == ERROR_ACCESS_DENIED,
680 "RegOpenKeyEx failed! result: %08x\n", lResult);
681 if (lResult != ERROR_SUCCESS) {
682 if (lResult == ERROR_ACCESS_DENIED)
683 skip("Not enough rights to open the registry key\n");
684 IMalloc_Free(ppM, pidlMyDocuments);
685 IShellFolder_Release(psfDesktop);
686 return;
687 }
688
689 /* Query MyDocuments' Attributes value, to be able to restore it later. */
690 dwSize = sizeof(DWORD);
691 lResult = RegQueryValueExW(hKey, wszAttributes, NULL, NULL, (LPBYTE)&dwOrigAttributes, &dwSize);
692 ok (lResult == ERROR_SUCCESS, "RegQueryValueEx failed! result: %08x\n", lResult);
693 if (lResult != ERROR_SUCCESS) {
694 RegCloseKey(hKey);
695 IMalloc_Free(ppM, pidlMyDocuments);
696 IShellFolder_Release(psfDesktop);
697 return;
698 }
699
700 /* Query MyDocuments' CallForAttributes value, to be able to restore it later. */
701 dwSize = sizeof(DWORD);
702 lResult = RegQueryValueExW(hKey, wszCallForAttributes, NULL, NULL,
703 (LPBYTE)&dwOrigCallForAttributes, &dwSize);
704 ok (lResult == ERROR_SUCCESS, "RegQueryValueEx failed! result: %08x\n", lResult);
705 if (lResult != ERROR_SUCCESS) {
706 RegCloseKey(hKey);
707 IMalloc_Free(ppM, pidlMyDocuments);
708 IShellFolder_Release(psfDesktop);
709 return;
710 }
711
712 /* Define via the Attributes value that MyDocuments attributes are SFGAO_ISSLOW and
713 * SFGAO_GHOSTED and that MyDocuments should be called for the SFGAO_ISSLOW and
714 * SFGAO_FILESYSTEM attributes. */
715 dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED;
716 RegSetValueExW(hKey, wszAttributes, 0, REG_DWORD, (LPBYTE)&dwAttributes, sizeof(DWORD));
717 dwCallForAttributes = SFGAO_ISSLOW|SFGAO_FILESYSTEM;
718 RegSetValueExW(hKey, wszCallForAttributes, 0, REG_DWORD,
719 (LPBYTE)&dwCallForAttributes, sizeof(DWORD));
720
721 /* Although it is not set in CallForAttributes, the SFGAO_GHOSTED flag is reset by
722 * GetAttributesOf. It seems that once there is a single attribute queried, for which
723 * CallForAttributes is set, all flags are taken from the GetAttributesOf call and
724 * the flags in Attributes are ignored.
725 */
726 dwAttributes = SFGAO_ISSLOW|SFGAO_GHOSTED|SFGAO_FILESYSTEM;
727 hr = IShellFolder_GetAttributesOf(psfDesktop, 1,
728 (LPCITEMIDLIST*)&pidlMyDocuments, &dwAttributes);
729 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(MyDocuments) failed! hr = %08x\n", hr);
730 if (SUCCEEDED(hr))
731 ok (dwAttributes == SFGAO_FILESYSTEM,
732 "Desktop->GetAttributes(MyDocuments) returned unexpected attributes: %08x\n",
733 dwAttributes);
734
735 /* Restore MyDocuments' original Attributes and CallForAttributes registry values */
736 RegSetValueExW(hKey, wszAttributes, 0, REG_DWORD, (LPBYTE)&dwOrigAttributes, sizeof(DWORD));
737 RegSetValueExW(hKey, wszCallForAttributes, 0, REG_DWORD,
738 (LPBYTE)&dwOrigCallForAttributes, sizeof(DWORD));
739 RegCloseKey(hKey);
740 IMalloc_Free(ppM, pidlMyDocuments);
741 IShellFolder_Release(psfDesktop);
742 }
743
744 static void test_GetAttributesOf(void)
745 {
746 HRESULT hr;
747 LPSHELLFOLDER psfDesktop, psfMyComputer;
748 SHITEMID emptyitem = { 0, { 0 } };
749 LPCITEMIDLIST pidlEmpty = (LPCITEMIDLIST)&emptyitem;
750 LPITEMIDLIST pidlMyComputer;
751 DWORD dwFlags;
752 static const DWORD desktopFlags[] = {
753 /* WinXP */
754 SFGAO_STORAGE | SFGAO_HASPROPSHEET | SFGAO_STORAGEANCESTOR | SFGAO_FILESYSANCESTOR |
755 SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER,
756 /* Win2k */
757 SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_STREAM | SFGAO_FILESYSANCESTOR |
758 SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER,
759 /* WinMe, Win9x, WinNT*/
760 SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_FILESYSANCESTOR |
761 SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER
762 };
763 static const DWORD myComputerFlags[] = {
764 /* WinXP */
765 SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
766 SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER,
767 /* Win2k */
768 SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_STREAM |
769 SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER,
770 /* WinMe, Win9x, WinNT */
771 SFGAO_CANRENAME | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_FILESYSANCESTOR |
772 SFGAO_FOLDER | SFGAO_HASSUBFOLDER,
773 /* Win95, WinNT when queried directly */
774 SFGAO_CANLINK | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET | SFGAO_FILESYSANCESTOR |
775 SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_HASSUBFOLDER
776 };
777 WCHAR wszMyComputer[] = {
778 ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
779 'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
780 char cCurrDirA [MAX_PATH] = {0};
781 WCHAR cCurrDirW [MAX_PATH];
782 static WCHAR cTestDirW[] = {'t','e','s','t','d','i','r',0};
783 IShellFolder *IDesktopFolder, *testIShellFolder;
784 ITEMIDLIST *newPIDL;
785 int len, i;
786 BOOL foundFlagsMatch;
787
788 hr = SHGetDesktopFolder(&psfDesktop);
789 ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
790 if (FAILED(hr)) return;
791
792 /* The Desktop attributes can be queried with a single empty itemidlist, .. */
793 dwFlags = 0xffffffff;
794 hr = IShellFolder_GetAttributesOf(psfDesktop, 1, &pidlEmpty, &dwFlags);
795 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(empty pidl) failed! hr = %08x\n", hr);
796 for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
797 i < sizeof(desktopFlags) / sizeof(desktopFlags[0]); i++)
798 {
799 if (desktopFlags[i] == dwFlags)
800 foundFlagsMatch = TRUE;
801 }
802 ok (foundFlagsMatch, "Wrong Desktop attributes: %08x\n", dwFlags);
803
804 /* .. or with no itemidlist at all. */
805 dwFlags = 0xffffffff;
806 hr = IShellFolder_GetAttributesOf(psfDesktop, 0, NULL, &dwFlags);
807 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
808 for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
809 i < sizeof(desktopFlags) / sizeof(desktopFlags[0]); i++)
810 {
811 if (desktopFlags[i] == dwFlags)
812 foundFlagsMatch = TRUE;
813 }
814 ok (foundFlagsMatch, "Wrong Desktop attributes: %08x\n", dwFlags);
815
816 /* Testing the attributes of the MyComputer shellfolder */
817 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
818 ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
819 if (FAILED(hr)) {
820 IShellFolder_Release(psfDesktop);
821 return;
822 }
823
824 /* Windows sets the SFGAO_CANLINK flag, when MyComputer is queried via the Desktop
825 * folder object. It doesn't do this, if MyComputer is queried directly (see below).
826 */
827 dwFlags = 0xffffffff;
828 hr = IShellFolder_GetAttributesOf(psfDesktop, 1, (LPCITEMIDLIST*)&pidlMyComputer, &dwFlags);
829 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf(MyComputer) failed! hr = %08x\n", hr);
830 for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
831 i < sizeof(myComputerFlags) / sizeof(myComputerFlags[0]); i++)
832 {
833 if ((myComputerFlags[i] | SFGAO_CANLINK) == dwFlags)
834 foundFlagsMatch = TRUE;
835 }
836 todo_wine
837 ok (foundFlagsMatch, "Wrong MyComputer attributes: %08x\n", dwFlags);
838
839 hr = IShellFolder_BindToObject(psfDesktop, pidlMyComputer, NULL, &IID_IShellFolder, (LPVOID*)&psfMyComputer);
840 ok (SUCCEEDED(hr), "Desktop failed to bind to MyComputer object! hr = %08x\n", hr);
841 IShellFolder_Release(psfDesktop);
842 IMalloc_Free(ppM, pidlMyComputer);
843 if (FAILED(hr)) return;
844
845 hr = IShellFolder_GetAttributesOf(psfMyComputer, 1, &pidlEmpty, &dwFlags);
846 todo_wine
847 ok (hr == E_INVALIDARG ||
848 broken(SUCCEEDED(hr)), /* W2K and earlier */
849 "MyComputer->GetAttributesOf(emtpy pidl) should fail! hr = %08x\n", hr);
850
851 dwFlags = 0xffffffff;
852 hr = IShellFolder_GetAttributesOf(psfMyComputer, 0, NULL, &dwFlags);
853 ok (SUCCEEDED(hr), "MyComputer->GetAttributesOf(NULL) failed! hr = %08x\n", hr);
854 for (i = 0, foundFlagsMatch = FALSE; !foundFlagsMatch &&
855 i < sizeof(myComputerFlags) / sizeof(myComputerFlags[0]); i++)
856 {
857 if (myComputerFlags[i] == dwFlags)
858 foundFlagsMatch = TRUE;
859 }
860 todo_wine
861 ok (foundFlagsMatch, "Wrong MyComputer attributes: %08x\n", dwFlags);
862
863 IShellFolder_Release(psfMyComputer);
864
865 GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
866 len = lstrlenA(cCurrDirA);
867
868 if (len == 0) {
869 win_skip("GetCurrentDirectoryA returned empty string. Skipping test_GetAttributesOf\n");
870 return;
871 }
872 if (len > 3 && cCurrDirA[len-1] == '\\')
873 cCurrDirA[len-1] = 0;
874
875 /* create test directory */
876 CreateFilesFolders();
877
878 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
879
880 hr = SHGetDesktopFolder(&IDesktopFolder);
881 ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
882
883 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
884 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
885
886 hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
887 ok(hr == S_OK, "BindToObject failed %08x\n", hr);
888
889 IMalloc_Free(ppM, newPIDL);
890
891 /* get relative PIDL */
892 hr = IShellFolder_ParseDisplayName(testIShellFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
893 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
894
895 /* test the shell attributes of the test directory using the relative PIDL */
896 dwFlags = SFGAO_FOLDER;
897 hr = IShellFolder_GetAttributesOf(testIShellFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
898 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
899 ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for relative PIDL: %08x\n", dwFlags);
900
901 /* free memory */
902 IMalloc_Free(ppM, newPIDL);
903
904 /* append testdirectory name to path */
905 if (cCurrDirA[len-1] == '\\')
906 cCurrDirA[len-1] = 0;
907 lstrcatA(cCurrDirA, "\\testdir");
908 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
909
910 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
911 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
912
913 /* test the shell attributes of the test directory using the absolute PIDL */
914 dwFlags = SFGAO_FOLDER;
915 hr = IShellFolder_GetAttributesOf(IDesktopFolder, 1, (LPCITEMIDLIST*)&newPIDL, &dwFlags);
916 ok (SUCCEEDED(hr), "Desktop->GetAttributesOf() failed! hr = %08x\n", hr);
917 ok ((dwFlags&SFGAO_FOLDER), "Wrong directory attribute for absolute PIDL: %08x\n", dwFlags);
918
919 /* free memory */
920 IMalloc_Free(ppM, newPIDL);
921
922 IShellFolder_Release(testIShellFolder);
923
924 Cleanup();
925
926 IShellFolder_Release(IDesktopFolder);
927 }
928
929 static void test_SHGetPathFromIDList(void)
930 {
931 SHITEMID emptyitem = { 0, { 0 } };
932 LPCITEMIDLIST pidlEmpty = (LPCITEMIDLIST)&emptyitem;
933 LPITEMIDLIST pidlMyComputer;
934 WCHAR wszPath[MAX_PATH], wszDesktop[MAX_PATH];
935 BOOL result;
936 HRESULT hr;
937 LPSHELLFOLDER psfDesktop;
938 WCHAR wszMyComputer[] = {
939 ':',':','{','2','0','D','0','4','F','E','0','-','3','A','E','A','-','1','0','6','9','-',
940 'A','2','D','8','-','0','8','0','0','2','B','3','0','3','0','9','D','}',0 };
941 WCHAR wszFileName[MAX_PATH];
942 LPITEMIDLIST pidlTestFile;
943 HANDLE hTestFile;
944 STRRET strret;
945 static WCHAR wszTestFile[] = {
946 'w','i','n','e','t','e','s','t','.','f','o','o',0 };
947 HRESULT (WINAPI *pSHGetSpecialFolderLocation)(HWND, int, LPITEMIDLIST *);
948 HMODULE hShell32;
949 LPITEMIDLIST pidlPrograms;
950
951 if(!pSHGetPathFromIDListW || !pSHGetSpecialFolderPathW)
952 {
953 win_skip("SHGetPathFromIDListW() or SHGetSpecialFolderPathW() is missing\n");
954 return;
955 }
956
957 /* Calling SHGetPathFromIDListW with no pidl should return the empty string */
958 wszPath[0] = 'a';
959 wszPath[1] = '\0';
960 result = pSHGetPathFromIDListW(NULL, wszPath);
961 ok(!result, "Expected failure\n");
962 ok(!wszPath[0], "Expected empty string\n");
963
964 /* Calling SHGetPathFromIDListW with an empty pidl should return the desktop folder's path. */
965 result = pSHGetSpecialFolderPathW(NULL, wszDesktop, CSIDL_DESKTOP, FALSE);
966 ok(result, "SHGetSpecialFolderPathW(CSIDL_DESKTOP) failed! Last error: %u\n", GetLastError());
967 if (!result) return;
968
969 /* Check if we are on Win9x */
970 SetLastError(0xdeadbeef);
971 lstrcmpiW(wszDesktop, wszDesktop);
972 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
973 {
974 win_skip("Most W-calls are not implemented\n");
975 return;
976 }
977
978 result = pSHGetPathFromIDListW(pidlEmpty, wszPath);
979 ok(result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
980 if (!result) return;
981 ok(!lstrcmpiW(wszDesktop, wszPath), "SHGetPathFromIDListW didn't return desktop path for empty pidl!\n");
982
983 /* MyComputer does not map to a filesystem path. SHGetPathFromIDListW should fail. */
984 hr = SHGetDesktopFolder(&psfDesktop);
985 ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
986 if (FAILED(hr)) return;
987
988 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszMyComputer, NULL, &pidlMyComputer, NULL);
989 ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse MyComputer's CLSID! hr = %08x\n", hr);
990 if (FAILED(hr)) {
991 IShellFolder_Release(psfDesktop);
992 return;
993 }
994
995 SetLastError(0xdeadbeef);
996 wszPath[0] = 'a';
997 wszPath[1] = '\0';
998 result = pSHGetPathFromIDListW(pidlMyComputer, wszPath);
999 ok (!result, "SHGetPathFromIDListW succeeded where it shouldn't!\n");
1000 ok (GetLastError()==0xdeadbeef ||
1001 GetLastError()==ERROR_SUCCESS, /* Vista and higher */
1002 "Unexpected last error from SHGetPathFromIDListW: %u\n", GetLastError());
1003 ok (!wszPath[0], "Expected empty path\n");
1004 if (result) {
1005 IShellFolder_Release(psfDesktop);
1006 return;
1007 }
1008
1009 IMalloc_Free(ppM, pidlMyComputer);
1010
1011 result = pSHGetSpecialFolderPathW(NULL, wszFileName, CSIDL_DESKTOPDIRECTORY, FALSE);
1012 ok(result, "SHGetSpecialFolderPathW failed! Last error: %u\n", GetLastError());
1013 if (!result) {
1014 IShellFolder_Release(psfDesktop);
1015 return;
1016 }
1017 myPathAddBackslashW(wszFileName);
1018 lstrcatW(wszFileName, wszTestFile);
1019 hTestFile = CreateFileW(wszFileName, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, NULL);
1020 ok(hTestFile != INVALID_HANDLE_VALUE, "CreateFileW failed! Last error: %u\n", GetLastError());
1021 if (hTestFile == INVALID_HANDLE_VALUE) {
1022 IShellFolder_Release(psfDesktop);
1023 return;
1024 }
1025 CloseHandle(hTestFile);
1026
1027 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszTestFile, NULL, &pidlTestFile, NULL);
1028 ok (SUCCEEDED(hr), "Desktop's ParseDisplayName failed to parse filename hr = %08x\n", hr);
1029 if (FAILED(hr)) {
1030 IShellFolder_Release(psfDesktop);
1031 DeleteFileW(wszFileName);
1032 IMalloc_Free(ppM, pidlTestFile);
1033 return;
1034 }
1035
1036 /* This test is to show that the Desktop shellfolder prepends the CSIDL_DESKTOPDIRECTORY
1037 * path for files placed on the desktop, if called with SHGDN_FORPARSING. */
1038 hr = IShellFolder_GetDisplayNameOf(psfDesktop, pidlTestFile, SHGDN_FORPARSING, &strret);
1039 ok (SUCCEEDED(hr), "Desktop's GetDisplayNamfOf failed! hr = %08x\n", hr);
1040 IShellFolder_Release(psfDesktop);
1041 DeleteFileW(wszFileName);
1042 if (FAILED(hr)) {
1043 IMalloc_Free(ppM, pidlTestFile);
1044 return;
1045 }
1046 if (pStrRetToBufW)
1047 {
1048 pStrRetToBufW(&strret, pidlTestFile, wszPath, MAX_PATH);
1049 ok(0 == lstrcmpW(wszFileName, wszPath),
1050 "Desktop->GetDisplayNameOf(pidlTestFile, SHGDN_FORPARSING) "
1051 "returned incorrect path for file placed on desktop\n");
1052 }
1053
1054 result = pSHGetPathFromIDListW(pidlTestFile, wszPath);
1055 ok(result, "SHGetPathFromIDListW failed! Last error: %u\n", GetLastError());
1056 IMalloc_Free(ppM, pidlTestFile);
1057 if (!result) return;
1058 ok(0 == lstrcmpW(wszFileName, wszPath), "SHGetPathFromIDListW returned incorrect path for file placed on desktop\n");
1059
1060
1061 /* Test if we can get the path from the start menu "program files" PIDL. */
1062 hShell32 = GetModuleHandleA("shell32");
1063 pSHGetSpecialFolderLocation = (void *)GetProcAddress(hShell32, "SHGetSpecialFolderLocation");
1064
1065 hr = pSHGetSpecialFolderLocation(NULL, CSIDL_PROGRAM_FILES, &pidlPrograms);
1066 ok(SUCCEEDED(hr), "SHGetFolderLocation failed: 0x%08x\n", hr);
1067
1068 SetLastError(0xdeadbeef);
1069 result = pSHGetPathFromIDListW(pidlPrograms, wszPath);
1070 IMalloc_Free(ppM, pidlPrograms);
1071 ok(result, "SHGetPathFromIDListW failed\n");
1072 }
1073
1074 static void test_EnumObjects_and_CompareIDs(void)
1075 {
1076 ITEMIDLIST *newPIDL;
1077 IShellFolder *IDesktopFolder, *testIShellFolder;
1078 char cCurrDirA [MAX_PATH] = {0};
1079 static const CHAR cTestDirA[] = "\\testdir";
1080 WCHAR cTestDirW[MAX_PATH];
1081 int len;
1082 HRESULT hr;
1083
1084 GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1085 len = lstrlenA(cCurrDirA);
1086
1087 if(len == 0) {
1088 win_skip("GetCurrentDirectoryA returned empty string. Skipping test_EnumObjects_and_CompareIDs\n");
1089 return;
1090 }
1091 if(cCurrDirA[len-1] == '\\')
1092 cCurrDirA[len-1] = 0;
1093
1094 lstrcatA(cCurrDirA, cTestDirA);
1095 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cTestDirW, MAX_PATH);
1096
1097 hr = SHGetDesktopFolder(&IDesktopFolder);
1098 ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1099
1100 CreateFilesFolders();
1101
1102 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cTestDirW, NULL, &newPIDL, 0);
1103 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1104
1105 hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1106 ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1107
1108 test_EnumObjects(testIShellFolder);
1109
1110 IShellFolder_Release(testIShellFolder);
1111
1112 Cleanup();
1113
1114 IMalloc_Free(ppM, newPIDL);
1115
1116 IShellFolder_Release(IDesktopFolder);
1117 }
1118
1119 /* A simple implementation of an IPropertyBag, which returns fixed values for
1120 * 'Target' and 'Attributes' properties.
1121 */
1122 static HRESULT WINAPI InitPropertyBag_IPropertyBag_QueryInterface(IPropertyBag *iface, REFIID riid,
1123 void **ppvObject)
1124 {
1125 if (!ppvObject)
1126 return E_INVALIDARG;
1127
1128 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPropertyBag, riid)) {
1129 *ppvObject = iface;
1130 } else {
1131 ok (FALSE, "InitPropertyBag asked for unknown interface!\n");
1132 return E_NOINTERFACE;
1133 }
1134
1135 IPropertyBag_AddRef(iface);
1136 return S_OK;
1137 }
1138
1139 static ULONG WINAPI InitPropertyBag_IPropertyBag_AddRef(IPropertyBag *iface) {
1140 return 2;
1141 }
1142
1143 static ULONG WINAPI InitPropertyBag_IPropertyBag_Release(IPropertyBag *iface) {
1144 return 1;
1145 }
1146
1147 static HRESULT WINAPI InitPropertyBag_IPropertyBag_Read(IPropertyBag *iface, LPCOLESTR pszPropName,
1148 VARIANT *pVar, IErrorLog *pErrorLog)
1149 {
1150 static const WCHAR wszTargetSpecialFolder[] = {
1151 'T','a','r','g','e','t','S','p','e','c','i','a','l','F','o','l','d','e','r',0 };
1152 static const WCHAR wszTarget[] = {
1153 'T','a','r','g','e','t',0 };
1154 static const WCHAR wszAttributes[] = {
1155 'A','t','t','r','i','b','u','t','e','s',0 };
1156 static const WCHAR wszResolveLinkFlags[] = {
1157 'R','e','s','o','l','v','e','L','i','n','k','F','l','a','g','s',0 };
1158 static const WCHAR wszTargetKnownFolder[] = {
1159 'T','a','r','g','e','t','K','n','o','w','n','F','o','l','d','e','r',0 };
1160 static const WCHAR wszCLSID[] = {
1161 'C','L','S','I','D',0 };
1162
1163 if (!lstrcmpW(pszPropName, wszTargetSpecialFolder)) {
1164 ok(V_VT(pVar) == VT_I4 ||
1165 broken(V_VT(pVar) == VT_BSTR), /* Win2k */
1166 "Wrong variant type for 'TargetSpecialFolder' property!\n");
1167 return E_INVALIDARG;
1168 }
1169
1170 if (!lstrcmpW(pszPropName, wszResolveLinkFlags))
1171 {
1172 ok(V_VT(pVar) == VT_UI4, "Wrong variant type for 'ResolveLinkFlags' property!\n");
1173 return E_INVALIDARG;
1174 }
1175
1176 if (!lstrcmpW(pszPropName, wszTarget)) {
1177 WCHAR wszPath[MAX_PATH];
1178 BOOL result;
1179
1180 ok(V_VT(pVar) == VT_BSTR ||
1181 broken(V_VT(pVar) == VT_EMPTY), /* Win2k */
1182 "Wrong variant type for 'Target' property!\n");
1183 if (V_VT(pVar) != VT_BSTR) return E_INVALIDARG;
1184
1185 result = pSHGetSpecialFolderPathW(NULL, wszPath, CSIDL_DESKTOPDIRECTORY, FALSE);
1186 ok(result, "SHGetSpecialFolderPathW(DESKTOPDIRECTORY) failed! %u\n", GetLastError());
1187 if (!result) return E_INVALIDARG;
1188
1189 V_BSTR(pVar) = SysAllocString(wszPath);
1190 return S_OK;
1191 }
1192
1193 if (!lstrcmpW(pszPropName, wszAttributes)) {
1194 ok(V_VT(pVar) == VT_UI4, "Wrong variant type for 'Attributes' property!\n");
1195 if (V_VT(pVar) != VT_UI4) return E_INVALIDARG;
1196 V_UI4(pVar) = SFGAO_FOLDER|SFGAO_HASSUBFOLDER|SFGAO_FILESYSANCESTOR|
1197 SFGAO_CANRENAME|SFGAO_FILESYSTEM;
1198 return S_OK;
1199 }
1200
1201 if (!lstrcmpW(pszPropName, wszTargetKnownFolder)) {
1202 ok(V_VT(pVar) == VT_BSTR, "Wrong variant type for 'TargetKnownFolder' property!\n");
1203 /* TODO */
1204 return E_INVALIDARG;
1205 }
1206
1207 if (!lstrcmpW(pszPropName, wszCLSID)) {
1208 ok(V_VT(pVar) == VT_EMPTY, "Wrong variant type for 'CLSID' property!\n");
1209 /* TODO */
1210 return E_INVALIDARG;
1211 }
1212
1213 ok(FALSE, "PropertyBag was asked for unknown property %s (vt=%d)!\n", wine_dbgstr_w(pszPropName), V_VT(pVar));
1214 return E_INVALIDARG;
1215 }
1216
1217 static HRESULT WINAPI InitPropertyBag_IPropertyBag_Write(IPropertyBag *iface, LPCOLESTR pszPropName,
1218 VARIANT *pVar)
1219 {
1220 ok(FALSE, "Unexpected call to IPropertyBag_Write\n");
1221 return E_NOTIMPL;
1222 }
1223
1224 static const IPropertyBagVtbl InitPropertyBag_IPropertyBagVtbl = {
1225 InitPropertyBag_IPropertyBag_QueryInterface,
1226 InitPropertyBag_IPropertyBag_AddRef,
1227 InitPropertyBag_IPropertyBag_Release,
1228 InitPropertyBag_IPropertyBag_Read,
1229 InitPropertyBag_IPropertyBag_Write
1230 };
1231
1232 static struct IPropertyBag InitPropertyBag = {
1233 &InitPropertyBag_IPropertyBagVtbl
1234 };
1235
1236 static void test_FolderShortcut(void) {
1237 IPersistPropertyBag *pPersistPropertyBag;
1238 IShellFolder *pShellFolder, *pDesktopFolder;
1239 IPersistFolder3 *pPersistFolder3;
1240 HRESULT hr;
1241 STRRET strret;
1242 WCHAR wszDesktopPath[MAX_PATH], wszBuffer[MAX_PATH];
1243 BOOL result;
1244 CLSID clsid;
1245 LPITEMIDLIST pidlCurrentFolder, pidlWineTestFolder, pidlSubFolder;
1246 HKEY hShellExtKey;
1247 WCHAR wszWineTestFolder[] = {
1248 ':',':','{','9','B','3','5','2','E','B','F','-','2','7','6','5','-','4','5','C','1','-',
1249 'B','4','C','6','-','8','5','C','C','7','F','7','A','B','C','6','4','}',0 };
1250 WCHAR wszShellExtKey[] = { 'S','o','f','t','w','a','r','e','\\',
1251 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
1252 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1253 'E','x','p','l','o','r','e','r','\\','D','e','s','k','t','o','p','\\',
1254 'N','a','m','e','S','p','a','c','e','\\',
1255 '{','9','b','3','5','2','e','b','f','-','2','7','6','5','-','4','5','c','1','-',
1256 'b','4','c','6','-','8','5','c','c','7','f','7','a','b','c','6','4','}',0 };
1257
1258 WCHAR wszSomeSubFolder[] = { 'S','u','b','F','o','l','d','e','r', 0};
1259 static const GUID CLSID_UnixDosFolder =
1260 {0x9d20aae8, 0x0625, 0x44b0, {0x9c, 0xa7, 0x71, 0x88, 0x9c, 0x22, 0x54, 0xd9}};
1261
1262 if (!pSHGetSpecialFolderPathW || !pStrRetToBufW) {
1263 win_skip("SHGetSpecialFolderPathW and/or StrRetToBufW are not available\n");
1264 return;
1265 }
1266
1267 if (!pSHGetFolderPathAndSubDirA)
1268 {
1269 win_skip("FolderShortcut test doesn't work on Win2k\n");
1270 return;
1271 }
1272
1273 /* These tests basically show, that CLSID_FolderShortcuts are initialized
1274 * via their IPersistPropertyBag interface. And that the target folder
1275 * is taken from the IPropertyBag's 'Target' property.
1276 */
1277 hr = CoCreateInstance(&CLSID_FolderShortcut, NULL, CLSCTX_INPROC_SERVER,
1278 &IID_IPersistPropertyBag, (LPVOID*)&pPersistPropertyBag);
1279 if (hr == REGDB_E_CLASSNOTREG) {
1280 win_skip("CLSID_FolderShortcut is not implemented\n");
1281 return;
1282 }
1283 ok (SUCCEEDED(hr), "CoCreateInstance failed! hr = 0x%08x\n", hr);
1284 if (FAILED(hr)) return;
1285
1286 hr = IPersistPropertyBag_Load(pPersistPropertyBag, &InitPropertyBag, NULL);
1287 ok(SUCCEEDED(hr), "IPersistPropertyBag_Load failed! hr = %08x\n", hr);
1288 if (FAILED(hr)) {
1289 IPersistPropertyBag_Release(pPersistPropertyBag);
1290 return;
1291 }
1292
1293 hr = IPersistPropertyBag_QueryInterface(pPersistPropertyBag, &IID_IShellFolder,
1294 (LPVOID*)&pShellFolder);
1295 IPersistPropertyBag_Release(pPersistPropertyBag);
1296 ok(SUCCEEDED(hr), "IPersistPropertyBag_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
1297 if (FAILED(hr)) return;
1298
1299 hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
1300 ok(SUCCEEDED(hr), "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
1301 if (FAILED(hr)) {
1302 IShellFolder_Release(pShellFolder);
1303 return;
1304 }
1305
1306 result = pSHGetSpecialFolderPathW(NULL, wszDesktopPath, CSIDL_DESKTOPDIRECTORY, FALSE);
1307 ok(result, "SHGetSpecialFolderPathW(CSIDL_DESKTOPDIRECTORY) failed! %u\n", GetLastError());
1308 if (!result) return;
1309
1310 pStrRetToBufW(&strret, NULL, wszBuffer, MAX_PATH);
1311 ok(!lstrcmpiW(wszDesktopPath, wszBuffer), "FolderShortcut returned incorrect folder!\n");
1312
1313 hr = IShellFolder_QueryInterface(pShellFolder, &IID_IPersistFolder3, (LPVOID*)&pPersistFolder3);
1314 IShellFolder_Release(pShellFolder);
1315 ok(SUCCEEDED(hr), "IShellFolder_QueryInterface(IID_IPersistFolder3 failed! hr = 0x%08x\n", hr);
1316 if (FAILED(hr)) return;
1317
1318 hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
1319 ok(SUCCEEDED(hr), "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
1320 ok(IsEqualCLSID(&clsid, &CLSID_FolderShortcut), "Unexpected CLSID!\n");
1321
1322 hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
1323 ok(SUCCEEDED(hr), "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
1324 ok(!pidlCurrentFolder, "IPersistFolder3_GetCurFolder should return a NULL pidl!\n");
1325
1326 /* For FolderShortcut objects, the Initialize method initialized the folder's position in the
1327 * shell namespace. The target folder, read from the property bag above, remains untouched.
1328 * The following tests show this: The itemidlist for some imaginary shellfolder object
1329 * is created and the FolderShortcut is initialized with it. GetCurFolder now returns this
1330 * itemidlist, but GetDisplayNameOf still returns the path from above.
1331 */
1332 hr = SHGetDesktopFolder(&pDesktopFolder);
1333 ok (SUCCEEDED(hr), "SHGetDesktopFolder failed! hr = %08x\n", hr);
1334 if (FAILED(hr)) return;
1335
1336 /* Temporarily register WineTestFolder as a shell namespace extension at the Desktop.
1337 * Otherwise ParseDisplayName fails on WinXP with E_INVALIDARG */
1338 RegCreateKeyW(HKEY_CURRENT_USER, wszShellExtKey, &hShellExtKey);
1339 RegCloseKey(hShellExtKey);
1340 hr = IShellFolder_ParseDisplayName(pDesktopFolder, NULL, NULL, wszWineTestFolder, NULL,
1341 &pidlWineTestFolder, NULL);
1342 RegDeleteKeyW(HKEY_CURRENT_USER, wszShellExtKey);
1343 IShellFolder_Release(pDesktopFolder);
1344 ok (SUCCEEDED(hr), "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
1345 if (FAILED(hr)) return;
1346
1347 hr = IPersistFolder3_Initialize(pPersistFolder3, pidlWineTestFolder);
1348 ok (SUCCEEDED(hr), "IPersistFolder3::Initialize failed! hr = %08x\n", hr);
1349 if (FAILED(hr)) {
1350 IPersistFolder3_Release(pPersistFolder3);
1351 pILFree(pidlWineTestFolder);
1352 return;
1353 }
1354
1355 hr = IPersistFolder3_GetCurFolder(pPersistFolder3, &pidlCurrentFolder);
1356 ok(SUCCEEDED(hr), "IPersistFolder3_GetCurFolder failed! hr=0x%08x\n", hr);
1357 ok(pILIsEqual(pidlCurrentFolder, pidlWineTestFolder),
1358 "IPersistFolder3_GetCurFolder should return pidlWineTestFolder!\n");
1359 pILFree(pidlCurrentFolder);
1360 pILFree(pidlWineTestFolder);
1361
1362 hr = IPersistFolder3_QueryInterface(pPersistFolder3, &IID_IShellFolder, (LPVOID*)&pShellFolder);
1363 IPersistFolder3_Release(pPersistFolder3);
1364 ok(SUCCEEDED(hr), "IPersistFolder3_QueryInterface(IShellFolder) failed! hr = %08x\n", hr);
1365 if (FAILED(hr)) return;
1366
1367 hr = IShellFolder_GetDisplayNameOf(pShellFolder, NULL, SHGDN_FORPARSING, &strret);
1368 ok(SUCCEEDED(hr), "IShellFolder_GetDisplayNameOf(NULL) failed! hr = %08x\n", hr);
1369 if (FAILED(hr)) {
1370 IShellFolder_Release(pShellFolder);
1371 return;
1372 }
1373
1374 pStrRetToBufW(&strret, NULL, wszBuffer, MAX_PATH);
1375 ok(!lstrcmpiW(wszDesktopPath, wszBuffer), "FolderShortcut returned incorrect folder!\n");
1376
1377 /* Next few lines are meant to show that children of FolderShortcuts are not FolderShortcuts,
1378 * but ShellFSFolders. */
1379 myPathAddBackslashW(wszDesktopPath);
1380 lstrcatW(wszDesktopPath, wszSomeSubFolder);
1381 if (!CreateDirectoryW(wszDesktopPath, NULL)) {
1382 IShellFolder_Release(pShellFolder);
1383 return;
1384 }
1385
1386 hr = IShellFolder_ParseDisplayName(pShellFolder, NULL, NULL, wszSomeSubFolder, NULL,
1387 &pidlSubFolder, NULL);
1388 RemoveDirectoryW(wszDesktopPath);
1389 ok (SUCCEEDED(hr), "IShellFolder::ParseDisplayName failed! hr = %08x\n", hr);
1390 if (FAILED(hr)) {
1391 IShellFolder_Release(pShellFolder);
1392 return;
1393 }
1394
1395 hr = IShellFolder_BindToObject(pShellFolder, pidlSubFolder, NULL, &IID_IPersistFolder3,
1396 (LPVOID*)&pPersistFolder3);
1397 IShellFolder_Release(pShellFolder);
1398 pILFree(pidlSubFolder);
1399 ok (SUCCEEDED(hr), "IShellFolder::BindToObject failed! hr = %08x\n", hr);
1400 if (FAILED(hr))
1401 return;
1402
1403 /* On windows, we expect CLSID_ShellFSFolder. On wine we relax this constraint
1404 * a little bit and also allow CLSID_UnixDosFolder. */
1405 hr = IPersistFolder3_GetClassID(pPersistFolder3, &clsid);
1406 ok(SUCCEEDED(hr), "IPersistFolder3_GetClassID failed! hr=0x%08x\n", hr);
1407 ok(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder) || IsEqualCLSID(&clsid, &CLSID_UnixDosFolder),
1408 "IPersistFolder3::GetClassID returned unexpected CLSID!\n");
1409
1410 IPersistFolder3_Release(pPersistFolder3);
1411 }
1412
1413 #include "pshpack1.h"
1414 struct FileStructA {
1415 BYTE type;
1416 BYTE dummy;
1417 DWORD dwFileSize;
1418 WORD uFileDate; /* In our current implementation this is */
1419 WORD uFileTime; /* FileTimeToDosDate(WIN32_FIND_DATA->ftLastWriteTime) */
1420 WORD uFileAttribs;
1421 CHAR szName[1];
1422 };
1423
1424 struct FileStructW {
1425 WORD cbLen; /* Length of this element. */
1426 BYTE abFooBar1[6]; /* Beyond any recognition. */
1427 WORD uDate; /* FileTimeToDosDate(WIN32_FIND_DATA->ftCreationTime)? */
1428 WORD uTime; /* (this is currently speculation) */
1429 WORD uDate2; /* FileTimeToDosDate(WIN32_FIND_DATA->ftLastAccessTime)? */
1430 WORD uTime2; /* (this is currently speculation) */
1431 BYTE abFooBar2[4]; /* Beyond any recognition. */
1432 WCHAR wszName[1]; /* The long filename in unicode. */
1433 /* Just for documentation: Right after the unicode string: */
1434 WORD cbOffset; /* FileStructW's offset from the beginning of the SHITMEID.
1435 * SHITEMID->cb == uOffset + cbLen */
1436 };
1437 #include "poppack.h"
1438
1439 static void test_ITEMIDLIST_format(void) {
1440 WCHAR wszPersonal[MAX_PATH];
1441 LPSHELLFOLDER psfDesktop, psfPersonal;
1442 LPITEMIDLIST pidlPersonal, pidlFile;
1443 HANDLE hFile;
1444 HRESULT hr;
1445 BOOL bResult;
1446 WCHAR wszFile[3][17] = { { 'e','v','e','n','_',0 }, { 'o','d','d','_',0 },
1447 { 'l','o','n','g','e','r','_','t','h','a','n','.','8','_','3',0 } };
1448 int i;
1449
1450 if (!pSHGetSpecialFolderPathW) return;
1451
1452 bResult = pSHGetSpecialFolderPathW(NULL, wszPersonal, CSIDL_PERSONAL, FALSE);
1453 ok(bResult, "SHGetSpecialFolderPathW failed! Last error: %u\n", GetLastError());
1454 if (!bResult) return;
1455
1456 SetLastError(0xdeadbeef);
1457 bResult = SetCurrentDirectoryW(wszPersonal);
1458 if (!bResult && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
1459 win_skip("Most W-calls are not implemented\n");
1460 return;
1461 }
1462 ok(bResult, "SetCurrentDirectory failed! Last error: %u\n", GetLastError());
1463 if (!bResult) return;
1464
1465 hr = SHGetDesktopFolder(&psfDesktop);
1466 ok(SUCCEEDED(hr), "SHGetDesktopFolder failed! hr: %08x\n", hr);
1467 if (FAILED(hr)) return;
1468
1469 hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, wszPersonal, NULL, &pidlPersonal, NULL);
1470 ok(SUCCEEDED(hr), "psfDesktop->ParseDisplayName failed! hr = %08x\n", hr);
1471 if (FAILED(hr)) {
1472 IShellFolder_Release(psfDesktop);
1473 return;
1474 }
1475
1476 hr = IShellFolder_BindToObject(psfDesktop, pidlPersonal, NULL, &IID_IShellFolder,
1477 (LPVOID*)&psfPersonal);
1478 IShellFolder_Release(psfDesktop);
1479 pILFree(pidlPersonal);
1480 ok(SUCCEEDED(hr), "psfDesktop->BindToObject failed! hr = %08x\n", hr);
1481 if (FAILED(hr)) return;
1482
1483 for (i=0; i<3; i++) {
1484 CHAR szFile[MAX_PATH];
1485 struct FileStructA *pFileStructA;
1486 WORD cbOffset;
1487
1488 WideCharToMultiByte(CP_ACP, 0, wszFile[i], -1, szFile, MAX_PATH, NULL, NULL);
1489
1490 hFile = CreateFileW(wszFile[i], GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_FLAG_WRITE_THROUGH, NULL);
1491 ok(hFile != INVALID_HANDLE_VALUE, "CreateFile failed! (%u)\n", GetLastError());
1492 if (hFile == INVALID_HANDLE_VALUE) {
1493 IShellFolder_Release(psfPersonal);
1494 return;
1495 }
1496 CloseHandle(hFile);
1497
1498 hr = IShellFolder_ParseDisplayName(psfPersonal, NULL, NULL, wszFile[i], NULL, &pidlFile, NULL);
1499 DeleteFileW(wszFile[i]);
1500 ok(SUCCEEDED(hr), "psfPersonal->ParseDisplayName failed! hr: %08x\n", hr);
1501 if (FAILED(hr)) {
1502 IShellFolder_Release(psfPersonal);
1503 return;
1504 }
1505
1506 pFileStructA = (struct FileStructA *)pidlFile->mkid.abID;
1507 ok(pFileStructA->type == 0x32, "PIDLTYPE should be 0x32!\n");
1508 ok(pFileStructA->dummy == 0x00, "Dummy Byte should be 0x00!\n");
1509 ok(pFileStructA->dwFileSize == 0, "Filesize should be zero!\n");
1510
1511 if (i < 2) /* First two file names are already in valid 8.3 format */
1512 ok(!strcmp(szFile, (CHAR*)&pidlFile->mkid.abID[12]), "Wrong file name!\n");
1513 else
1514 /* WinXP stores a derived 8.3 dos name (LONGER~1.8_3) here. We probably
1515 * can't implement this correctly, since unix filesystems don't support
1516 * this nasty short/long filename stuff. So we'll probably stay with our
1517 * current habbit of storing the long filename here, which seems to work
1518 * just fine. */
1519 todo_wine
1520 ok(pidlFile->mkid.abID[18] == '~' ||
1521 broken(pidlFile->mkid.abID[34] == '~'), /* Win2k */
1522 "Should be derived 8.3 name!\n");
1523
1524 if (i == 0) /* First file name has an even number of chars. No need for alignment. */
1525 ok(pidlFile->mkid.abID[12 + strlen(szFile) + 1] != '\0' ||
1526 broken(pidlFile->mkid.cb == 2 + 12 + strlen(szFile) + 1 + 1), /* Win2k */
1527 "Alignment byte, where there shouldn't be!\n");
1528
1529 if (i == 1) /* Second file name has an uneven number of chars => alignment byte */
1530 ok(pidlFile->mkid.abID[12 + strlen(szFile) + 1] == '\0',
1531 "There should be an alignment byte, but isn't!\n");
1532
1533 /* The offset of the FileStructW member is stored as a WORD at the end of the pidl. */
1534 cbOffset = *(WORD*)(((LPBYTE)pidlFile)+pidlFile->mkid.cb-sizeof(WORD));
1535 ok ((cbOffset >= sizeof(struct FileStructA) &&
1536 cbOffset <= pidlFile->mkid.cb - sizeof(struct FileStructW)) ||
1537 broken(pidlFile->mkid.cb == 2 + 12 + strlen(szFile) + 1 + 1) || /* Win2k on short names */
1538 broken(pidlFile->mkid.cb == 2 + 12 + strlen(szFile) + 1 + 12 + 1), /* Win2k on long names */
1539 "Wrong offset value (%d) stored at the end of the PIDL\n", cbOffset);
1540
1541 if (cbOffset >= sizeof(struct FileStructA) &&
1542 cbOffset <= pidlFile->mkid.cb - sizeof(struct FileStructW))
1543 {
1544 struct FileStructW *pFileStructW = (struct FileStructW *)(((LPBYTE)pidlFile)+cbOffset);
1545
1546 ok(pidlFile->mkid.cb == cbOffset + pFileStructW->cbLen,
1547 "FileStructW's offset and length should add up to the PIDL's length!\n");
1548
1549 if (pidlFile->mkid.cb == cbOffset + pFileStructW->cbLen) {
1550 /* Since we just created the file, time of creation,
1551 * time of last access and time of last write access just be the same.
1552 * These tests seem to fail sometimes (on WinXP), if the test is run again shortly
1553 * after the first run. I do remember something with NTFS keeping the creation time
1554 * if a file is deleted and then created again within a couple of seconds or so.
1555 * Might be the reason. */
1556 ok (pFileStructA->uFileDate == pFileStructW->uDate &&
1557 pFileStructA->uFileTime == pFileStructW->uTime,
1558 "Last write time should match creation time!\n");
1559
1560 /* On FAT filesystems the last access time is midnight
1561 local time, so the values of uDate2 and uTime2 will
1562 depend on the local timezone. If the times are exactly
1563 equal then the dates should be identical for both FAT
1564 and NTFS as no timezone is more than 1 day away from UTC.
1565 */
1566 if (pFileStructA->uFileTime == pFileStructW->uTime2)
1567 {
1568 ok (pFileStructA->uFileDate == pFileStructW->uDate2,
1569 "Last write date and time should match last access date and time!\n");
1570 }
1571 else
1572 {
1573 /* Filesystem may be FAT. Check date within 1 day
1574 and seconds are zero. */
1575 trace ("Filesystem may be FAT. Performing less strict atime test.\n");
1576 ok ((pFileStructW->uTime2 & 0x1F) == 0,
1577 "Last access time on FAT filesystems should have zero seconds.\n");
1578 /* TODO: Perform check for date being within one day.*/
1579 }
1580
1581 ok (!lstrcmpW(wszFile[i], pFileStructW->wszName) ||
1582 !lstrcmpW(wszFile[i], (WCHAR *)(pFileStructW->abFooBar2 + 22)) || /* Vista */
1583 !lstrcmpW(wszFile[i], (WCHAR *)(pFileStructW->abFooBar2 + 26)), /* Win7 */
1584 "The filename should be stored in unicode at this position!\n");
1585 }
1586 }
1587
1588 pILFree(pidlFile);
1589 }
1590
1591 IShellFolder_Release(psfPersonal);
1592 }
1593
1594 static void test_SHGetFolderPathAndSubDirA(void)
1595 {
1596 HRESULT ret;
1597 BOOL delret;
1598 DWORD dwret;
1599 int i;
1600 static char wine[] = "wine";
1601 static char winetemp[] = "wine\\temp";
1602 static char appdata[MAX_PATH];
1603 static char testpath[MAX_PATH];
1604 static char toolongpath[MAX_PATH+1];
1605
1606 if(!pSHGetFolderPathAndSubDirA)
1607 {
1608 win_skip("SHGetFolderPathAndSubDirA not present!\n");
1609 return;
1610 }
1611
1612 if(!pSHGetFolderPathA) {
1613 win_skip("SHGetFolderPathA not present!\n");
1614 return;
1615 }
1616 if(FAILED(pSHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, appdata)))
1617 {
1618 win_skip("SHGetFolderPathA failed for CSIDL_LOCAL_APPDATA!\n");
1619 return;
1620 }
1621
1622 sprintf(testpath, "%s\\%s", appdata, winetemp);
1623 delret = RemoveDirectoryA(testpath);
1624 if(!delret && (ERROR_PATH_NOT_FOUND != GetLastError()) ) {
1625 win_skip("RemoveDirectoryA(%s) failed with error %u\n", testpath, GetLastError());
1626 return;
1627 }
1628
1629 sprintf(testpath, "%s\\%s", appdata, wine);
1630 delret = RemoveDirectoryA(testpath);
1631 if(!delret && (ERROR_PATH_NOT_FOUND != GetLastError()) && (ERROR_FILE_NOT_FOUND != GetLastError())) {
1632 win_skip("RemoveDirectoryA(%s) failed with error %u\n", testpath, GetLastError());
1633 return;
1634 }
1635
1636 /* test invalid second parameter */
1637 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | 0xff, NULL, SHGFP_TYPE_CURRENT, wine, testpath);
1638 ok(E_INVALIDARG == ret, "expected E_INVALIDARG, got %x\n", ret);
1639
1640 /* test fourth parameter */
1641 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, 2, winetemp, testpath);
1642 switch(ret) {
1643 case S_OK: /* winvista */
1644 ok(!strncmp(appdata, testpath, strlen(appdata)),
1645 "expected %s to start with %s\n", testpath, appdata);
1646 ok(!lstrcmpA(&testpath[1 + strlen(appdata)], winetemp),
1647 "expected %s to end with %s\n", testpath, winetemp);
1648 break;
1649 case E_INVALIDARG: /* winxp, win2k3 */
1650 break;
1651 default:
1652 ok(0, "expected S_OK or E_INVALIDARG, got %x\n", ret);
1653 }
1654
1655 /* test fifth parameter */
1656 testpath[0] = '\0';
1657 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, NULL, testpath);
1658 ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1659 ok(!lstrcmpA(appdata, testpath), "expected %s, got %s\n", appdata, testpath);
1660
1661 testpath[0] = '\0';
1662 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, "", testpath);
1663 ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1664 ok(!lstrcmpA(appdata, testpath), "expected %s, got %s\n", appdata, testpath);
1665
1666 testpath[0] = '\0';
1667 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, "\\", testpath);
1668 ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1669 ok(!lstrcmpA(appdata, testpath), "expected %s, got %s\n", appdata, testpath);
1670
1671 for(i=0; i< MAX_PATH; i++)
1672 toolongpath[i] = '0' + i % 10;
1673 toolongpath[MAX_PATH] = '\0';
1674 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, toolongpath, testpath);
1675 ok(HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) == ret,
1676 "expected %x, got %x\n", HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE), ret);
1677
1678 testpath[0] = '\0';
1679 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_DONT_VERIFY | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, wine, NULL);
1680 ok((S_OK == ret) || (E_INVALIDARG == ret), "expected S_OK or E_INVALIDARG, got %x\n", ret);
1681
1682 /* test a not existing path */
1683 testpath[0] = '\0';
1684 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, winetemp, testpath);
1685 ok(HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) == ret,
1686 "expected %x, got %x\n", HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), ret);
1687
1688 /* create a directory inside a not existing directory */
1689 testpath[0] = '\0';
1690 ret = pSHGetFolderPathAndSubDirA(NULL, CSIDL_FLAG_CREATE | CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, winetemp, testpath);
1691 ok(S_OK == ret, "expected S_OK, got %x\n", ret);
1692 ok(!strncmp(appdata, testpath, strlen(appdata)),
1693 "expected %s to start with %s\n", testpath, appdata);
1694 ok(!lstrcmpA(&testpath[1 + strlen(appdata)], winetemp),
1695 "expected %s to end with %s\n", testpath, winetemp);
1696 dwret = GetFileAttributes(testpath);
1697 ok(FILE_ATTRIBUTE_DIRECTORY | dwret, "expected %x to contain FILE_ATTRIBUTE_DIRECTORY\n", dwret);
1698
1699 /* cleanup */
1700 sprintf(testpath, "%s\\%s", appdata, winetemp);
1701 RemoveDirectoryA(testpath);
1702 sprintf(testpath, "%s\\%s", appdata, wine);
1703 RemoveDirectoryA(testpath);
1704 }
1705
1706 static void test_LocalizedNames(void)
1707 {
1708 static char cCurrDirA[MAX_PATH];
1709 WCHAR cCurrDirW[MAX_PATH], tempbufW[25];
1710 IShellFolder *IDesktopFolder, *testIShellFolder;
1711 ITEMIDLIST *newPIDL;
1712 int len;
1713 HRESULT hr;
1714 static char resourcefile[MAX_PATH];
1715 DWORD res;
1716 HANDLE file;
1717 STRRET strret;
1718
1719 static const char desktopini_contents1[] =
1720 "[.ShellClassInfo]\r\n"
1721 "LocalizedResourceName=@";
1722 static const char desktopini_contents2[] =
1723 ",-1\r\n";
1724 static WCHAR foldernameW[] = {'t','e','s','t','f','o','l','d','e','r',0};
1725 static const WCHAR folderdisplayW[] = {'F','o','l','d','e','r',' ','N','a','m','e',' ','R','e','s','o','u','r','c','e',0};
1726
1727 /* create folder with desktop.ini and localized name in GetModuleFileNameA(NULL) */
1728 CreateDirectoryA(".\\testfolder", NULL);
1729
1730 SetFileAttributesA(".\\testfolder", GetFileAttributesA(".\\testfolder")|FILE_ATTRIBUTE_SYSTEM);
1731
1732 GetModuleFileNameA(NULL, resourcefile, MAX_PATH);
1733
1734 file = CreateFileA(".\\testfolder\\desktop.ini", GENERIC_WRITE, 0, NULL,
1735 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1736 ok(file != INVALID_HANDLE_VALUE, "CreateFileA failed %i\n", GetLastError());
1737 ok(WriteFile(file, desktopini_contents1, strlen(desktopini_contents1), &res, NULL) &&
1738 WriteFile(file, resourcefile, strlen(resourcefile), &res, NULL) &&
1739 WriteFile(file, desktopini_contents2, strlen(desktopini_contents2), &res, NULL),
1740 "WriteFile failed %i\n", GetLastError());
1741 CloseHandle(file);
1742
1743 /* get IShellFolder for parent */
1744 GetCurrentDirectoryA(MAX_PATH, cCurrDirA);
1745 len = lstrlenA(cCurrDirA);
1746
1747 if (len == 0) {
1748 win_skip("GetCurrentDirectoryA returned empty string. Skipping test_LocalizedNames\n");
1749 goto cleanup;
1750 }
1751 if(cCurrDirA[len-1] == '\\')
1752 cCurrDirA[len-1] = 0;
1753
1754 MultiByteToWideChar(CP_ACP, 0, cCurrDirA, -1, cCurrDirW, MAX_PATH);
1755
1756 hr = SHGetDesktopFolder(&IDesktopFolder);
1757 ok(hr == S_OK, "SHGetDesktopfolder failed %08x\n", hr);
1758
1759 hr = IShellFolder_ParseDisplayName(IDesktopFolder, NULL, NULL, cCurrDirW, NULL, &newPIDL, 0);
1760 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1761
1762 hr = IShellFolder_BindToObject(IDesktopFolder, newPIDL, NULL, (REFIID)&IID_IShellFolder, (LPVOID *)&testIShellFolder);
1763 ok(hr == S_OK, "BindToObject failed %08x\n", hr);
1764
1765 IMalloc_Free(ppM, newPIDL);
1766
1767 /* windows reads the display name from the resource */
1768 hr = IShellFolder_ParseDisplayName(testIShellFolder, NULL, NULL, foldernameW, NULL, &newPIDL, 0);
1769 ok(hr == S_OK, "ParseDisplayName failed %08x\n", hr);
1770
1771 hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER, &strret);
1772 ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1773
1774 if (SUCCEEDED(hr) && pStrRetToBufW)
1775 {
1776 hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
1777 ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
1778 todo_wine
1779 ok (!lstrcmpiW(tempbufW, folderdisplayW) ||
1780 broken(!lstrcmpiW(tempbufW, foldernameW)), /* W2K */
1781 "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1782 }
1783
1784 /* editing name is also read from the resource */
1785 hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FOREDITING, &strret);
1786 ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1787
1788 if (SUCCEEDED(hr) && pStrRetToBufW)
1789 {
1790 hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
1791 ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
1792 todo_wine
1793 ok (!lstrcmpiW(tempbufW, folderdisplayW) ||
1794 broken(!lstrcmpiW(tempbufW, foldernameW)), /* W2K */
1795 "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1796 }
1797
1798 /* parsing name is unchanged */
1799 hr = IShellFolder_GetDisplayNameOf(testIShellFolder, newPIDL, SHGDN_INFOLDER|SHGDN_FORPARSING, &strret);
1800 ok(hr == S_OK, "GetDisplayNameOf failed %08x\n", hr);
1801
1802 if (SUCCEEDED(hr) && pStrRetToBufW)
1803 {
1804 hr = pStrRetToBufW(&strret, newPIDL, tempbufW, sizeof(tempbufW)/sizeof(WCHAR));
1805 ok (SUCCEEDED(hr), "StrRetToBufW failed! hr = %08x\n", hr);
1806 ok (!lstrcmpiW(tempbufW, foldernameW), "GetDisplayNameOf returned %s\n", wine_dbgstr_w(tempbufW));
1807 }
1808
1809 IShellFolder_Release(IDesktopFolder);
1810 IShellFolder_Release(testIShellFolder);
1811
1812 IMalloc_Free(ppM, newPIDL);
1813
1814 cleanup:
1815 DeleteFileA(".\\testfolder\\desktop.ini");
1816 SetFileAttributesA(".\\testfolder", GetFileAttributesA(".\\testfolder")&~FILE_ATTRIBUTE_SYSTEM);
1817 RemoveDirectoryA(".\\testfolder");
1818 }
1819
1820 static void test_SHCreateShellItem(void)
1821 {
1822 IShellItem *shellitem, *shellitem2;
1823 IPersistIDList *persistidl;
1824 LPITEMIDLIST pidl_cwd=NULL, pidl_testfile, pidl_abstestfile, pidl_test;
1825 HRESULT ret;
1826 char curdirA[MAX_PATH];
1827 WCHAR curdirW[MAX_PATH];
1828 IShellFolder *desktopfolder=NULL, *currentfolder=NULL;
1829 static WCHAR testfileW[] = {'t','e','s','t','f','i','l','e',0};
1830
1831 GetCurrentDirectoryA(MAX_PATH, curdirA);
1832
1833 if (!pSHCreateShellItem)
1834 {
1835 win_skip("SHCreateShellItem isn't available\n");
1836 return;
1837 }
1838
1839 if (!lstrlenA(curdirA))
1840 {
1841 win_skip("GetCurrentDirectoryA returned empty string, skipping test_SHCreateShellItem\n");
1842 return;
1843 }
1844
1845 MultiByteToWideChar(CP_ACP, 0, curdirA, -1, curdirW, MAX_PATH);
1846
1847 ret = SHGetDesktopFolder(&desktopfolder);
1848 ok(SUCCEEDED(ret), "SHGetShellFolder returned %x\n", ret);
1849
1850 ret = IShellFolder_ParseDisplayName(desktopfolder, NULL, NULL, curdirW, NULL, &pidl_cwd, NULL);
1851 ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
1852
1853 ret = IShellFolder_BindToObject(desktopfolder, pidl_cwd, NULL, &IID_IShellFolder, (void**)&currentfolder);
1854 ok(SUCCEEDED(ret), "BindToObject returned %x\n", ret);
1855
1856 CreateTestFile(".\\testfile");
1857
1858 ret = IShellFolder_ParseDisplayName(currentfolder, NULL, NULL, testfileW, NULL, &pidl_testfile, NULL);
1859 ok(SUCCEEDED(ret), "ParseDisplayName returned %x\n", ret);
1860
1861 pidl_abstestfile = pILCombine(pidl_cwd, pidl_testfile);
1862
1863 ret = pSHCreateShellItem(NULL, NULL, NULL, &shellitem);
1864 ok(ret == E_INVALIDARG, "SHCreateShellItem returned %x\n", ret);
1865
1866 if (0) /* crashes on Windows XP */
1867 {
1868 pSHCreateShellItem(NULL, NULL, pidl_cwd, NULL);
1869 pSHCreateShellItem(pidl_cwd, NULL, NULL, &shellitem);
1870 pSHCreateShellItem(NULL, currentfolder, NULL, &shellitem);
1871 pSHCreateShellItem(pidl_cwd, currentfolder, NULL, &shellitem);
1872 }
1873
1874 ret = pSHCreateShellItem(NULL, NULL, pidl_cwd, &shellitem);
1875 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1876 if (SUCCEEDED(ret))
1877 {
1878 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1879 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1880 if (SUCCEEDED(ret))
1881 {
1882 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1883 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1884 if (SUCCEEDED(ret))
1885 {
1886 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
1887 pILFree(pidl_test);
1888 }
1889 IPersistIDList_Release(persistidl);
1890 }
1891 IShellItem_Release(shellitem);
1892 }
1893
1894 ret = pSHCreateShellItem(pidl_cwd, NULL, pidl_testfile, &shellitem);
1895 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1896 if (SUCCEEDED(ret))
1897 {
1898 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1899 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1900 if (SUCCEEDED(ret))
1901 {
1902 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1903 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1904 if (SUCCEEDED(ret))
1905 {
1906 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
1907 pILFree(pidl_test);
1908 }
1909 IPersistIDList_Release(persistidl);
1910 }
1911
1912 ret = IShellItem_GetParent(shellitem, &shellitem2);
1913 ok(SUCCEEDED(ret), "GetParent returned %x\n", ret);
1914 if (SUCCEEDED(ret))
1915 {
1916 ret = IShellItem_QueryInterface(shellitem2, &IID_IPersistIDList, (void**)&persistidl);
1917 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1918 if (SUCCEEDED(ret))
1919 {
1920 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1921 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1922 if (SUCCEEDED(ret))
1923 {
1924 ok(ILIsEqual(pidl_cwd, pidl_test), "id lists are not equal\n");
1925 pILFree(pidl_test);
1926 }
1927 IPersistIDList_Release(persistidl);
1928 }
1929 IShellItem_Release(shellitem2);
1930 }
1931
1932 IShellItem_Release(shellitem);
1933 }
1934
1935 ret = pSHCreateShellItem(NULL, currentfolder, pidl_testfile, &shellitem);
1936 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1937 if (SUCCEEDED(ret))
1938 {
1939 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1940 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1941 if (SUCCEEDED(ret))
1942 {
1943 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1944 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1945 if (SUCCEEDED(ret))
1946 {
1947 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
1948 pILFree(pidl_test);
1949 }
1950 IPersistIDList_Release(persistidl);
1951 }
1952 IShellItem_Release(shellitem);
1953 }
1954
1955 /* if a parent pidl and shellfolder are specified, the shellfolder is ignored */
1956 ret = pSHCreateShellItem(pidl_cwd, desktopfolder, pidl_testfile, &shellitem);
1957 ok(SUCCEEDED(ret), "SHCreateShellItem returned %x\n", ret);
1958 if (SUCCEEDED(ret))
1959 {
1960 ret = IShellItem_QueryInterface(shellitem, &IID_IPersistIDList, (void**)&persistidl);
1961 ok(SUCCEEDED(ret), "QueryInterface returned %x\n", ret);
1962 if (SUCCEEDED(ret))
1963 {
1964 ret = IPersistIDList_GetIDList(persistidl, &pidl_test);
1965 ok(SUCCEEDED(ret), "GetIDList returned %x\n", ret);
1966 if (SUCCEEDED(ret))
1967 {
1968 ok(ILIsEqual(pidl_abstestfile, pidl_test), "id lists are not equal\n");
1969 pILFree(pidl_test);
1970 }
1971 IPersistIDList_Release(persistidl);
1972 }
1973 IShellItem_Release(shellitem);
1974 }
1975
1976 DeleteFileA(".\\testfile");
1977 pILFree(pidl_abstestfile);
1978 pILFree(pidl_testfile);
1979 pILFree(pidl_cwd);
1980 IShellFolder_Release(currentfolder);
1981 IShellFolder_Release(desktopfolder);
1982 }
1983
1984 static void test_SHParseDisplayName(void)
1985 {
1986 static const WCHAR prefixW[] = {'w','t',0};
1987 LPITEMIDLIST pidl1, pidl2;
1988 IShellFolder *desktop;
1989 WCHAR dirW[MAX_PATH];
1990 WCHAR nameW[10];
1991 HRESULT hr;
1992 BOOL ret;
1993
1994 if (!pSHParseDisplayName)
1995 {
1996 win_skip("SHParseDisplayName isn't available\n");
1997 return;
1998 }
1999
2000 if (0)
2001 {
2002 /* crashes on native */
2003 hr = pSHParseDisplayName(NULL, NULL, NULL, 0, NULL);
2004 nameW[0] = 0;
2005 hr = pSHParseDisplayName(nameW, NULL, NULL, 0, NULL);
2006 }
2007
2008 pidl1 = (LPITEMIDLIST)0xdeadbeef;
2009 hr = pSHParseDisplayName(NULL, NULL, &pidl1, 0, NULL);
2010 ok(broken(hr == E_OUTOFMEMORY) /* < Vista */ ||
2011 hr == E_INVALIDARG, "failed %08x\n", hr);
2012 ok(pidl1 == 0, "expected null ptr, got %p\n", pidl1);
2013
2014 /* dummy name */
2015 nameW[0] = 0;
2016 hr = pSHParseDisplayName(nameW, NULL, &pidl1, 0, NULL);
2017 ok(hr == S_OK, "failed %08x\n", hr);
2018 hr = SHGetDesktopFolder(&desktop);
2019 ok(hr == S_OK, "failed %08x\n", hr);
2020 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, nameW, NULL, &pidl2, NULL);
2021 ok(hr == S_OK, "failed %08x\n", hr);
2022 ret = pILIsEqual(pidl1, pidl2);
2023 ok(ret == TRUE, "expected equal idls\n");
2024 pILFree(pidl1);
2025 pILFree(pidl2);
2026
2027 /* with path */
2028 GetTempPathW(sizeof(dirW)/sizeof(WCHAR), dirW);
2029 GetTempFileNameW(dirW, prefixW, 0, dirW);
2030 CreateFileW(dirW, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
2031
2032 hr = pSHParseDisplayName(dirW, NULL, &pidl1, 0, NULL);
2033 ok(hr == S_OK, "failed %08x\n", hr);
2034 hr = IShellFolder_ParseDisplayName(desktop, NULL, NULL, dirW, NULL, &pidl2, NULL);
2035 ok(hr == S_OK, "failed %08x\n", hr);
2036
2037 ret = pILIsEqual(pidl1, pidl2);
2038 ok(ret == TRUE, "expected equal idls\n");
2039 pILFree(pidl1);
2040 pILFree(pidl2);
2041
2042 DeleteFileW(dirW);
2043
2044 IShellFolder_Release(desktop);
2045 }
2046
2047 START_TEST(shlfolder)
2048 {
2049 init_function_pointers();
2050 /* if OleInitialize doesn't get called, ParseDisplayName returns
2051 CO_E_NOTINITIALIZED for malformed directory names on win2k. */
2052 OleInitialize(NULL);
2053
2054 test_ParseDisplayName();
2055 test_SHParseDisplayName();
2056 test_BindToObject();
2057 test_EnumObjects_and_CompareIDs();
2058 test_GetDisplayName();
2059 test_GetAttributesOf();
2060 test_SHGetPathFromIDList();
2061 test_CallForAttributes();
2062 test_FolderShortcut();
2063 test_ITEMIDLIST_format();
2064 test_SHGetFolderPathAndSubDirA();
2065 test_LocalizedNames();
2066 test_SHCreateShellItem();
2067
2068 OleUninitialize();
2069 }
useful hacks and other patches not (yet) suitable for mainline