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

   1 /*
   2  * Unit test of the SHFileOperation function.
   3  *
   4  * Copyright 2002 Andriy Palamarchuk
   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 WINE_NOWINSOCK
  25 #include <windows.h>
  26 #include "shellapi.h"
  27 #include "shlobj.h"
  28
  29 #include "wine/test.h"
  30
  31 #ifndef FOF_NORECURSION
  32 #define FOF_NORECURSION 0x1000
  33 #endif
  34
  35 /* Error codes could be pre-Win32 */
  36 #define DE_OPCANCELLED 0x75
  37 #define expect_retval(ret, ret_prewin32)\
  38     ok(retval == ret ||\
  39        broken(retval == ret_prewin32),\
  40        "Expected %d, got %d\n", ret, retval)
  41
  42 static CHAR CURR_DIR[MAX_PATH];
  43 static const WCHAR UNICODE_PATH[] = {'c',':','\\',0x00c4,'\0','\0'};
  44     /* "c:\Ä", or "c:\A" with diaeresis */
  45     /* Double-null termination needed for pFrom field of SHFILEOPSTRUCT */
  46
  47 static HMODULE hshell32;
  48 static int (WINAPI *pSHCreateDirectoryExA)(HWND, LPCSTR, LPSECURITY_ATTRIBUTES);
  49 static int (WINAPI *pSHCreateDirectoryExW)(HWND, LPCWSTR, LPSECURITY_ATTRIBUTES);
  50 static int (WINAPI *pSHFileOperationW)(LPSHFILEOPSTRUCTW);
  51 static DWORD_PTR (WINAPI *pSHGetFileInfoW)(LPCWSTR, DWORD , SHFILEINFOW*, UINT, UINT);
  52 static int (WINAPI *pSHPathPrepareForWriteA)(HWND, IUnknown*, LPCSTR, DWORD);
  53 static int (WINAPI *pSHPathPrepareForWriteW)(HWND, IUnknown*, LPCWSTR, DWORD);
  54
  55 static void InitFunctionPointers(void)
  56 {
  57     hshell32 = GetModuleHandleA("shell32.dll");
  58     pSHCreateDirectoryExA = (void*)GetProcAddress(hshell32, "SHCreateDirectoryExA");
  59     pSHCreateDirectoryExW = (void*)GetProcAddress(hshell32, "SHCreateDirectoryExW");
  60     pSHFileOperationW = (void*)GetProcAddress(hshell32, "SHFileOperationW");
  61     pSHGetFileInfoW = (void*)GetProcAddress(hshell32, "SHGetFileInfoW");
  62     pSHPathPrepareForWriteA = (void*)GetProcAddress(hshell32, "SHPathPrepareForWriteA");
  63     pSHPathPrepareForWriteW = (void*)GetProcAddress(hshell32, "SHPathPrepareForWriteW");
  64 }
  65
  66 /* creates a file with the specified name for tests */
  67 static void createTestFile(const CHAR *name)
  68 {
  69     HANDLE file;
  70     DWORD written;
  71
  72     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
  73     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
  74     WriteFile(file, name, strlen(name), &written, NULL);
  75     WriteFile(file, "\n", strlen("\n"), &written, NULL);
  76     CloseHandle(file);
  77 }
  78
  79 static void createTestFileW(const WCHAR *name)
  80 {
  81     HANDLE file;
  82
  83     file = CreateFileW(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
  84     ok(file != INVALID_HANDLE_VALUE, "Failure to open file\n");
  85     CloseHandle(file);
  86 }
  87
  88 static BOOL file_exists(const CHAR *name)
  89 {
  90     return GetFileAttributesA(name) != INVALID_FILE_ATTRIBUTES;
  91 }
  92
  93 static BOOL file_existsW(LPCWSTR name)
  94 {
  95   return GetFileAttributesW(name) != INVALID_FILE_ATTRIBUTES;
  96 }
  97
  98 static BOOL file_has_content(const CHAR *name, const CHAR *content)
  99 {
 100     CHAR buf[MAX_PATH];
 101     HANDLE file;
 102     DWORD read;
 103
 104     file = CreateFileA(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
 105     if (file == INVALID_HANDLE_VALUE)
 106         return FALSE;
 107     ReadFile(file, buf, MAX_PATH - 1, &read, NULL);
 108     buf[read] = 0;
 109     CloseHandle(file);
 110     return strcmp(buf, content)==0;
 111 }
 112
 113 /* initializes the tests */
 114 static void init_shfo_tests(void)
 115 {
 116     int len;
 117
 118     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
 119     len = lstrlenA(CURR_DIR);
 120
 121     if(len && (CURR_DIR[len-1] == '\\'))
 122         CURR_DIR[len-1] = 0;
 123
 124     createTestFile("test1.txt");
 125     createTestFile("test2.txt");
 126     createTestFile("test3.txt");
 127     createTestFile("test_5.txt");
 128     CreateDirectoryA("test4.txt", NULL);
 129     CreateDirectoryA("testdir2", NULL);
 130     CreateDirectoryA("testdir2\\nested", NULL);
 131     createTestFile("testdir2\\one.txt");
 132     createTestFile("testdir2\\nested\\two.txt");
 133 }
 134
 135 /* cleans after tests */
 136 static void clean_after_shfo_tests(void)
 137 {
 138     DeleteFileA("test1.txt");
 139     DeleteFileA("test2.txt");
 140     DeleteFileA("test3.txt");
 141     DeleteFileA("test_5.txt");
 142     DeleteFileA("one.txt");
 143     DeleteFileA("test4.txt\\test1.txt");
 144     DeleteFileA("test4.txt\\test2.txt");
 145     DeleteFileA("test4.txt\\test3.txt");
 146     RemoveDirectoryA("test4.txt");
 147     DeleteFileA("testdir2\\one.txt");
 148     DeleteFileA("testdir2\\test1.txt");
 149     DeleteFileA("testdir2\\test2.txt");
 150     DeleteFileA("testdir2\\test3.txt");
 151     DeleteFileA("testdir2\\test4.txt\\test1.txt");
 152     DeleteFileA("testdir2\\nested\\two.txt");
 153     RemoveDirectoryA("testdir2\\test4.txt");
 154     RemoveDirectoryA("testdir2\\nested");
 155     RemoveDirectoryA("testdir2");
 156     RemoveDirectoryA("c:\\testdir3");
 157     DeleteFileA("nonexistent\\notreal\\test2.txt");
 158     RemoveDirectoryA("nonexistent\\notreal");
 159     RemoveDirectoryA("nonexistent");
 160 }
 161
 162
 163 static void test_get_file_info(void)
 164 {
 165     DWORD rc, rc2;
 166     SHFILEINFOA shfi, shfi2;
 167     SHFILEINFOW shfiw;
 168     char notepad[MAX_PATH];
 169
 170     /* Test whether fields of SHFILEINFOA are always cleared */
 171     memset(&shfi, 0xcf, sizeof(shfi));
 172     rc=SHGetFileInfoA("", 0, &shfi, sizeof(shfi), 0);
 173     ok(rc, "SHGetFileInfoA('' | 0) should not fail\n");
 174     todo_wine ok(shfi.hIcon == 0, "SHGetFileInfoA('' | 0) did not clear hIcon\n");
 175     todo_wine ok(shfi.szDisplayName[0] == 0, "SHGetFileInfoA('' | 0) did not clear szDisplayName[0]\n");
 176     todo_wine ok(shfi.szTypeName[0] == 0, "SHGetFileInfoA('' | 0) did not clear szTypeName[0]\n");
 177     ok(shfi.iIcon == 0xcfcfcfcf, "SHGetFileInfoA('' | 0) should not clear iIcon\n");
 178     ok(shfi.dwAttributes == 0xcfcfcfcf, "SHGetFileInfoA('' | 0) should not clear dwAttributes\n");
 179
 180     if (pSHGetFileInfoW)
 181     {
 182         /* Test whether fields of SHFILEINFOW are always cleared */
 183         memset(&shfiw, 0xcf, sizeof(shfiw));
 184         rc=pSHGetFileInfoW(NULL, 0, &shfiw, sizeof(shfiw), 0);
 185         todo_wine ok(!rc, "SHGetFileInfoW(NULL | 0) should fail\n");
 186         ok(shfiw.hIcon == (HANDLE) 0xcfcfcfcf, "SHGetFileInfoW(NULL | 0) should not clear hIcon\n");
 187         todo_wine ok(shfiw.szDisplayName[0] == 0xcfcf, "SHGetFileInfoW(NULL | 0) should not clear szDisplayName[0]\n");
 188         todo_wine ok(shfiw.szTypeName[0] == 0xcfcf, "SHGetFileInfoW(NULL | 0) should not clear szTypeName[0]\n");
 189         todo_wine ok(shfiw.iIcon == 0xcfcfcfcf, "SHGetFileInfoW(NULL | 0) should not clear iIcon\n");
 190         ok(shfiw.dwAttributes == 0xcfcfcfcf, "SHGetFileInfoW(NULL | 0) should not clear dwAttributes\n");
 191     }
 192     else
 193         win_skip("SHGetFileInfoW is not available\n");
 194
 195
 196     /* Test some flag combinations that MSDN claims are not allowed,
 197      * but which work anyway
 198      */
 199     memset(&shfi, 0xcf, sizeof(shfi));
 200     rc=SHGetFileInfoA("c:\\nonexistent", FILE_ATTRIBUTE_DIRECTORY,
 201                       &shfi, sizeof(shfi),
 202                       SHGFI_ATTRIBUTES | SHGFI_USEFILEATTRIBUTES);
 203     ok(rc, "SHGetFileInfoA(c:\\nonexistent | SHGFI_ATTRIBUTES) failed\n");
 204     if (rc)
 205         ok(shfi.dwAttributes != 0xcfcfcfcf, "dwFileAttributes is not set\n");
 206     todo_wine ok(shfi.hIcon == 0, "SHGetFileInfoA(c:\\nonexistent | SHGFI_ATTRIBUTES) did not clear hIcon\n");
 207     todo_wine ok(shfi.szDisplayName[0] == 0, "SHGetFileInfoA(c:\\nonexistent | SHGFI_ATTRIBUTES) did not clear szDisplayName[0]\n");
 208     todo_wine ok(shfi.szTypeName[0] == 0, "SHGetFileInfoA(c:\\nonexistent | SHGFI_ATTRIBUTES) did not clear szTypeName[0]\n");
 209     ok(shfi.iIcon == 0xcfcfcfcf, "SHGetFileInfoA(c:\\nonexistent | SHGFI_ATTRIBUTES) should not clear iIcon\n");
 210
 211     rc=SHGetFileInfoA("c:\\nonexistent", FILE_ATTRIBUTE_DIRECTORY,
 212                       &shfi, sizeof(shfi),
 213                       SHGFI_EXETYPE | SHGFI_USEFILEATTRIBUTES);
 214     todo_wine ok(rc == 1, "SHGetFileInfoA(c:\\nonexistent | SHGFI_EXETYPE) returned %d\n", rc);
 215
 216     /* Test SHGFI_USEFILEATTRIBUTES support */
 217     strcpy(shfi.szDisplayName, "dummy");
 218     shfi.iIcon=0xdeadbeef;
 219     rc=SHGetFileInfoA("c:\\nonexistent", FILE_ATTRIBUTE_DIRECTORY,
 220                       &shfi, sizeof(shfi),
 221                       SHGFI_ICONLOCATION | SHGFI_USEFILEATTRIBUTES);
 222     ok(rc, "SHGetFileInfoA(c:\\nonexistent) failed\n");
 223     if (rc)
 224     {
 225         ok(strcpy(shfi.szDisplayName, "dummy") != 0, "SHGetFileInfoA(c:\\nonexistent) displayname is not set\n");
 226         ok(shfi.iIcon != 0xdeadbeef, "SHGetFileInfoA(c:\\nonexistent) iIcon is not set\n");
 227     }
 228
 229     /* Wine does not have a default icon for text files, and Windows 98 fails
 230      * if we give it an empty executable. So use notepad.exe as the test
 231      */
 232     if (SearchPath(NULL, "notepad.exe", NULL, sizeof(notepad), notepad, NULL))
 233     {
 234         strcpy(shfi.szDisplayName, "dummy");
 235         shfi.iIcon=0xdeadbeef;
 236         rc=SHGetFileInfoA(notepad, GetFileAttributes(notepad),
 237                           &shfi, sizeof(shfi),
 238                           SHGFI_ICONLOCATION | SHGFI_USEFILEATTRIBUTES);
 239         ok(rc, "SHGetFileInfoA(%s, SHGFI_USEFILEATTRIBUTES) failed\n", notepad);
 240         strcpy(shfi2.szDisplayName, "dummy");
 241         shfi2.iIcon=0xdeadbeef;
 242         rc2=SHGetFileInfoA(notepad, 0,
 243                            &shfi2, sizeof(shfi2),
 244                            SHGFI_ICONLOCATION);
 245         ok(rc2, "SHGetFileInfoA(%s) failed\n", notepad);
 246         if (rc && rc2)
 247         {
 248             ok(lstrcmpi(shfi2.szDisplayName, shfi.szDisplayName) == 0, "wrong display name %s != %s\n", shfi.szDisplayName, shfi2.szDisplayName);
 249             ok(shfi2.iIcon == shfi.iIcon, "wrong icon index %d != %d\n", shfi.iIcon, shfi2.iIcon);
 250         }
 251     }
 252
 253     /* with a directory now */
 254     strcpy(shfi.szDisplayName, "dummy");
 255     shfi.iIcon=0xdeadbeef;
 256     rc=SHGetFileInfoA("test4.txt", GetFileAttributes("test4.txt"),
 257                       &shfi, sizeof(shfi),
 258                       SHGFI_ICONLOCATION | SHGFI_USEFILEATTRIBUTES);
 259     ok(rc, "SHGetFileInfoA(test4.txt/, SHGFI_USEFILEATTRIBUTES) failed\n");
 260     strcpy(shfi2.szDisplayName, "dummy");
 261     shfi2.iIcon=0xdeadbeef;
 262     rc2=SHGetFileInfoA("test4.txt", 0,
 263                       &shfi2, sizeof(shfi2),
 264                       SHGFI_ICONLOCATION);
 265     ok(rc2, "SHGetFileInfoA(test4.txt/) failed\n");
 266     if (rc && rc2)
 267     {
 268         ok(lstrcmpi(shfi2.szDisplayName, shfi.szDisplayName) == 0, "wrong display name %s != %s\n", shfi.szDisplayName, shfi2.szDisplayName);
 269         ok(shfi2.iIcon == shfi.iIcon, "wrong icon index %d != %d\n", shfi.iIcon, shfi2.iIcon);
 270     }
 271 }
 272
 273 static void test_get_file_info_iconlist(void)
 274 {
 275     /* Test retrieving a handle to the system image list, and
 276      * what that returns for hIcon
 277      */
 278     HRESULT hr;
 279     HIMAGELIST hSysImageList;
 280     LPITEMIDLIST pidList;
 281     SHFILEINFOA shInfoa;
 282     SHFILEINFOW shInfow;
 283
 284     hr = SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidList);
 285     if (FAILED(hr)) {
 286          skip("can't get desktop pidl\n");
 287          return;
 288     }
 289
 290     memset(&shInfoa, 0xcf, sizeof(shInfoa));
 291     hSysImageList = (HIMAGELIST) SHGetFileInfoA((const char *)pidList, 0,
 292             &shInfoa, sizeof(shInfoa),
 293             SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_PIDL);
 294     ok(hSysImageList != INVALID_HANDLE_VALUE, "Can't get handle for CSIDL_DESKTOP imagelist\n");
 295     todo_wine ok(shInfoa.hIcon == 0, "SHGetFileInfoA(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) did not clear hIcon\n");
 296     todo_wine ok(shInfoa.szTypeName[0] == 0, "SHGetFileInfoA(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) did not clear szTypeName[0]\n");
 297     ok(shInfoa.iIcon != 0xcfcfcfcf, "SHGetFileInfoA(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) should set iIcon\n");
 298     ok(shInfoa.dwAttributes == 0xcfcfcfcf, "SHGetFileInfoA(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) should not change dwAttributes\n");
 299     CloseHandle(hSysImageList);
 300
 301     if (!pSHGetFileInfoW)
 302     {
 303         win_skip("SHGetFileInfoW is not available\n");
 304         ILFree(pidList);
 305         return;
 306     }
 307
 308     memset(&shInfow, 0xcf, sizeof(shInfow));
 309     hSysImageList = (HIMAGELIST) pSHGetFileInfoW((const WCHAR *)pidList, 0,
 310             &shInfow, sizeof(shInfow),
 311             SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_PIDL);
 312     if (!hSysImageList)
 313     {
 314         win_skip("SHGetFileInfoW is not implemented\n");
 315         return;
 316     }
 317     ok(hSysImageList != INVALID_HANDLE_VALUE, "Can't get handle for CSIDL_DESKTOP imagelist\n");
 318     todo_wine ok(shInfow.hIcon == 0, "SHGetFileInfoW(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) did not clear hIcon\n");
 319     ok(shInfow.szTypeName[0] == 0, "SHGetFileInfoW(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) did not clear szTypeName[0]\n");
 320     ok(shInfow.iIcon != 0xcfcfcfcf, "SHGetFileInfoW(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) should set iIcon\n");
 321     ok(shInfow.dwAttributes == 0xcfcfcfcf, "SHGetFileInfoW(CSIDL_DESKTOP, SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_PIDL) should not change dwAttributes\n");
 322     CloseHandle(hSysImageList);
 323
 324     /* Various suposidly invalid flag testing */
 325     memset(&shInfow, 0xcf, sizeof(shInfow));
 326     hr =  pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 327             SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON);
 328     ok(hr != 0, "SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON Failed\n");
 329     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 330     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 331
 332     memset(&shInfow, 0xcf, sizeof(shInfow));
 333     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 334             SHGFI_ICON|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON);
 335     ok(hr != 0, " SHGFI_ICON|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON Failed\n");
 336     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 337     ok(shInfow.hIcon!=(HICON)0xcfcfcfcf && shInfow.hIcon!=0,"hIcon invalid\n");
 338     if (shInfow.hIcon!=(HICON)0xcfcfcfcf) DestroyIcon(shInfow.hIcon);
 339     todo_wine ok(shInfow.dwAttributes==0,"dwAttributes not set\n");
 340
 341     memset(&shInfow, 0xcf, sizeof(shInfow));
 342     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 343             SHGFI_ICON|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_LARGEICON);
 344     ok(hr != 0, "SHGFI_ICON|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_LARGEICON Failed\n");
 345     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 346     ok(shInfow.hIcon!=(HICON)0xcfcfcfcf && shInfow.hIcon!=0,"hIcon invalid\n");
 347     if (shInfow.hIcon != (HICON)0xcfcfcfcf) DestroyIcon(shInfow.hIcon);
 348     todo_wine ok(shInfow.dwAttributes==0,"dwAttributes not set\n");
 349
 350     memset(&shInfow, 0xcf, sizeof(shInfow));
 351     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 352             SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_LARGEICON);
 353     ok(hr != 0, "SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_LARGEICON Failed\n");
 354     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 355     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 356
 357     memset(&shInfow, 0xcf, sizeof(shInfow));
 358     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 359             SHGFI_OPENICON|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON);
 360     ok(hr != 0, "SHGFI_OPENICON|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON Failed\n");
 361     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 362     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 363
 364     memset(&shInfow, 0xcf, sizeof(shInfow));
 365     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 366             SHGFI_SHELLICONSIZE|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON);
 367     ok(hr != 0, "SHGFI_SHELLICONSIZE|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON Failed\n");
 368     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 369     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 370
 371     memset(&shInfow, 0xcf, sizeof(shInfow));
 372     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 373             SHGFI_SHELLICONSIZE|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON);
 374     ok(hr != 0, "SHGFI_SHELLICONSIZE|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON Failed\n");
 375     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 376     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 377
 378     memset(&shInfow, 0xcf, sizeof(shInfow));
 379     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 380             SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|
 381         SHGFI_ATTRIBUTES);
 382     ok(hr != 0, "SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|SHGFI_ATTRIBUTES Failed\n");
 383     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 384     ok(shInfow.dwAttributes!=0xcfcfcfcf,"dwAttributes not set\n");
 385
 386     memset(&shInfow, 0xcf, sizeof(shInfow));
 387     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 388             SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|
 389         SHGFI_EXETYPE);
 390     todo_wine ok(hr != 0, "SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|SHGFI_EXETYPE Failed\n");
 391     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 392     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 393
 394     memset(&shInfow, 0xcf, sizeof(shInfow));
 395     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 396         SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|SHGFI_EXETYPE);
 397     todo_wine ok(hr != 0, "SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|SHGFI_EXETYPE Failed\n");
 398     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 399     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 400
 401     memset(&shInfow, 0xcf, sizeof(shInfow));
 402     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 403         SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|SHGFI_ATTRIBUTES);
 404     ok(hr != 0, "SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_SMALLICON|SHGFI_ATTRIBUTES Failed\n");
 405     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 406     ok(shInfow.dwAttributes!=0xcfcfcfcf,"dwAttributes not set\n");
 407
 408     memset(&shInfow, 0xcf, sizeof(shInfow));
 409     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 410             SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|
 411         SHGFI_ATTRIBUTES);
 412     ok(hr != 0, "SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_ATTRIBUTES Failed\n");
 413     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 414     ok(shInfow.dwAttributes!=0xcfcfcfcf,"dwAttributes not set\n");
 415
 416     memset(&shInfow, 0xcf, sizeof(shInfow));
 417     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 418         SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_EXETYPE);
 419     todo_wine ok(hr != 0, "SHGFI_SYSICONINDEX|SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_EXETYPE Failed\n");
 420     ok(shInfow.iIcon!=0xcfcfcfcf, "Icon Index Missing\n");
 421     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 422
 423     memset(&shInfow, 0xcf, sizeof(shInfow));
 424     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 425         SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_EXETYPE);
 426     todo_wine ok(hr != 0, "SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_EXETYPE Failed\n");
 427     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 428     ok(shInfow.dwAttributes==0xcfcfcfcf,"dwAttributes modified\n");
 429
 430     memset(&shInfow, 0xcf, sizeof(shInfow));
 431     hr = pSHGetFileInfoW((const WCHAR *)pidList, 0, &shInfow, sizeof(shInfow),
 432         SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_ATTRIBUTES);
 433     ok(hr != 0, "SHGFI_USEFILEATTRIBUTES|SHGFI_PIDL|SHGFI_ATTRIBUTES Failed\n");
 434     todo_wine ok(shInfow.iIcon==0xcfcfcfcf, "Icon Index Modified\n");
 435     ok(shInfow.dwAttributes!=0xcfcfcfcf,"dwAttributes not set\n");
 436
 437     ILFree(pidList);
 438 }
 439
 440
 441 /*
 442  puts into the specified buffer file names with current directory.
 443  files - string with file names, separated by null characters. Ends on a double
 444  null characters
 445 */
 446 static void set_curr_dir_path(CHAR *buf, const CHAR* files)
 447 {
 448     buf[0] = 0;
 449     while (files[0])
 450     {
 451         strcpy(buf, CURR_DIR);
 452         buf += strlen(buf);
 453         buf[0] = '\\';
 454         buf++;
 455         strcpy(buf, files);
 456         buf += strlen(buf) + 1;
 457         files += strlen(files) + 1;
 458     }
 459     buf[0] = 0;
 460 }
 461
 462
 463 /* tests the FO_DELETE action */
 464 static void test_delete(void)
 465 {
 466     SHFILEOPSTRUCTA shfo;
 467     DWORD ret;
 468     CHAR buf[sizeof(CURR_DIR)+sizeof("/test?.txt")+1];
 469
 470     sprintf(buf, "%s\\%s", CURR_DIR, "test?.txt");
 471     buf[strlen(buf) + 1] = '\0';
 472
 473     shfo.hwnd = NULL;
 474     shfo.wFunc = FO_DELETE;
 475     shfo.pFrom = buf;
 476     shfo.pTo = "\0";
 477     shfo.fFlags = FOF_FILESONLY | FOF_NOCONFIRMATION | FOF_SILENT;
 478     shfo.hNameMappings = NULL;
 479     shfo.lpszProgressTitle = NULL;
 480
 481     ok(!SHFileOperationA(&shfo), "Deletion was not successful\n");
 482     ok(file_exists("test4.txt"), "Directory should not have been removed\n");
 483     ok(!file_exists("test1.txt"), "File should have been removed\n");
 484
 485     ret = SHFileOperationA(&shfo);
 486     ok(!ret, "Directory exists, but is not removed, ret=%d\n", ret);
 487     ok(file_exists("test4.txt"), "Directory should not have been removed\n");
 488
 489     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
 490
 491     ok(!SHFileOperationA(&shfo), "Directory is not removed\n");
 492     ok(!file_exists("test4.txt"), "Directory should have been removed\n");
 493
 494     ret = SHFileOperationA(&shfo);
 495     ok(!ret, "The requested file does not exist, ret=%d\n", ret);
 496
 497     init_shfo_tests();
 498     sprintf(buf, "%s\\%s", CURR_DIR, "test4.txt");
 499     buf[strlen(buf) + 1] = '\0';
 500     ok(MoveFileA("test1.txt", "test4.txt\\test1.txt"), "Filling the subdirectory failed\n");
 501     ok(!SHFileOperationA(&shfo), "Directory is not removed\n");
 502     ok(!file_exists("test4.txt"), "Directory is not removed\n");
 503
 504     init_shfo_tests();
 505     shfo.pFrom = "test1.txt\0test4.txt\0";
 506     ok(!SHFileOperationA(&shfo), "Directory and a file are not removed\n");
 507     ok(!file_exists("test1.txt"), "The file should have been removed\n");
 508     ok(!file_exists("test4.txt"), "Directory should have been removed\n");
 509     ok(file_exists("test2.txt"), "This file should not have been removed\n");
 510
 511     /* FOF_FILESONLY does not delete a dir matching a wildcard */
 512     init_shfo_tests();
 513     shfo.fFlags |= FOF_FILESONLY;
 514     shfo.pFrom = "*.txt\0";
 515     ok(!SHFileOperation(&shfo), "Failed to delete files\n");
 516     ok(!file_exists("test1.txt"), "test1.txt should have been removed\n");
 517     ok(!file_exists("test_5.txt"), "test_5.txt should have been removed\n");
 518     ok(file_exists("test4.txt"), "test4.txt should not have been removed\n");
 519
 520     /* FOF_FILESONLY only deletes a dir if explicitly specified */
 521     init_shfo_tests();
 522     shfo.pFrom = "test_?.txt\0test4.txt\0";
 523     ok(!SHFileOperation(&shfo), "Failed to delete files and directory\n");
 524     ok(!file_exists("test4.txt"), "test4.txt should have been removed\n");
 525     ok(!file_exists("test_5.txt"), "test_5.txt should have been removed\n");
 526     ok(file_exists("test1.txt"), "test1.txt should not have been removed\n");
 527
 528     /* try to delete an invalid filename */
 529     if (0) {
 530         /* this crashes on win9x */
 531         init_shfo_tests();
 532         shfo.pFrom = "\0";
 533         shfo.fFlags &= ~FOF_FILESONLY;
 534         shfo.fAnyOperationsAborted = FALSE;
 535         ret = SHFileOperation(&shfo);
 536         ok(ret == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED, got %d\n", ret);
 537         ok(!shfo.fAnyOperationsAborted, "Expected no aborted operations\n");
 538         ok(file_exists("test1.txt"), "Expected test1.txt to exist\n");
 539     }
 540
 541     /* try an invalid function */
 542     init_shfo_tests();
 543     shfo.pFrom = "test1.txt\0";
 544     shfo.wFunc = 0;
 545     ret = SHFileOperation(&shfo);
 546     ok(ret == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", ret);
 547     ok(file_exists("test1.txt"), "Expected test1.txt to exist\n");
 548
 549     /* try an invalid list, only one null terminator */
 550     if (0) {
 551         /* this crashes on win9x */
 552         init_shfo_tests();
 553         shfo.pFrom = "";
 554         shfo.wFunc = FO_DELETE;
 555         ret = SHFileOperation(&shfo);
 556         ok(ret == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED, got %d\n", ret);
 557         ok(file_exists("test1.txt"), "Expected test1.txt to exist\n");
 558     }
 559
 560     /* delete a dir, and then a file inside the dir, same as
 561     * deleting a nonexistent file
 562     */
 563     init_shfo_tests();
 564     shfo.pFrom = "testdir2\0testdir2\\one.txt\0";
 565     shfo.wFunc = FO_DELETE;
 566     ret = SHFileOperation(&shfo);
 567     ok(ret == ERROR_PATH_NOT_FOUND, "Expected ERROR_PATH_NOT_FOUND, got %d\n", ret);
 568     ok(!file_exists("testdir2"), "Expected testdir2 to not exist\n");
 569     ok(!file_exists("testdir2\\one.txt"), "Expected testdir2\\one.txt to not exist\n");
 570
 571     /* try the FOF_NORECURSION flag, continues deleting subdirs */
 572     init_shfo_tests();
 573     shfo.pFrom = "testdir2\0";
 574     shfo.fFlags |= FOF_NORECURSION;
 575     ret = SHFileOperation(&shfo);
 576     ok(ret == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", ret);
 577     ok(!file_exists("testdir2\\one.txt"), "Expected testdir2\\one.txt to not exist\n");
 578     ok(!file_exists("testdir2\\nested"), "Expected testdir2\\nested to exist\n");
 579 }
 580
 581 /* tests the FO_RENAME action */
 582 static void test_rename(void)
 583 {
 584     SHFILEOPSTRUCTA shfo, shfo2;
 585     CHAR from[5*MAX_PATH];
 586     CHAR to[5*MAX_PATH];
 587     DWORD retval;
 588
 589     shfo.hwnd = NULL;
 590     shfo.wFunc = FO_RENAME;
 591     shfo.pFrom = from;
 592     shfo.pTo = to;
 593     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
 594     shfo.hNameMappings = NULL;
 595     shfo.lpszProgressTitle = NULL;
 596
 597     set_curr_dir_path(from, "test1.txt\0");
 598     set_curr_dir_path(to, "test4.txt\0");
 599     ok(SHFileOperationA(&shfo), "File is not renamed moving to other directory "
 600        "when specifying directory name only\n");
 601     ok(file_exists("test1.txt"), "The file is removed\n");
 602
 603     set_curr_dir_path(from, "test3.txt\0");
 604     set_curr_dir_path(to, "test4.txt\\test1.txt\0");
 605     ok(!SHFileOperationA(&shfo), "File is renamed moving to other directory\n");
 606     ok(file_exists("test4.txt\\test1.txt"), "The file is not renamed\n");
 607
 608     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
 609     set_curr_dir_path(to, "test6.txt\0test7.txt\0test8.txt\0");
 610     retval = SHFileOperationA(&shfo); /* W98 returns 0, W2K and newer returns ERROR_GEN_FAILURE, both do nothing */
 611     ok(!retval || retval == ERROR_GEN_FAILURE || retval == ERROR_INVALID_TARGET_HANDLE,
 612        "Can't rename many files, retval = %d\n", retval);
 613     ok(file_exists("test1.txt"), "The file is renamed - many files are specified\n");
 614
 615     memcpy(&shfo2, &shfo, sizeof(SHFILEOPSTRUCTA));
 616     shfo2.fFlags |= FOF_MULTIDESTFILES;
 617
 618     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
 619     set_curr_dir_path(to, "test6.txt\0test7.txt\0test8.txt\0");
 620     retval = SHFileOperationA(&shfo2); /* W98 returns 0, W2K and newer returns ERROR_GEN_FAILURE, both do nothing */
 621     ok(!retval || retval == ERROR_GEN_FAILURE || retval == ERROR_INVALID_TARGET_HANDLE,
 622        "Can't rename many files, retval = %d\n", retval);
 623     ok(file_exists("test1.txt"), "The file is not renamed - many files are specified\n");
 624
 625     set_curr_dir_path(from, "test1.txt\0");
 626     set_curr_dir_path(to, "test6.txt\0");
 627     retval = SHFileOperationA(&shfo);
 628     ok(!retval, "Rename file failed, retval = %d\n", retval);
 629     ok(!file_exists("test1.txt"), "The file is not renamed\n");
 630     ok(file_exists("test6.txt"), "The file is not renamed\n");
 631
 632     set_curr_dir_path(from, "test6.txt\0");
 633     set_curr_dir_path(to, "test1.txt\0");
 634     retval = SHFileOperationA(&shfo);
 635     ok(!retval, "Rename file back failed, retval = %d\n", retval);
 636
 637     set_curr_dir_path(from, "test4.txt\0");
 638     set_curr_dir_path(to, "test6.txt\0");
 639     retval = SHFileOperationA(&shfo);
 640     ok(!retval, "Rename dir failed, retval = %d\n", retval);
 641     ok(!file_exists("test4.txt"), "The dir is not renamed\n");
 642     ok(file_exists("test6.txt"), "The dir is not renamed\n");
 643
 644     set_curr_dir_path(from, "test6.txt\0");
 645     set_curr_dir_path(to, "test4.txt\0");
 646     retval = SHFileOperationA(&shfo);
 647     ok(!retval, "Rename dir back failed, retval = %d\n", retval);
 648
 649     /* try to rename more than one file to a single file */
 650     shfo.pFrom = "test1.txt\0test2.txt\0";
 651     shfo.pTo = "a.txt\0";
 652     retval = SHFileOperationA(&shfo);
 653     ok(retval == ERROR_GEN_FAILURE, "Expected ERROR_GEN_FAILURE, got %d\n", retval);
 654     ok(file_exists("test1.txt"), "Expected test1.txt to exist\n");
 655     ok(file_exists("test2.txt"), "Expected test2.txt to exist\n");
 656
 657     /* pFrom doesn't exist */
 658     shfo.pFrom = "idontexist\0";
 659     shfo.pTo = "newfile\0";
 660     retval = SHFileOperationA(&shfo);
 661     ok(retval == 1026, "Expected 1026, got %d\n", retval);
 662     ok(!file_exists("newfile"), "Expected newfile to not exist\n");
 663
 664     /* pTo already exist */
 665     shfo.pFrom = "test1.txt\0";
 666     shfo.pTo = "test2.txt\0";
 667     retval = SHFileOperationA(&shfo);
 668         ok(retval == ERROR_ALREADY_EXISTS, "Expected ERROR_ALREADY_EXISTS, got %d\n", retval);
 669
 670     /* pFrom is valid, but pTo is empty */
 671     shfo.pFrom = "test1.txt\0";
 672     shfo.pTo = "\0";
 673     retval = SHFileOperationA(&shfo);
 674     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x */);
 675     ok(file_exists("test1.txt"), "Expected test1.txt to exist\n");
 676
 677     /* pFrom is empty */
 678     shfo.pFrom = "\0";
 679     retval = SHFileOperationA(&shfo);
 680         ok(retval == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED, got %d\n", retval);
 681
 682     /* pFrom is NULL, commented out because it crashes on nt 4.0 */
 683 #if 0
 684     shfo.pFrom = NULL;
 685     retval = SHFileOperationA(&shfo);
 686     ok(retval == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", retval);
 687 #endif
 688 }
 689
 690 /* tests the FO_COPY action */
 691 static void test_copy(void)
 692 {
 693     SHFILEOPSTRUCTA shfo, shfo2;
 694     CHAR from[5*MAX_PATH];
 695     CHAR to[5*MAX_PATH];
 696     FILEOP_FLAGS tmp_flags;
 697     DWORD retval;
 698     LPSTR ptr;
 699
 700     shfo.hwnd = NULL;
 701     shfo.wFunc = FO_COPY;
 702     shfo.pFrom = from;
 703     shfo.pTo = to;
 704     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
 705     shfo.hNameMappings = NULL;
 706     shfo.lpszProgressTitle = NULL;
 707
 708     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
 709     set_curr_dir_path(to, "test6.txt\0test7.txt\0test8.txt\0");
 710     ok(SHFileOperationA(&shfo), "Can't copy many files\n");
 711     ok(!file_exists("test6.txt"), "The file is not copied - many files are "
 712        "specified as a target\n");
 713
 714     memcpy(&shfo2, &shfo, sizeof(SHFILEOPSTRUCTA));
 715     shfo2.fFlags |= FOF_MULTIDESTFILES;
 716
 717     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
 718     set_curr_dir_path(to, "test6.txt\0test7.txt\0test8.txt\0");
 719     ok(!SHFileOperationA(&shfo2), "Can't copy many files\n");
 720     ok(file_exists("test6.txt"), "The file is copied - many files are "
 721        "specified as a target\n");
 722     DeleteFileA("test6.txt");
 723     DeleteFileA("test7.txt");
 724     RemoveDirectoryA("test8.txt");
 725
 726     /* number of sources do not correspond to number of targets */
 727     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
 728     set_curr_dir_path(to, "test6.txt\0test7.txt\0");
 729     ok(SHFileOperationA(&shfo2), "Can't copy many files\n");
 730     ok(!file_exists("test6.txt"), "The file is not copied - many files are "
 731        "specified as a target\n");
 732
 733     set_curr_dir_path(from, "test1.txt\0");
 734     set_curr_dir_path(to, "test4.txt\0");
 735     ok(!SHFileOperationA(&shfo), "Prepare test to check how directories are copied recursively\n");
 736     ok(file_exists("test4.txt\\test1.txt"), "The file is copied\n");
 737
 738     set_curr_dir_path(from, "test?.txt\0");
 739     set_curr_dir_path(to, "testdir2\0");
 740     ok(!file_exists("testdir2\\test1.txt"), "The file is not copied yet\n");
 741     ok(!file_exists("testdir2\\test4.txt"), "The directory is not copied yet\n");
 742     ok(!SHFileOperationA(&shfo), "Files and directories are copied to directory\n");
 743     ok(file_exists("testdir2\\test1.txt"), "The file is copied\n");
 744     ok(file_exists("testdir2\\test4.txt"), "The directory is copied\n");
 745     ok(file_exists("testdir2\\test4.txt\\test1.txt"), "The file in subdirectory is copied\n");
 746     clean_after_shfo_tests();
 747
 748     init_shfo_tests();
 749     shfo.fFlags |= FOF_FILESONLY;
 750     ok(!file_exists("testdir2\\test1.txt"), "The file is not copied yet\n");
 751     ok(!file_exists("testdir2\\test4.txt"), "The directory is not copied yet\n");
 752     ok(!SHFileOperationA(&shfo), "Files are copied to other directory\n");
 753     ok(file_exists("testdir2\\test1.txt"), "The file is copied\n");
 754     ok(!file_exists("testdir2\\test4.txt"), "The directory is copied\n");
 755     clean_after_shfo_tests();
 756
 757     init_shfo_tests();
 758     set_curr_dir_path(from, "test1.txt\0test2.txt\0");
 759     ok(!file_exists("testdir2\\test1.txt"), "The file is not copied yet\n");
 760     ok(!file_exists("testdir2\\test2.txt"), "The file is not copied yet\n");
 761     ok(!SHFileOperationA(&shfo), "Files are copied to other directory\n");
 762     ok(file_exists("testdir2\\test1.txt"), "The file is copied\n");
 763     ok(file_exists("testdir2\\test2.txt"), "The file is copied\n");
 764     clean_after_shfo_tests();
 765
 766     /* Copying multiple files with one not existing as source, fails the
 767        entire operation in Win98/ME/2K/XP, but not in 95/NT */
 768     init_shfo_tests();
 769     tmp_flags = shfo.fFlags;
 770     set_curr_dir_path(from, "test1.txt\0test10.txt\0test2.txt\0");
 771     ok(!file_exists("testdir2\\test1.txt"), "The file is not copied yet\n");
 772     ok(!file_exists("testdir2\\test2.txt"), "The file is not copied yet\n");
 773     retval = SHFileOperationA(&shfo);
 774     if (!retval)
 775         /* Win 95/NT returns success but copies only the files up to the nonexistent source */
 776         ok(file_exists("testdir2\\test1.txt"), "The file is not copied\n");
 777     else
 778     {
 779         /* Win 98/ME/2K/XP fail the entire operation with return code 1026 if one source file does not exist */
 780         ok(retval == 1026, "Files are copied to other directory\n");
 781         ok(!file_exists("testdir2\\test1.txt"), "The file is copied\n");
 782     }
 783     ok(!file_exists("testdir2\\test2.txt"), "The file is copied\n");
 784     shfo.fFlags = tmp_flags;
 785
 786     /* copy into a nonexistent directory */
 787     init_shfo_tests();
 788     shfo.fFlags = FOF_NOCONFIRMMKDIR;
 789     set_curr_dir_path(from, "test1.txt\0");
 790     set_curr_dir_path(to, "nonexistent\\notreal\\test2.txt\0");
 791     retval= SHFileOperation(&shfo);
 792         ok(!retval, "Error copying into nonexistent directory\n");
 793         ok(file_exists("nonexistent"), "nonexistent not created\n");
 794         ok(file_exists("nonexistent\\notreal"), "nonexistent\\notreal not created\n");
 795         ok(file_exists("nonexistent\\notreal\\test2.txt"), "Directory not created\n");
 796     ok(!file_exists("nonexistent\\notreal\\test1.txt"), "test1.txt should not exist\n");
 797
 798     /* a relative dest directory is OK */
 799     clean_after_shfo_tests();
 800     init_shfo_tests();
 801     shfo.pFrom = "test1.txt\0test2.txt\0test3.txt\0";
 802     shfo.pTo = "testdir2\0";
 803     retval = SHFileOperation(&shfo);
 804     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 805     ok(file_exists("testdir2\\test1.txt"), "Expected testdir2\\test1 to exist\n");
 806
 807     /* try to copy files to a file */
 808     clean_after_shfo_tests();
 809     init_shfo_tests();
 810     shfo.pFrom = from;
 811     shfo.pTo = to;
 812     /* suppress the error-dialog in win9x here */
 813     shfo.fFlags |= FOF_NOERRORUI;
 814     set_curr_dir_path(from, "test1.txt\0test2.txt\0");
 815     set_curr_dir_path(to, "test3.txt\0");
 816     retval = SHFileOperation(&shfo);
 817     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 818     ok(shfo.fAnyOperationsAborted, "Expected aborted operations\n");
 819     ok(!file_exists("test3.txt\\test2.txt"), "Expected test3.txt\\test2.txt to not exist\n");
 820
 821     /* try to copy many files to nonexistent directory */
 822     DeleteFile(to);
 823     shfo.fFlags &= ~FOF_NOERRORUI;
 824     shfo.fAnyOperationsAborted = FALSE;
 825     retval = SHFileOperation(&shfo);
 826         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 827         ok(DeleteFile("test3.txt\\test1.txt"), "Expected test3.txt\\test1.txt to exist\n");
 828         ok(DeleteFile("test3.txt\\test2.txt"), "Expected test3.txt\\test1.txt to exist\n");
 829         ok(RemoveDirectory(to), "Expected test3.txt to exist\n");
 830
 831     /* send in FOF_MULTIDESTFILES with too many destination files */
 832     init_shfo_tests();
 833     shfo.pFrom = "test1.txt\0test2.txt\0test3.txt\0";
 834     shfo.pTo = "testdir2\\a.txt\0testdir2\\b.txt\0testdir2\\c.txt\0testdir2\\d.txt\0";
 835     shfo.fFlags |= FOF_NOERRORUI | FOF_MULTIDESTFILES;
 836     retval = SHFileOperation(&shfo);
 837     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 838     ok(shfo.fAnyOperationsAborted, "Expected aborted operations\n");
 839     ok(!file_exists("testdir2\\a.txt"), "Expected testdir2\\a.txt to not exist\n");
 840
 841     /* send in FOF_MULTIDESTFILES with too many destination files */
 842     shfo.pFrom = "test1.txt\0test2.txt\0test3.txt\0";
 843     shfo.pTo = "e.txt\0f.txt\0";
 844     shfo.fAnyOperationsAborted = FALSE;
 845     retval = SHFileOperation(&shfo);
 846     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 847     ok(shfo.fAnyOperationsAborted, "Expected aborted operations\n");
 848     ok(!file_exists("e.txt"), "Expected e.txt to not exist\n");
 849
 850     /* use FOF_MULTIDESTFILES with files and a source directory */
 851     shfo.pFrom = "test1.txt\0test2.txt\0test4.txt\0";
 852     shfo.pTo = "testdir2\\a.txt\0testdir2\\b.txt\0testdir2\\c.txt\0";
 853     shfo.fAnyOperationsAborted = FALSE;
 854     retval = SHFileOperation(&shfo);
 855     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 856     ok(DeleteFile("testdir2\\a.txt"), "Expected testdir2\\a.txt to exist\n");
 857     ok(DeleteFile("testdir2\\b.txt"), "Expected testdir2\\b.txt to exist\n");
 858     ok(RemoveDirectory("testdir2\\c.txt"), "Expected testdir2\\c.txt to exist\n");
 859
 860     /* try many dest files without FOF_MULTIDESTFILES flag */
 861     shfo.pFrom = "test1.txt\0test2.txt\0test3.txt\0";
 862     shfo.pTo = "a.txt\0b.txt\0c.txt\0";
 863     shfo.fAnyOperationsAborted = FALSE;
 864     shfo.fFlags &= ~FOF_MULTIDESTFILES;
 865     retval = SHFileOperation(&shfo);
 866     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 867     ok(!file_exists("a.txt"), "Expected a.txt to not exist\n");
 868
 869     /* try a glob */
 870     shfo.pFrom = "test?.txt\0";
 871     shfo.pTo = "testdir2\0";
 872     shfo.fFlags &= ~FOF_MULTIDESTFILES;
 873     retval = SHFileOperation(&shfo);
 874         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 875         ok(file_exists("testdir2\\test1.txt"), "Expected testdir2\\test1.txt to exist\n");
 876
 877     /* try a glob with FOF_FILESONLY */
 878     clean_after_shfo_tests();
 879     init_shfo_tests();
 880     shfo.pFrom = "test?.txt\0";
 881     shfo.fFlags |= FOF_FILESONLY;
 882     retval = SHFileOperation(&shfo);
 883         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 884         ok(file_exists("testdir2\\test1.txt"), "Expected testdir2\\test1.txt to exist\n");
 885     ok(!file_exists("testdir2\\test4.txt"), "Expected testdir2\\test4.txt to not exist\n");
 886
 887     /* try a glob with FOF_MULTIDESTFILES and the same number
 888     * of dest files that we would expect
 889     */
 890     clean_after_shfo_tests();
 891     init_shfo_tests();
 892     shfo.pTo = "testdir2\\a.txt\0testdir2\\b.txt\0testdir2\\c.txt\0testdir2\\d.txt\0";
 893     shfo.fFlags &= ~FOF_FILESONLY;
 894     shfo.fFlags |= FOF_MULTIDESTFILES;
 895     retval = SHFileOperation(&shfo);
 896     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 897     ok(shfo.fAnyOperationsAborted, "Expected aborted operations\n");
 898     ok(!file_exists("testdir2\\a.txt"), "Expected testdir2\\test1.txt to not exist\n");
 899     ok(!RemoveDirectory("b.txt"), "b.txt should not exist\n");
 900
 901     /* copy one file to two others, second is ignored */
 902     clean_after_shfo_tests();
 903     init_shfo_tests();
 904     shfo.pFrom = "test1.txt\0";
 905     shfo.pTo = "b.txt\0c.txt\0";
 906     shfo.fAnyOperationsAborted = FALSE;
 907     retval = SHFileOperation(&shfo);
 908         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 909         ok(DeleteFile("b.txt"), "Expected b.txt to exist\n");
 910     ok(!DeleteFile("c.txt"), "Expected c.txt to not exist\n");
 911
 912     /* copy two file to three others, all fail */
 913     shfo.pFrom = "test1.txt\0test2.txt\0";
 914     shfo.pTo = "b.txt\0c.txt\0d.txt\0";
 915     retval = SHFileOperation(&shfo);
 916     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 917     ok(shfo.fAnyOperationsAborted, "Expected operations to be aborted\n");
 918     ok(!DeleteFile("b.txt"), "Expected b.txt to not exist\n");
 919
 920     /* copy one file and one directory to three others */
 921     shfo.pFrom = "test1.txt\0test4.txt\0";
 922     shfo.pTo = "b.txt\0c.txt\0d.txt\0";
 923     shfo.fAnyOperationsAborted = FALSE;
 924     retval = SHFileOperation(&shfo);
 925     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 926     ok(shfo.fAnyOperationsAborted, "Expected operations to be aborted\n");
 927     ok(!DeleteFile("b.txt"), "Expected b.txt to not exist\n");
 928     ok(!DeleteFile("c.txt"), "Expected c.txt to not exist\n");
 929
 930     /* copy a directory with a file beneath it, plus some files */
 931     createTestFile("test4.txt\\a.txt");
 932     shfo.pFrom = "test4.txt\0test1.txt\0";
 933     shfo.pTo = "testdir2\0";
 934     shfo.fFlags &= ~FOF_MULTIDESTFILES;
 935     shfo.fAnyOperationsAborted = FALSE;
 936     retval = SHFileOperation(&shfo);
 937     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 938     ok(DeleteFile("testdir2\\test1.txt"), "Expected newdir\\test1.txt to exist\n");
 939     ok(DeleteFile("testdir2\\test4.txt\\a.txt"), "Expected a.txt to exist\n");
 940     ok(RemoveDirectory("testdir2\\test4.txt"), "Expected testdir2\\test4.txt to exist\n");
 941
 942     /* copy one directory and a file in that dir to another dir */
 943     shfo.pFrom = "test4.txt\0test4.txt\\a.txt\0";
 944     shfo.pTo = "testdir2\0";
 945     retval = SHFileOperation(&shfo);
 946     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 947     ok(DeleteFile("testdir2\\test4.txt\\a.txt"), "Expected a.txt to exist\n");
 948     ok(DeleteFile("testdir2\\a.txt"), "Expected testdir2\\a.txt to exist\n");
 949
 950     /* copy a file in a directory first, and then the directory to a nonexistent dir */
 951     shfo.pFrom = "test4.txt\\a.txt\0test4.txt\0";
 952     shfo.pTo = "nonexistent\0";
 953     retval = SHFileOperation(&shfo);
 954     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
 955     ok(shfo.fAnyOperationsAborted, "Expected operations to be aborted\n");
 956     ok(!file_exists("nonexistent\\test4.txt"), "Expected nonexistent\\test4.txt to not exist\n");
 957     DeleteFile("test4.txt\\a.txt");
 958
 959     /* destination is same as source file */
 960     shfo.pFrom = "test1.txt\0test2.txt\0test3.txt\0";
 961     shfo.pTo = "b.txt\0test2.txt\0c.txt\0";
 962     shfo.fAnyOperationsAborted = FALSE;
 963     shfo.fFlags = FOF_NOERRORUI | FOF_MULTIDESTFILES;
 964     retval = SHFileOperation(&shfo);
 965         ok(retval == ERROR_NO_MORE_SEARCH_HANDLES,
 966            "Expected ERROR_NO_MORE_SEARCH_HANDLES, got %d\n", retval);
 967         ok(!shfo.fAnyOperationsAborted, "Expected no operations to be aborted\n");
 968         ok(DeleteFile("b.txt"), "Expected b.txt to exist\n");
 969     ok(!file_exists("c.txt"), "Expected c.txt to not exist\n");
 970
 971     /* destination is same as source directory */
 972     shfo.pFrom = "test1.txt\0test4.txt\0test3.txt\0";
 973     shfo.pTo = "b.txt\0test4.txt\0c.txt\0";
 974     shfo.fAnyOperationsAborted = FALSE;
 975     retval = SHFileOperation(&shfo);
 976         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 977         ok(DeleteFile("b.txt"), "Expected b.txt to exist\n");
 978     ok(!file_exists("c.txt"), "Expected c.txt to not exist\n");
 979
 980     /* copy a directory into itself, error displayed in UI */
 981     shfo.pFrom = "test4.txt\0";
 982     shfo.pTo = "test4.txt\\newdir\0";
 983     shfo.fFlags &= ~FOF_MULTIDESTFILES;
 984     shfo.fAnyOperationsAborted = FALSE;
 985     retval = SHFileOperation(&shfo);
 986         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 987     ok(!RemoveDirectory("test4.txt\\newdir"), "Expected test4.txt\\newdir to not exist\n");
 988
 989     /* copy a directory to itself, error displayed in UI */
 990     shfo.pFrom = "test4.txt\0";
 991     shfo.pTo = "test4.txt\0";
 992     shfo.fAnyOperationsAborted = FALSE;
 993     retval = SHFileOperation(&shfo);
 994         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
 995
 996     /* copy a file into a directory, and the directory into itself */
 997     shfo.pFrom = "test1.txt\0test4.txt\0";
 998     shfo.pTo = "test4.txt\0";
 999     shfo.fAnyOperationsAborted = FALSE;
1000     shfo.fFlags |= FOF_NOCONFIRMATION;
1001     retval = SHFileOperation(&shfo);
1002         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1003     ok(DeleteFile("test4.txt\\test1.txt"), "Expected test4.txt\\test1.txt to exist\n");
1004
1005     /* copy a file to a file, and the directory into itself */
1006     shfo.pFrom = "test1.txt\0test4.txt\0";
1007     shfo.pTo = "test4.txt\\a.txt\0";
1008     shfo.fAnyOperationsAborted = FALSE;
1009     retval = SHFileOperation(&shfo);
1010     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1011     ok(!file_exists("test4.txt\\a.txt"), "Expected test4.txt\\a.txt to not exist\n");
1012
1013     /* copy a nonexistent file to a nonexistent directory */
1014     shfo.pFrom = "e.txt\0";
1015     shfo.pTo = "nonexistent\0";
1016     shfo.fAnyOperationsAborted = FALSE;
1017     retval = SHFileOperation(&shfo);
1018     ok(retval == 1026, "Expected 1026, got %d\n", retval);
1019     ok(!file_exists("nonexistent\\e.txt"), "Expected nonexistent\\e.txt to not exist\n");
1020     ok(!file_exists("nonexistent"), "Expected nonexistent to not exist\n");
1021
1022     /* Overwrite tests */
1023     clean_after_shfo_tests();
1024     init_shfo_tests();
1025     shfo.fFlags = FOF_NOCONFIRMATION;
1026     shfo.pFrom = "test1.txt\0";
1027     shfo.pTo = "test2.txt\0";
1028     shfo.fAnyOperationsAborted = FALSE;
1029     /* without FOF_NOCONFIRMATION the confirmation is Yes/No */
1030     retval = SHFileOperation(&shfo);
1031     ok(retval == 0, "Expected 0, got %d\n", retval);
1032     ok(file_has_content("test2.txt", "test1.txt\n"), "The file was not copied\n");
1033
1034     shfo.pFrom = "test3.txt\0test1.txt\0";
1035     shfo.pTo = "test2.txt\0one.txt\0";
1036     shfo.fFlags = FOF_NOCONFIRMATION | FOF_MULTIDESTFILES;
1037     /* without FOF_NOCONFIRMATION the confirmation is Yes/Yes to All/No/Cancel */
1038     retval = SHFileOperation(&shfo);
1039     ok(retval == 0, "Expected 0, got %d\n", retval);
1040     ok(file_has_content("test2.txt", "test3.txt\n"), "The file was not copied\n");
1041
1042     shfo.pFrom = "one.txt\0";
1043     shfo.pTo = "testdir2\0";
1044     shfo.fFlags = FOF_NOCONFIRMATION;
1045     /* without FOF_NOCONFIRMATION the confirmation is Yes/No */
1046     retval = SHFileOperation(&shfo);
1047     ok(retval == 0, "Expected 0, got %d\n", retval);
1048     ok(file_has_content("testdir2\\one.txt", "test1.txt\n"), "The file was not copied\n");
1049
1050     createTestFile("test4.txt\\test1.txt");
1051     shfo.pFrom = "test4.txt\0";
1052     shfo.pTo = "testdir2\0";
1053     shfo.fFlags = FOF_NOCONFIRMATION;
1054     ok(!SHFileOperation(&shfo), "First SHFileOperation failed\n");
1055     createTestFile("test4.txt\\.\\test1.txt"); /* modify the content of the file */
1056     /* without FOF_NOCONFIRMATION the confirmation is "This folder already contains a folder named ..." */
1057     retval = SHFileOperation(&shfo);
1058     ok(retval == 0, "Expected 0, got %d\n", retval);
1059     ok(file_has_content("testdir2\\test4.txt\\test1.txt", "test4.txt\\.\\test1.txt\n"), "The file was not copied\n");
1060
1061     createTestFile("one.txt");
1062
1063     /* pFrom contains bogus 2nd name longer than MAX_PATH */
1064     memset(from, 'a', MAX_PATH*2);
1065     memset(from+MAX_PATH*2, 0, 2);
1066     lstrcpyA(from, "one.txt");
1067     shfo.pFrom = from;
1068     shfo.pTo = "two.txt\0";
1069     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1070     retval = SHFileOperation(&shfo);
1071     ok(retval == 1148 || retval == 1026 ||
1072        retval == ERROR_ACCESS_DENIED, /* win2k */
1073        "Expected 1148, 1026 or ERROR_ACCESS_DENIED, got %d\n", retval);
1074     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1075     ok(!DeleteFileA("two.txt"), "Expected file to not exist\n");
1076
1077     createTestFile("one.txt");
1078
1079     /* pTo contains bogus 2nd name longer than MAX_PATH */
1080     memset(to, 'a', MAX_PATH*2);
1081     memset(to+MAX_PATH*2, 0, 2);
1082     lstrcpyA(to, "two.txt");
1083     shfo.pFrom = "one.txt\0";
1084     shfo.pTo = to;
1085     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1086     retval = SHFileOperation(&shfo);
1087     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1088     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1089     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1090
1091     createTestFile("one.txt");
1092
1093     /* no FOF_MULTIDESTFILES, two files in pTo */
1094     shfo.pFrom = "one.txt\0";
1095     shfo.pTo = "two.txt\0three.txt\0";
1096     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1097     retval = SHFileOperation(&shfo);
1098     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1099     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1100     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1101
1102     createTestFile("one.txt");
1103
1104     /* both pFrom and pTo contain bogus 2nd names longer than MAX_PATH */
1105     memset(from, 'a', MAX_PATH*2);
1106     memset(from+MAX_PATH*2, 0, 2);
1107     memset(to, 'a', MAX_PATH*2);
1108     memset(to+MAX_PATH*2, 0, 2);
1109     lstrcpyA(from, "one.txt");
1110     lstrcpyA(to, "two.txt");
1111     shfo.pFrom = from;
1112     shfo.pTo = to;
1113     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1114     retval = SHFileOperation(&shfo);
1115     ok(retval == 1148 || retval == 1026 ||
1116        retval == ERROR_ACCESS_DENIED, /* win2k */
1117        "Expected 1148, 1026 or ERROR_ACCESS_DENIED, got %d\n", retval);
1118     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1119     ok(!DeleteFileA("two.txt"), "Expected file to not exist\n");
1120
1121     createTestFile("one.txt");
1122
1123     /* pTo contains bogus 2nd name longer than MAX_PATH, FOF_MULTIDESTFILES */
1124     memset(to, 'a', MAX_PATH*2);
1125     memset(to+MAX_PATH*2, 0, 2);
1126     lstrcpyA(to, "two.txt");
1127     shfo.pFrom = "one.txt\0";
1128     shfo.pTo = to;
1129     shfo.fFlags = FOF_MULTIDESTFILES | FOF_NOCONFIRMATION |
1130                   FOF_SILENT | FOF_NOERRORUI;
1131     retval = SHFileOperation(&shfo);
1132     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1133     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1134     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1135
1136     createTestFile("one.txt");
1137     createTestFile("two.txt");
1138
1139     /* pTo contains bogus 2nd name longer than MAX_PATH,
1140      * multiple source files,
1141      * dest directory does not exist
1142      */
1143     memset(to, 'a', 2 * MAX_PATH);
1144     memset(to+MAX_PATH*2, 0, 2);
1145     lstrcpyA(to, "threedir");
1146     shfo.pFrom = "one.txt\0two.txt\0";
1147     shfo.pTo = to;
1148     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1149     retval = SHFileOperation(&shfo);
1150     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1151     ok(!DeleteFileA("threedir\\one.txt"), "Expected file to not exist\n");
1152     ok(!DeleteFileA("threedir\\two.txt"), "Expected file to not exist\n");
1153     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1154     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1155     ok(!DeleteFileA("threedir"), "Expected file to not exist\n");
1156     ok(!RemoveDirectoryA("threedir"), "Expected dir to not exist\n");
1157
1158     createTestFile("one.txt");
1159     createTestFile("two.txt");
1160     CreateDirectoryA("threedir", NULL);
1161
1162     /* pTo contains bogus 2nd name longer than MAX_PATH,
1163      * multiple source files,
1164      * dest directory does exist
1165      */
1166     memset(to, 'a', 2 * MAX_PATH);
1167     memset(to+MAX_PATH*2, 0, 2);
1168     lstrcpyA(to, "threedir");
1169     shfo.pFrom = "one.txt\0two.txt\0";
1170     shfo.pTo = to;
1171     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1172     retval = SHFileOperation(&shfo);
1173     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1174     ok(DeleteFileA("threedir\\one.txt"), "Expected file to exist\n");
1175     ok(DeleteFileA("threedir\\two.txt"), "Expected file to exist\n");
1176     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1177     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1178     ok(RemoveDirectoryA("threedir"), "Expected dir to exist\n");
1179
1180     if (0) {
1181         /* this crashes on win9x */
1182         createTestFile("one.txt");
1183         createTestFile("two.txt");
1184
1185         /* pTo contains bogus 2nd name longer than MAX_PATH,
1186          * multiple source files, FOF_MULTIDESTFILES
1187          * dest dir does not exist
1188          */
1189
1190         memset(to, 'a', 2 * MAX_PATH);
1191         memset(to+MAX_PATH*2, 0, 2);
1192         lstrcpyA(to, "threedir");
1193         shfo.pFrom = "one.txt\0two.txt\0";
1194         shfo.pTo = to;
1195         shfo.fFlags = FOF_MULTIDESTFILES | FOF_NOCONFIRMATION |
1196                       FOF_SILENT | FOF_NOERRORUI;
1197         retval = SHFileOperation(&shfo);
1198         ok(retval == ERROR_CANCELLED ||
1199            retval == ERROR_SUCCESS, /* win2k3 */
1200            "Expected ERROR_CANCELLED or ERROR_SUCCESS, got %d\n", retval);
1201         ok(!DeleteFileA("threedir\\one.txt"), "Expected file to not exist\n");
1202         ok(!DeleteFileA("threedir\\two.txt"), "Expected file to not exist\n");
1203         ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1204         ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1205         ok(!RemoveDirectoryA("threedir"), "Expected dir to not exist\n");
1206
1207         /* file exists in win2k */
1208         DeleteFileA("threedir");
1209     }
1210
1211
1212     createTestFile("one.txt");
1213     createTestFile("two.txt");
1214     CreateDirectoryA("threedir", NULL);
1215
1216     /* pTo contains bogus 2nd name longer than MAX_PATH,
1217      * multiple source files, FOF_MULTIDESTFILES
1218      * dest dir does exist
1219      */
1220     memset(to, 'a', 2 * MAX_PATH);
1221     memset(to+MAX_PATH*2, 0, 2);
1222     lstrcpyA(to, "threedir");
1223     ptr = to + lstrlenA(to) + 1;
1224     lstrcpyA(ptr, "fourdir");
1225     shfo.pFrom = "one.txt\0two.txt\0";
1226     shfo.pTo = to;
1227     shfo.fFlags = FOF_MULTIDESTFILES | FOF_NOCONFIRMATION |
1228                   FOF_SILENT | FOF_NOERRORUI;
1229     retval = SHFileOperation(&shfo);
1230     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1231     ok(DeleteFileA("threedir\\one.txt"), "Expected file to exist\n");
1232     ok(DeleteFileA("threedir\\two.txt"), "Expected file to exist\n");
1233     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1234     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1235     ok(RemoveDirectoryA("threedir"), "Expected dir to exist\n");
1236     ok(!DeleteFileA("fourdir"), "Expected file to not exist\n");
1237     ok(!RemoveDirectoryA("fourdir"), "Expected dir to not exist\n");
1238
1239     createTestFile("one.txt");
1240     createTestFile("two.txt");
1241     CreateDirectoryA("threedir", NULL);
1242
1243     /* multiple source files, FOF_MULTIDESTFILES
1244      * multiple dest files, but first dest dir exists
1245      * num files in lists is equal
1246      */
1247     shfo.pFrom = "one.txt\0two.txt\0";
1248     shfo.pTo = "threedir\0fourdir\0";
1249     shfo.fFlags = FOF_MULTIDESTFILES | FOF_NOCONFIRMATION |
1250                   FOF_SILENT | FOF_NOERRORUI;
1251     retval = SHFileOperation(&shfo);
1252     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1253     ok(!DeleteFileA("threedir\\one.txt"), "Expected file to not exist\n");
1254     ok(!DeleteFileA("threedir\\two.txt"), "Expected file to not exist\n");
1255     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1256     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1257     ok(RemoveDirectoryA("threedir"), "Expected dir to exist\n");
1258     ok(!DeleteFileA("fourdir"), "Expected file to not exist\n");
1259     ok(!RemoveDirectoryA("fourdir"), "Expected dit to not exist\n");
1260
1261     createTestFile("one.txt");
1262     createTestFile("two.txt");
1263     CreateDirectoryA("threedir", NULL);
1264
1265     /* multiple source files, FOF_MULTIDESTFILES
1266      * multiple dest files, but first dest dir exists
1267      * num files in lists is not equal
1268      */
1269     shfo.pFrom = "one.txt\0two.txt\0";
1270     shfo.pTo = "threedir\0fourdir\0five\0";
1271     shfo.fFlags = FOF_MULTIDESTFILES | FOF_NOCONFIRMATION |
1272                   FOF_SILENT | FOF_NOERRORUI;
1273     retval = SHFileOperation(&shfo);
1274     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1275     ok(DeleteFileA("threedir\\one.txt"), "Expected file to exist\n");
1276     ok(DeleteFileA("threedir\\two.txt"), "Expected file to exist\n");
1277     ok(DeleteFileA("one.txt"), "Expected file to exist\n");
1278     ok(DeleteFileA("two.txt"), "Expected file to exist\n");
1279     ok(RemoveDirectoryA("threedir"), "Expected dir to exist\n");
1280     ok(!DeleteFileA("fourdir"), "Expected file to not exist\n");
1281     ok(!RemoveDirectoryA("fourdir"), "Expected dit to not exist\n");
1282     ok(!DeleteFileA("five"), "Expected file to not exist\n");
1283     ok(!RemoveDirectoryA("five"), "Expected dit to not exist\n");
1284
1285     createTestFile("aa.txt");
1286     createTestFile("ab.txt");
1287     CreateDirectoryA("one", NULL);
1288     CreateDirectoryA("two", NULL);
1289
1290     /* pFrom has a glob, pTo has more than one dest */
1291     shfo.pFrom = "a*.txt\0";
1292     shfo.pTo = "one\0two\0";
1293     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1294     retval = SHFileOperation(&shfo);
1295     ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1296     ok(DeleteFileA("one\\aa.txt"), "Expected file to exist\n");
1297     ok(DeleteFileA("one\\ab.txt"), "Expected file to exist\n");
1298     ok(!DeleteFileA("two\\aa.txt"), "Expected file to not exist\n");
1299     ok(!DeleteFileA("two\\ab.txt"), "Expected file to not exist\n");
1300     ok(DeleteFileA("aa.txt"), "Expected file to exist\n");
1301     ok(DeleteFileA("ab.txt"), "Expected file to exist\n");
1302     ok(RemoveDirectoryA("one"), "Expected dir to exist\n");
1303     ok(RemoveDirectoryA("two"), "Expected dir to exist\n");
1304 }
1305
1306 /* tests the FO_MOVE action */
1307 static void test_move(void)
1308 {
1309     SHFILEOPSTRUCTA shfo, shfo2;
1310     CHAR from[5*MAX_PATH];
1311     CHAR to[5*MAX_PATH];
1312     DWORD retval;
1313
1314     shfo.hwnd = NULL;
1315     shfo.wFunc = FO_MOVE;
1316     shfo.pFrom = from;
1317     shfo.pTo = to;
1318     shfo.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1319     shfo.hNameMappings = NULL;
1320     shfo.lpszProgressTitle = NULL;
1321
1322     set_curr_dir_path(from, "test1.txt\0");
1323     set_curr_dir_path(to, "test4.txt\0");
1324     ok(!SHFileOperationA(&shfo), "Prepare test to check how directories are moved recursively\n");
1325     ok(!file_exists("test1.txt"), "test1.txt should not exist\n");
1326     ok(file_exists("test4.txt\\test1.txt"), "The file is not moved\n");
1327
1328     set_curr_dir_path(from, "test?.txt\0");
1329     set_curr_dir_path(to, "testdir2\0");
1330     ok(!file_exists("testdir2\\test2.txt"), "The file is not moved yet\n");
1331     ok(!file_exists("testdir2\\test4.txt"), "The directory is not moved yet\n");
1332     ok(!SHFileOperationA(&shfo), "Files and directories are moved to directory\n");
1333     ok(file_exists("testdir2\\test2.txt"), "The file is moved\n");
1334     ok(file_exists("testdir2\\test4.txt"), "The directory is moved\n");
1335     ok(file_exists("testdir2\\test4.txt\\test1.txt"), "The file in subdirectory is moved\n");
1336
1337     clean_after_shfo_tests();
1338     init_shfo_tests();
1339
1340     memcpy(&shfo2, &shfo, sizeof(SHFILEOPSTRUCTA));
1341     shfo2.fFlags |= FOF_MULTIDESTFILES;
1342
1343     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
1344     set_curr_dir_path(to, "test6.txt\0test7.txt\0test8.txt\0");
1345     ok(!SHFileOperationA(&shfo2), "Move many files\n");
1346     ok(file_exists("test6.txt"), "The file is moved - many files are "
1347        "specified as a target\n");
1348     DeleteFileA("test6.txt");
1349     DeleteFileA("test7.txt");
1350     RemoveDirectoryA("test8.txt");
1351
1352     init_shfo_tests();
1353
1354     /* number of sources do not correspond to number of targets */
1355     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
1356     set_curr_dir_path(to, "test6.txt\0test7.txt\0");
1357     ok(SHFileOperationA(&shfo2), "Can't move many files\n");
1358     ok(!file_exists("test6.txt"), "The file is not moved - many files are "
1359        "specified as a target\n");
1360
1361     init_shfo_tests();
1362
1363     set_curr_dir_path(from, "test3.txt\0");
1364     set_curr_dir_path(to, "test4.txt\\test1.txt\0");
1365     ok(!SHFileOperationA(&shfo), "File is moved moving to other directory\n");
1366     ok(file_exists("test4.txt\\test1.txt"), "The file is moved\n");
1367
1368     set_curr_dir_path(from, "test1.txt\0test2.txt\0test4.txt\0");
1369     set_curr_dir_path(to, "test6.txt\0test7.txt\0test8.txt\0");
1370     ok(SHFileOperationA(&shfo), "Cannot move many files\n");
1371     ok(file_exists("test1.txt"), "The file is not moved. Many files are specified\n");
1372     ok(file_exists("test4.txt"), "The directory is not moved. Many files are specified\n");
1373
1374     set_curr_dir_path(from, "test1.txt\0");
1375     set_curr_dir_path(to, "test6.txt\0");
1376     ok(!SHFileOperationA(&shfo), "Move file\n");
1377     ok(!file_exists("test1.txt"), "The file is moved\n");
1378     ok(file_exists("test6.txt"), "The file is moved\n");
1379     set_curr_dir_path(from, "test6.txt\0");
1380     set_curr_dir_path(to, "test1.txt\0");
1381     ok(!SHFileOperationA(&shfo), "Move file back\n");
1382
1383     set_curr_dir_path(from, "test4.txt\0");
1384     set_curr_dir_path(to, "test6.txt\0");
1385     ok(!SHFileOperationA(&shfo), "Move dir\n");
1386     ok(!file_exists("test4.txt"), "The dir is moved\n");
1387     ok(file_exists("test6.txt"), "The dir is moved\n");
1388     set_curr_dir_path(from, "test6.txt\0");
1389     set_curr_dir_path(to, "test4.txt\0");
1390     ok(!SHFileOperationA(&shfo), "Move dir back\n");
1391
1392     /* move one file to two others */
1393     init_shfo_tests();
1394     shfo.pFrom = "test1.txt\0";
1395     shfo.pTo = "a.txt\0b.txt\0";
1396     retval = SHFileOperationA(&shfo);
1397         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1398         ok(!file_exists("test1.txt"), "Expected test1.txt to not exist\n");
1399         ok(DeleteFile("a.txt"), "Expected a.txt to exist\n");
1400     ok(!file_exists("b.txt"), "Expected b.txt to not exist\n");
1401
1402     /* move two files to one other */
1403     shfo.pFrom = "test2.txt\0test3.txt\0";
1404     shfo.pTo = "test1.txt\0";
1405     retval = SHFileOperationA(&shfo);
1406     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1407     ok(!file_exists("test1.txt"), "Expected test1.txt to not exist\n");
1408     ok(file_exists("test2.txt"), "Expected test2.txt to exist\n");
1409     ok(file_exists("test3.txt"), "Expected test3.txt to exist\n");
1410
1411     /* move a directory into itself */
1412     shfo.pFrom = "test4.txt\0";
1413     shfo.pTo = "test4.txt\\b.txt\0";
1414     retval = SHFileOperationA(&shfo);
1415         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1416     ok(!RemoveDirectory("test4.txt\\b.txt"), "Expected test4.txt\\b.txt to not exist\n");
1417     ok(file_exists("test4.txt"), "Expected test4.txt to exist\n");
1418
1419     /* move many files without FOF_MULTIDESTFILES */
1420     shfo.pFrom = "test2.txt\0test3.txt\0";
1421     shfo.pTo = "d.txt\0e.txt\0";
1422     retval = SHFileOperationA(&shfo);
1423     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1424     ok(!DeleteFile("d.txt"), "Expected d.txt to not exist\n");
1425     ok(!DeleteFile("e.txt"), "Expected e.txt to not exist\n");
1426
1427     /* number of sources != number of targets */
1428     shfo.pTo = "d.txt\0";
1429     shfo.fFlags |= FOF_MULTIDESTFILES;
1430     retval = SHFileOperationA(&shfo);
1431     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1432     ok(!DeleteFile("d.txt"), "Expected d.txt to not exist\n");
1433
1434     /* FO_MOVE does not create dest directories */
1435     shfo.pFrom = "test2.txt\0";
1436     shfo.pTo = "dir1\\dir2\\test2.txt\0";
1437     retval = SHFileOperationA(&shfo);
1438     expect_retval(ERROR_CANCELLED, DE_OPCANCELLED /* Win9x, NT4 */);
1439     ok(!file_exists("dir1"), "Expected dir1 to not exist\n");
1440
1441     /* try to overwrite an existing file */
1442     shfo.pTo = "test3.txt\0";
1443     retval = SHFileOperationA(&shfo);
1444         ok(retval == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", retval);
1445         ok(!file_exists("test2.txt"), "Expected test2.txt to not exist\n");
1446     ok(file_exists("test3.txt"), "Expected test3.txt to exist\n");
1447 }
1448
1449 static void test_sh_create_dir(void)
1450 {
1451     CHAR path[MAX_PATH];
1452     int ret;
1453
1454     if(!pSHCreateDirectoryExA)
1455     {
1456         win_skip("skipping SHCreateDirectoryExA tests\n");
1457         return;
1458     }
1459
1460     set_curr_dir_path(path, "testdir2\\test4.txt\0");
1461     ret = pSHCreateDirectoryExA(NULL, path, NULL);
1462     ok(ERROR_SUCCESS == ret, "SHCreateDirectoryEx failed to create directory recursively, ret = %d\n", ret);
1463     ok(file_exists("testdir2"), "The first directory is not created\n");
1464     ok(file_exists("testdir2\\test4.txt"), "The second directory is not created\n");
1465
1466     ret = pSHCreateDirectoryExA(NULL, path, NULL);
1467     ok(ERROR_ALREADY_EXISTS == ret, "SHCreateDirectoryEx should fail to create existing directory, ret = %d\n", ret);
1468
1469     ret = pSHCreateDirectoryExA(NULL, "c:\\testdir3", NULL);
1470     ok(file_exists("c:\\testdir3"), "The directory is not created\n");
1471 }
1472
1473 static void test_sh_path_prepare(void)
1474 {
1475     HRESULT res;
1476     CHAR path[MAX_PATH];
1477
1478     if(!pSHPathPrepareForWriteA)
1479     {
1480         win_skip("skipping SHPathPrepareForWriteA tests\n");
1481         return;
1482     }
1483
1484     /* directory exists, SHPPFW_NONE */
1485     set_curr_dir_path(path, "testdir2\0");
1486     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_NONE);
1487     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1488
1489     /* directory exists, SHPPFW_IGNOREFILENAME */
1490     set_curr_dir_path(path, "testdir2\\test4.txt\0");
1491     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_IGNOREFILENAME);
1492     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1493
1494     /* directory exists, SHPPFW_DIRCREATE */
1495     set_curr_dir_path(path, "testdir2\0");
1496     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_DIRCREATE);
1497     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1498
1499     /* directory exists, SHPPFW_IGNOREFILENAME|SHPPFW_DIRCREATE */
1500     set_curr_dir_path(path, "testdir2\\test4.txt\0");
1501     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_IGNOREFILENAME|SHPPFW_DIRCREATE);
1502     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1503     ok(!file_exists("nonexistent\\"), "nonexistent\\ exists but shouldn't\n");
1504
1505     /* file exists, SHPPFW_NONE */
1506     set_curr_dir_path(path, "test1.txt\0");
1507     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_NONE);
1508     ok(res == HRESULT_FROM_WIN32(ERROR_DIRECTORY), "res == 0x%08x, expected HRESULT_FROM_WIN32(ERROR_DIRECTORY)\n", res);
1509
1510     /* file exists, SHPPFW_DIRCREATE */
1511     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_DIRCREATE);
1512     ok(res == HRESULT_FROM_WIN32(ERROR_DIRECTORY), "res == 0x%08x, expected HRESULT_FROM_WIN32(ERROR_DIRECTORY)\n", res);
1513
1514     /* file exists, SHPPFW_NONE, trailing \ */
1515     set_curr_dir_path(path, "test1.txt\\\0");
1516     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_NONE);
1517     ok(res == HRESULT_FROM_WIN32(ERROR_DIRECTORY), "res == 0x%08x, expected HRESULT_FROM_WIN32(ERROR_DIRECTORY)\n", res);
1518
1519     /* relative path exists, SHPPFW_DIRCREATE */
1520     res = pSHPathPrepareForWriteA(0, 0, ".\\testdir2", SHPPFW_DIRCREATE);
1521     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1522
1523     /* relative path doesn't exist, SHPPFW_DIRCREATE -- Windows does not create the directory in this case */
1524     res = pSHPathPrepareForWriteA(0, 0, ".\\testdir2\\test4.txt", SHPPFW_DIRCREATE);
1525     ok(res == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "res == 0x%08x, expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)\n", res);
1526     ok(!file_exists(".\\testdir2\\test4.txt\\"), ".\\testdir2\\test4.txt\\ exists but shouldn't\n");
1527
1528     /* directory doesn't exist, SHPPFW_NONE */
1529     set_curr_dir_path(path, "nonexistent\0");
1530     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_NONE);
1531     ok(res == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "res == 0x%08x, expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)\n", res);
1532
1533     /* directory doesn't exist, SHPPFW_IGNOREFILENAME */
1534     set_curr_dir_path(path, "nonexistent\\notreal\0");
1535     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_IGNOREFILENAME);
1536     ok(res == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "res == 0x%08x, expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)\n", res);
1537     ok(!file_exists("nonexistent\\notreal"), "nonexistent\\notreal exists but shouldn't\n");
1538     ok(!file_exists("nonexistent\\"), "nonexistent\\ exists but shouldn't\n");
1539
1540     /* directory doesn't exist, SHPPFW_IGNOREFILENAME|SHPPFW_DIRCREATE */
1541     set_curr_dir_path(path, "testdir2\\test4.txt\\\0");
1542     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_IGNOREFILENAME|SHPPFW_DIRCREATE);
1543     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1544     ok(file_exists("testdir2\\test4.txt\\"), "testdir2\\test4.txt doesn't exist but should\n");
1545
1546     /* nested directory doesn't exist, SHPPFW_DIRCREATE */
1547     set_curr_dir_path(path, "nonexistent\\notreal\0");
1548     res = pSHPathPrepareForWriteA(0, 0, path, SHPPFW_DIRCREATE);
1549     ok(res == S_OK, "res == 0x%08x, expected S_OK\n", res);
1550     ok(file_exists("nonexistent\\notreal"), "nonexistent\\notreal doesn't exist but should\n");
1551
1552     /* SHPPFW_ASKDIRCREATE, SHPPFW_NOWRITECHECK, and SHPPFW_MEDIACHECKONLY are untested */
1553
1554     if(!pSHPathPrepareForWriteW)
1555     {
1556         skip("Skipping SHPathPrepareForWriteW tests\n");
1557         return;
1558     }
1559     /* unicode directory doesn't exist, SHPPFW_NONE */
1560     res = pSHPathPrepareForWriteW(0, 0, UNICODE_PATH, SHPPFW_NONE);
1561     ok(res == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "res == %08x, expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)\n", res);
1562     ok(!file_existsW(UNICODE_PATH), "unicode path was created but shouldn't be\n");
1563     RemoveDirectoryW(UNICODE_PATH);
1564
1565     /* unicode directory doesn't exist, SHPPFW_DIRCREATE */
1566     res = pSHPathPrepareForWriteW(0, 0, UNICODE_PATH, SHPPFW_DIRCREATE);
1567     ok(res == S_OK, "res == %08x, expected S_OK\n", res);
1568     ok(file_existsW(UNICODE_PATH), "unicode path should've been created\n");
1569
1570     /* unicode directory exists, SHPPFW_NONE */
1571     res = pSHPathPrepareForWriteW(0, 0, UNICODE_PATH, SHPPFW_NONE);
1572     ok(res == S_OK, "ret == %08x, expected S_OK\n", res);
1573
1574     /* unicode directory exists, SHPPFW_DIRCREATE */
1575     res = pSHPathPrepareForWriteW(0, 0, UNICODE_PATH, SHPPFW_DIRCREATE);
1576     ok(res == S_OK, "ret == %08x, expected S_OK\n", res);
1577     RemoveDirectoryW(UNICODE_PATH);
1578 }
1579
1580 static void test_unicode(void)
1581 {
1582     SHFILEOPSTRUCTW shfoW;
1583     int ret;
1584     HANDLE file;
1585
1586     if (!pSHFileOperationW)
1587     {
1588         skip("SHFileOperationW() is missing\n");
1589         return;
1590     }
1591
1592     shfoW.hwnd = NULL;
1593     shfoW.wFunc = FO_DELETE;
1594     shfoW.pFrom = UNICODE_PATH;
1595     shfoW.pTo = '\0';
1596     shfoW.fFlags = FOF_NOCONFIRMATION | FOF_SILENT | FOF_NOERRORUI;
1597     shfoW.hNameMappings = NULL;
1598     shfoW.lpszProgressTitle = NULL;
1599
1600     /* Clean up before start test */
1601     DeleteFileW(UNICODE_PATH);
1602     RemoveDirectoryW(UNICODE_PATH);
1603
1604     /* Make sure we are on a system that supports unicode */
1605     SetLastError(0xdeadbeef);
1606     file = CreateFileW(UNICODE_PATH, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1607     if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
1608     {
1609         skip("Unicode tests skipped on non-unicode system\n");
1610         return;
1611     }
1612     CloseHandle(file);
1613
1614     /* Try to delete a file with unicode filename */
1615     ok(file_existsW(UNICODE_PATH), "The file does not exist\n");
1616     ret = pSHFileOperationW(&shfoW);
1617     ok(!ret, "File is not removed, ErrorCode: %d\n", ret);
1618     ok(!file_existsW(UNICODE_PATH), "The file should have been removed\n");
1619
1620     /* Try to trash a file with unicode filename */
1621     createTestFileW(UNICODE_PATH);
1622     shfoW.fFlags |= FOF_ALLOWUNDO;
1623     ok(file_existsW(UNICODE_PATH), "The file does not exist\n");
1624     ret = pSHFileOperationW(&shfoW);
1625     ok(!ret, "File is not removed, ErrorCode: %d\n", ret);
1626     ok(!file_existsW(UNICODE_PATH), "The file should have been removed\n");
1627
1628     if(!pSHCreateDirectoryExW)
1629     {
1630         skip("Skipping SHCreateDirectoryExW tests\n");
1631         return;
1632     }
1633
1634     /* Try to delete a directory with unicode filename */
1635     ret = pSHCreateDirectoryExW(NULL, UNICODE_PATH, NULL);
1636     ok(!ret, "SHCreateDirectoryExW returned %d\n", ret);
1637     ok(file_existsW(UNICODE_PATH), "The directory is not created\n");
1638     shfoW.fFlags &= ~FOF_ALLOWUNDO;
1639     ret = pSHFileOperationW(&shfoW);
1640     ok(!ret, "Directory is not removed, ErrorCode: %d\n", ret);
1641     ok(!file_existsW(UNICODE_PATH), "The directory should have been removed\n");
1642
1643     /* Try to trash a directory with unicode filename */
1644     ret = pSHCreateDirectoryExW(NULL, UNICODE_PATH, NULL);
1645     ok(!ret, "SHCreateDirectoryExW returned %d\n", ret);
1646     ok(file_existsW(UNICODE_PATH), "The directory was not created\n");
1647     shfoW.fFlags |= FOF_ALLOWUNDO;
1648     ret = pSHFileOperationW(&shfoW);
1649     ok(!ret, "Directory is not removed, ErrorCode: %d\n", ret);
1650     ok(!file_existsW(UNICODE_PATH), "The directory should have been removed\n");
1651 }
1652
1653 START_TEST(shlfileop)
1654 {
1655     InitFunctionPointers();
1656
1657     clean_after_shfo_tests();
1658
1659     init_shfo_tests();
1660     test_get_file_info();
1661     test_get_file_info_iconlist();
1662     clean_after_shfo_tests();
1663
1664     init_shfo_tests();
1665     test_delete();
1666     clean_after_shfo_tests();
1667
1668     init_shfo_tests();
1669     test_rename();
1670     clean_after_shfo_tests();
1671
1672     init_shfo_tests();
1673     test_copy();
1674     clean_after_shfo_tests();
1675
1676     init_shfo_tests();
1677     test_move();
1678     clean_after_shfo_tests();
1679
1680     test_sh_create_dir();
1681     clean_after_shfo_tests();
1682
1683     init_shfo_tests();
1684     test_sh_path_prepare();
1685     clean_after_shfo_tests();
1686
1687     test_unicode();
1688 }