dlls/kernel32/tests/change.c

   1 /*
   2  * Tests for file change notification functions
   3  *
   4  * Copyright (c) 2004 Hans Leidekker
   5  * Copyright 2006 Mike McCormack for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /* TODO: - security attribute changes
  23  *       - compound filter and multiple notifications
  24  *       - subtree notifications
  25  *       - non-documented flags FILE_NOTIFY_CHANGE_LAST_ACCESS and
  26  *         FILE_NOTIFY_CHANGE_CREATION
  27  */
  28
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "wine/test.h"
  35 #include <windef.h>
  36 #include <winbase.h>
  37 #include <winternl.h>
  38
  39 static DWORD CALLBACK NotificationThread(LPVOID arg)
  40 {
  41     HANDLE change = arg;
  42     BOOL notified = FALSE;
  43     BOOL ret = FALSE;
  44     DWORD status;
  45
  46     status = WaitForSingleObject(change, 100);
  47
  48     if (status == WAIT_OBJECT_0 ) {
  49         notified = TRUE;
  50         FindNextChangeNotification(change);
  51     }
  52
  53     ret = FindCloseChangeNotification(change);
  54     ok( ret, "FindCloseChangeNotification error: %d\n",
  55        GetLastError());
  56
  57     ExitThread((DWORD)notified);
  58 }
  59
  60 static HANDLE StartNotificationThread(LPCSTR path, BOOL subtree, DWORD flags)
  61 {
  62     HANDLE change, thread;
  63     DWORD threadId;
  64
  65     change = FindFirstChangeNotificationA(path, subtree, flags);
  66     ok(change != INVALID_HANDLE_VALUE, "FindFirstChangeNotification error: %d\n", GetLastError());
  67
  68     thread = CreateThread(NULL, 0, NotificationThread, change, 0, &threadId);
  69     ok(thread != NULL, "CreateThread error: %d\n", GetLastError());
  70
  71     return thread;
  72 }
  73
  74 static DWORD FinishNotificationThread(HANDLE thread)
  75 {
  76     DWORD status, exitcode;
  77
  78     status = WaitForSingleObject(thread, 5000);
  79     ok(status == WAIT_OBJECT_0, "WaitForSingleObject status %d error %d\n", status, GetLastError());
  80
  81     ok(GetExitCodeThread(thread, &exitcode), "Could not retrieve thread exit code\n");
  82     CloseHandle(thread);
  83
  84     return exitcode;
  85 }
  86
  87 static void test_FindFirstChangeNotification(void)
  88 {
  89     HANDLE change, file, thread;
  90     DWORD attributes, count;
  91     BOOL ret;
  92
  93     char workdir[MAX_PATH], dirname1[MAX_PATH], dirname2[MAX_PATH];
  94     char filename1[MAX_PATH], filename2[MAX_PATH];
  95     static const char prefix[] = "FCN";
  96     char buffer[2048];
  97
  98     /* pathetic checks */
  99
 100     change = FindFirstChangeNotificationA("not-a-file", FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 101     ok(change == INVALID_HANDLE_VALUE, "Expected INVALID_HANDLE_VALUE, got %p\n", change);
 102     ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
 103        GetLastError() == ERROR_NO_MORE_FILES, /* win95 */
 104        "FindFirstChangeNotification error: %d\n", GetLastError());
 105
 106     if (0) /* This documents win2k behavior. It crashes on win98. */
 107     {
 108         change = FindFirstChangeNotificationA(NULL, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 109         ok(change == NULL && GetLastError() == ERROR_PATH_NOT_FOUND,
 110         "FindFirstChangeNotification error: %d\n", GetLastError());
 111     }
 112
 113     ret = FindNextChangeNotification(NULL);
 114     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindNextChangeNotification error: %d\n",
 115        GetLastError());
 116
 117     ret = FindCloseChangeNotification(NULL);
 118     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindCloseChangeNotification error: %d\n",
 119        GetLastError());
 120
 121     ret = GetTempPathA(MAX_PATH, dirname1);
 122     ok(ret, "GetTempPathA error: %d\n", GetLastError());
 123
 124     ret = GetTempFileNameA(dirname1, "ffc", 0, workdir);
 125     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
 126     DeleteFileA( workdir );
 127
 128     ret = CreateDirectoryA(workdir, NULL);
 129     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 130
 131     ret = GetTempFileNameA(workdir, prefix, 0, filename1);
 132     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
 133
 134     file = CreateFileA(filename1, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS,
 135                        FILE_ATTRIBUTE_NORMAL, 0);
 136     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 137     ret = CloseHandle(file);
 138     ok( ret, "CloseHandle error: %d\n", GetLastError());
 139
 140     /* Try to register notification for a file. win98 and win2k behave differently here */
 141     change = FindFirstChangeNotificationA(filename1, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 142     ok(change == INVALID_HANDLE_VALUE && (GetLastError() == ERROR_DIRECTORY ||
 143                                           GetLastError() == ERROR_FILE_NOT_FOUND),
 144        "FindFirstChangeNotification error: %d\n", GetLastError());
 145
 146     lstrcpyA(dirname1, filename1);
 147     lstrcatA(dirname1, "dir");
 148
 149     lstrcpyA(dirname2, dirname1);
 150     lstrcatA(dirname2, "new");
 151
 152     ret = CreateDirectoryA(dirname1, NULL);
 153     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 154
 155     /* What if we move the directory we registered notification for? */
 156     thread = StartNotificationThread(dirname1, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 157     ret = MoveFileA(dirname1, dirname2);
 158     ok(ret, "MoveFileA error: %d\n", GetLastError());
 159     /* win9x and win2k behave differently here, don't check result */
 160     FinishNotificationThread(thread);
 161
 162     /* What if we remove the directory we registered notification for? */
 163     thread = StartNotificationThread(dirname2, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 164     ret = RemoveDirectoryA(dirname2);
 165     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 166     /* win9x and win2k behave differently here, don't check result */
 167     FinishNotificationThread(thread);
 168
 169     /* functional checks */
 170
 171     /* Create a directory */
 172     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 173     ret = CreateDirectoryA(dirname1, NULL);
 174     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 175     ok(FinishNotificationThread(thread), "Missed notification\n");
 176
 177     /* Rename a directory */
 178     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 179     ret = MoveFileA(dirname1, dirname2);
 180     ok(ret, "MoveFileA error: %d\n", GetLastError());
 181     ok(FinishNotificationThread(thread), "Missed notification\n");
 182
 183     /* Delete a directory */
 184     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 185     ret = RemoveDirectoryA(dirname2);
 186     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 187     ok(FinishNotificationThread(thread), "Missed notification\n");
 188
 189     lstrcpyA(filename2, filename1);
 190     lstrcatA(filename2, "new");
 191
 192     /* Rename a file */
 193     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 194     ret = MoveFileA(filename1, filename2);
 195     ok(ret, "MoveFileA error: %d\n", GetLastError());
 196     ok(FinishNotificationThread(thread), "Missed notification\n");
 197
 198     /* Delete a file */
 199     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 200     ret = DeleteFileA(filename2);
 201     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 202     ok(FinishNotificationThread(thread), "Missed notification\n");
 203
 204     /* Create a file */
 205     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 206     file = CreateFileA(filename2, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS,
 207                        FILE_ATTRIBUTE_NORMAL, 0);
 208     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 209     ret = CloseHandle(file);
 210     ok( ret, "CloseHandle error: %d\n", GetLastError());
 211     ok(FinishNotificationThread(thread), "Missed notification\n");
 212
 213     attributes = GetFileAttributesA(filename2);
 214     ok(attributes != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA error: %d\n", GetLastError());
 215     attributes &= FILE_ATTRIBUTE_READONLY;
 216
 217     /* Change file attributes */
 218     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_ATTRIBUTES);
 219     ret = SetFileAttributesA(filename2, attributes);
 220     ok(ret, "SetFileAttributesA error: %d\n", GetLastError());
 221     ok(FinishNotificationThread(thread), "Missed notification\n");
 222
 223     /* Change last write time by writing to a file */
 224     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE);
 225     file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 226                        FILE_ATTRIBUTE_NORMAL, 0);
 227     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 228     memset(buffer, 0, sizeof(buffer));
 229     ret = WriteFile(file, buffer, sizeof(buffer), &count, NULL);
 230     ok(ret && count == sizeof(buffer), "WriteFile error: %d\n", GetLastError());
 231     ret = CloseHandle(file);
 232     ok( ret, "CloseHandle error: %d\n", GetLastError());
 233     ok(FinishNotificationThread(thread), "Missed notification\n");
 234
 235     /* Change file size by truncating a file */
 236     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_SIZE);
 237     file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 238                        FILE_ATTRIBUTE_NORMAL, 0);
 239     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 240     ret = WriteFile(file, buffer, sizeof(buffer) / 2, &count, NULL);
 241     ok(ret && count == sizeof(buffer) / 2, "WriteFileA error: %d\n", GetLastError());
 242     ret = CloseHandle(file);
 243     ok( ret, "CloseHandle error: %d\n", GetLastError());
 244     ok(FinishNotificationThread(thread), "Missed notification\n");
 245
 246     /* clean up */
 247
 248     ret = DeleteFileA(filename2);
 249     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 250
 251     ret = RemoveDirectoryA(workdir);
 252     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 253 }
 254
 255 /* this test concentrates more on the wait behaviour of the handle */
 256 static void test_ffcn(void)
 257 {
 258     DWORD filter;
 259     HANDLE handle, file;
 260     LONG r;
 261     WCHAR path[MAX_PATH], subdir[MAX_PATH], filename[MAX_PATH];
 262     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 263     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 264     static const WCHAR szZoo[] = { '\\','z','o','o',0 };
 265
 266     SetLastError(0xdeadbeef);
 267     r = GetTempPathW( MAX_PATH, path );
 268     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 269     {
 270         win_skip("GetTempPathW is not implemented\n");
 271         return;
 272     }
 273     ok( r != 0, "temp path failed\n");
 274     if (!r)
 275         return;
 276
 277     lstrcatW( path, szBoo );
 278     lstrcpyW( subdir, path );
 279     lstrcatW( subdir, szHoo );
 280
 281     lstrcpyW( filename, path );
 282     lstrcatW( filename, szZoo );
 283
 284     RemoveDirectoryW( subdir );
 285     RemoveDirectoryW( path );
 286
 287     r = CreateDirectoryW(path, NULL);
 288     ok( r == TRUE, "failed to create directory\n");
 289
 290     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 291     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 292
 293     handle = FindFirstChangeNotificationW( path, 1, filter);
 294     ok( handle != INVALID_HANDLE_VALUE, "invalid handle\n");
 295
 296     r = WaitForSingleObject( handle, 0 );
 297     ok( r == STATUS_TIMEOUT, "should time out\n");
 298
 299     file = CreateFileW( filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
 300                         CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0 );
 301     ok( file != INVALID_HANDLE_VALUE, "CreateFile error %u\n", GetLastError() );
 302     CloseHandle(file);
 303
 304     r = WaitForSingleObject( handle, 0 );
 305     ok( r == WAIT_OBJECT_0, "should be ready\n");
 306
 307     r = WaitForSingleObject( handle, 0 );
 308     ok( r == WAIT_OBJECT_0, "should be ready\n");
 309
 310     r = FindNextChangeNotification(handle);
 311     ok( r == TRUE, "find next failed\n");
 312
 313     r = WaitForSingleObject( handle, 0 );
 314     ok( r == STATUS_TIMEOUT, "should time out\n");
 315
 316     r = DeleteFileW( filename );
 317     ok( r == TRUE, "failed to remove file\n");
 318
 319     r = WaitForSingleObject( handle, 0 );
 320     ok( r == WAIT_OBJECT_0, "should be ready\n");
 321
 322     r = WaitForSingleObject( handle, 0 );
 323     ok( r == WAIT_OBJECT_0, "should be ready\n");
 324
 325     r = FindNextChangeNotification(handle);
 326     ok( r == TRUE, "find next failed\n");
 327
 328     r = WaitForSingleObject( handle, 0 );
 329     ok( r == STATUS_TIMEOUT, "should time out\n");
 330
 331     r = CreateDirectoryW( subdir, NULL );
 332     ok( r == TRUE, "failed to create subdir\n");
 333
 334     r = WaitForSingleObject( handle, 0 );
 335     ok( r == WAIT_OBJECT_0, "should be ready\n");
 336
 337     r = WaitForSingleObject( handle, 0 );
 338     ok( r == WAIT_OBJECT_0, "should be ready\n");
 339
 340     r = FindNextChangeNotification(handle);
 341     ok( r == TRUE, "find next failed\n");
 342
 343     r = WaitForSingleObject( handle, 0 );
 344     ok( r == STATUS_TIMEOUT, "should time out\n");
 345
 346     r = RemoveDirectoryW( subdir );
 347     ok( r == TRUE, "failed to remove subdir\n");
 348
 349     r = WaitForSingleObject( handle, 0 );
 350     ok( r == WAIT_OBJECT_0, "should be ready\n");
 351
 352     r = WaitForSingleObject( handle, 0 );
 353     ok( r == WAIT_OBJECT_0, "should be ready\n");
 354
 355     r = FindNextChangeNotification(handle);
 356     ok( r == TRUE, "find next failed\n");
 357
 358     r = FindNextChangeNotification(handle);
 359     ok( r == TRUE, "find next failed\n");
 360
 361     r = FindCloseChangeNotification(handle);
 362     ok( r == TRUE, "should succeed\n");
 363
 364     r = RemoveDirectoryW( path );
 365     ok( r == TRUE, "failed to remove dir\n");
 366 }
 367
 368 /* this test concentrates on the wait behavior when multiple threads are
 369  * waiting on a change notification handle. */
 370 static void test_ffcnMultipleThreads(void)
 371 {
 372     LONG r;
 373     DWORD filter, threadId, status, exitcode;
 374     HANDLE handles[2];
 375     char tmp[MAX_PATH], path[MAX_PATH];
 376
 377     r = GetTempPathA(MAX_PATH, tmp);
 378     ok(r, "GetTempPathA error: %d\n", GetLastError());
 379
 380     r = GetTempFileNameA(tmp, "ffc", 0, path);
 381     ok(r, "GetTempFileNameA error: %d\n", GetLastError());
 382     DeleteFileA( path );
 383
 384     r = CreateDirectoryA(path, NULL);
 385     ok(r, "CreateDirectoryA error: %d\n", GetLastError());
 386
 387     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 388     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 389
 390     handles[0] = FindFirstChangeNotificationA(path, FALSE, filter);
 391     ok(handles[0] != INVALID_HANDLE_VALUE, "FindFirstChangeNotification error: %d\n", GetLastError());
 392
 393     /* Test behavior if a waiting thread holds the last reference to a change
 394      * directory object with an empty wine user APC queue for this thread (bug #7286) */
 395
 396     /* Create our notification thread */
 397     handles[1] = CreateThread(NULL, 0, NotificationThread, handles[0], 0,
 398                               &threadId);
 399     ok(handles[1] != NULL, "CreateThread error: %d\n", GetLastError());
 400
 401     status = WaitForMultipleObjects(2, handles, FALSE, 5000);
 402     ok(status == WAIT_OBJECT_0 || status == WAIT_OBJECT_0+1, "WaitForMultipleObjects status %d error %d\n", status, GetLastError());
 403     ok(GetExitCodeThread(handles[1], &exitcode), "Could not retrieve thread exit code\n");
 404
 405     /* Clean up */
 406     r = RemoveDirectoryA( path );
 407     ok( r == TRUE, "failed to remove dir\n");
 408 }
 409
 410 static BOOL (WINAPI *pReadDirectoryChangesW)(HANDLE,LPVOID,DWORD,BOOL,DWORD,
 411                          LPDWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
 412
 413 static void test_readdirectorychanges(void)
 414 {
 415     HANDLE hdir;
 416     char buffer[0x1000];
 417     DWORD fflags, filter = 0, r, dwCount;
 418     OVERLAPPED ov;
 419     WCHAR path[MAX_PATH], subdir[MAX_PATH], subsubdir[MAX_PATH];
 420     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 421     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 422     static const WCHAR szGa[] = { '\\','h','o','o','\\','g','a',0 };
 423     PFILE_NOTIFY_INFORMATION pfni;
 424     BOOL got_subdir_change = FALSE;
 425
 426     if (!pReadDirectoryChangesW)
 427     {
 428         win_skip("ReadDirectoryChangesW is not available\n");
 429         return;
 430     }
 431
 432     SetLastError(0xdeadbeef);
 433     r = GetTempPathW( MAX_PATH, path );
 434     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 435     {
 436         win_skip("GetTempPathW is not implemented\n");
 437         return;
 438     }
 439     ok( r != 0, "temp path failed\n");
 440     if (!r)
 441         return;
 442
 443     lstrcatW( path, szBoo );
 444     lstrcpyW( subdir, path );
 445     lstrcatW( subdir, szHoo );
 446
 447     lstrcpyW( subsubdir, path );
 448     lstrcatW( subsubdir, szGa );
 449
 450     RemoveDirectoryW( subsubdir );
 451     RemoveDirectoryW( subdir );
 452     RemoveDirectoryW( path );
 453
 454     r = CreateDirectoryW(path, NULL);
 455     ok( r == TRUE, "failed to create directory\n");
 456
 457     SetLastError(0xd0b00b00);
 458     r = pReadDirectoryChangesW(NULL,NULL,0,FALSE,0,NULL,NULL,NULL);
 459     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 460     ok(r==FALSE, "should return false\n");
 461
 462     fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
 463     hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
 464                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 465                         OPEN_EXISTING, fflags, NULL);
 466     ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 467
 468     ov.hEvent = CreateEventW( NULL, 1, 0, NULL );
 469
 470     SetLastError(0xd0b00b00);
 471     r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,0,NULL,NULL,NULL);
 472     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 473     ok(r==FALSE, "should return false\n");
 474
 475     SetLastError(0xd0b00b00);
 476     r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,0,NULL,&ov,NULL);
 477     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 478     ok(r==FALSE, "should return false\n");
 479
 480     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 481     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 482     filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
 483     filter |= FILE_NOTIFY_CHANGE_SIZE;
 484     filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
 485     filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
 486     filter |= FILE_NOTIFY_CHANGE_CREATION;
 487     filter |= FILE_NOTIFY_CHANGE_SECURITY;
 488
 489     SetLastError(0xd0b00b00);
 490     ov.Internal = 0;
 491     ov.InternalHigh = 0;
 492     memset( buffer, 0, sizeof buffer );
 493
 494     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,-1,NULL,&ov,NULL);
 495     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 496     ok(r==FALSE, "should return false\n");
 497
 498     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,&ov,NULL);
 499     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 500     ok(r==FALSE, "should return false\n");
 501
 502     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,TRUE,filter,NULL,&ov,NULL);
 503     ok(r==TRUE, "should return true\n");
 504
 505     r = WaitForSingleObject( ov.hEvent, 10 );
 506     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 507
 508     r = CreateDirectoryW( subdir, NULL );
 509     ok( r == TRUE, "failed to create directory\n");
 510
 511     r = WaitForSingleObject( ov.hEvent, 1000 );
 512     ok( r == WAIT_OBJECT_0, "event should be ready\n" );
 513
 514     ok( (NTSTATUS)ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 515     ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
 516
 517     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 518     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 519     ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
 520     ok( pfni->FileNameLength == 6, "len wrong\n" );
 521     ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
 522
 523     ResetEvent(ov.hEvent);
 524     SetLastError(0xd0b00b00);
 525     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,NULL,NULL);
 526     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 527     ok(r==FALSE, "should return false\n");
 528
 529     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,&ov,NULL);
 530     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 531     ok(r==FALSE, "should return false\n");
 532
 533     filter = FILE_NOTIFY_CHANGE_SIZE;
 534
 535     SetEvent(ov.hEvent);
 536     ov.Internal = 1;
 537     ov.InternalHigh = 1;
 538     S(U(ov)).Offset = 0;
 539     S(U(ov)).OffsetHigh = 0;
 540     memset( buffer, 0, sizeof buffer );
 541     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 542     ok(r==TRUE, "should return true\n");
 543
 544     ok( (NTSTATUS)ov.Internal == STATUS_PENDING, "ov.Internal wrong\n");
 545     ok( ov.InternalHigh == 1, "ov.InternalHigh wrong\n");
 546
 547     r = WaitForSingleObject( ov.hEvent, 0 );
 548     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 549
 550     r = RemoveDirectoryW( subdir );
 551     ok( r == TRUE, "failed to remove directory\n");
 552
 553     r = WaitForSingleObject( ov.hEvent, 1000 );
 554     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 555
 556     ok( (NTSTATUS)ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 557     ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
 558
 559     if ((NTSTATUS)ov.Internal == STATUS_SUCCESS)
 560     {
 561         r = GetOverlappedResult( hdir, &ov, &dwCount, TRUE );
 562         ok( r == TRUE, "getoverlappedresult failed\n");
 563         ok( dwCount == 0x12, "count wrong\n");
 564     }
 565
 566     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 567     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 568     ok( pfni->Action == FILE_ACTION_REMOVED, "action wrong\n" );
 569     ok( pfni->FileNameLength == 6, "len wrong\n" );
 570     ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
 571
 572     /* what happens if the buffer is too small? */
 573     r = pReadDirectoryChangesW(hdir,buffer,0x10,FALSE,filter,NULL,&ov,NULL);
 574     ok(r==TRUE, "should return true\n");
 575
 576     r = CreateDirectoryW( subdir, NULL );
 577     ok( r == TRUE, "failed to create directory\n");
 578
 579     r = WaitForSingleObject( ov.hEvent, 1000 );
 580     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 581
 582     ok( (NTSTATUS)ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
 583     ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
 584
 585     /* test the recursive watch */
 586     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 587     ok(r==TRUE, "should return true\n");
 588
 589     r = CreateDirectoryW( subsubdir, NULL );
 590     ok( r == TRUE, "failed to create directory\n");
 591
 592     while (1)
 593     {
 594         r = WaitForSingleObject( ov.hEvent, 1000 );
 595         ok(r == WAIT_OBJECT_0, "should be ready\n" );
 596         if (r == WAIT_TIMEOUT) break;
 597
 598         ok((NTSTATUS) ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 599
 600         pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 601         while (1)
 602         {
 603             /* We might get one or more modified events on the parent dir */
 604             if (pfni->Action == FILE_ACTION_MODIFIED)
 605             {
 606                 ok(pfni->FileNameLength == 3 * sizeof(WCHAR), "len wrong\n" );
 607                 ok(!memcmp(pfni->FileName, &szGa[1], 3 * sizeof(WCHAR)), "name wrong\n");
 608             }
 609             else
 610             {
 611                 ok(pfni->Action == FILE_ACTION_ADDED, "action wrong\n");
 612                 ok(pfni->FileNameLength == 6 * sizeof(WCHAR), "len wrong\n" );
 613                 ok(!memcmp(pfni->FileName, &szGa[1], 6 * sizeof(WCHAR)), "name wrong\n");
 614                 got_subdir_change = TRUE;
 615             }
 616             if (!pfni->NextEntryOffset) break;
 617             pfni = (PFILE_NOTIFY_INFORMATION)((char *)pfni + pfni->NextEntryOffset);
 618         }
 619
 620         if (got_subdir_change) break;
 621
 622         r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 623         ok(r==TRUE, "should return true\n");
 624     }
 625     ok(got_subdir_change, "didn't get subdir change\n");
 626
 627     r = RemoveDirectoryW( subsubdir );
 628     ok( r == TRUE, "failed to remove directory\n");
 629
 630     ov.Internal = 1;
 631     ov.InternalHigh = 1;
 632     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 633     ok(r==TRUE, "should return true\n");
 634
 635     r = RemoveDirectoryW( subdir );
 636     ok( r == TRUE, "failed to remove directory\n");
 637
 638     r = WaitForSingleObject( ov.hEvent, 1000 );
 639     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 640
 641     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 642     /* we may get a notification for the parent dir too */
 643     if (pfni->Action == FILE_ACTION_MODIFIED && pfni->NextEntryOffset)
 644     {
 645         ok( pfni->FileNameLength == 3*sizeof(WCHAR), "len wrong %u\n", pfni->FileNameLength );
 646         ok( !memcmp(pfni->FileName,&szGa[1],3*sizeof(WCHAR)), "name wrong\n" );
 647         pfni = (PFILE_NOTIFY_INFORMATION)((char *)pfni + pfni->NextEntryOffset);
 648     }
 649     ok( pfni->NextEntryOffset == 0, "offset wrong %u\n", pfni->NextEntryOffset );
 650     ok( pfni->Action == FILE_ACTION_REMOVED, "action wrong %u\n", pfni->Action );
 651     ok( pfni->FileNameLength == 6*sizeof(WCHAR), "len wrong %u\n", pfni->FileNameLength );
 652     ok( !memcmp(pfni->FileName,&szGa[1],6*sizeof(WCHAR)), "name wrong\n" );
 653
 654     ok( (NTSTATUS)ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 655     dwCount = (char *)&pfni->FileName[pfni->FileNameLength/sizeof(WCHAR)] - buffer;
 656     ok( ov.InternalHigh == dwCount, "ov.InternalHigh wrong %lu/%u\n",ov.InternalHigh, dwCount );
 657
 658     CloseHandle(hdir);
 659
 660     r = RemoveDirectoryW( path );
 661     ok( r == TRUE, "failed to remove directory\n");
 662 }
 663
 664 /* show the behaviour when a null buffer is passed */
 665 static void test_readdirectorychanges_null(void)
 666 {
 667     NTSTATUS r;
 668     HANDLE hdir;
 669     char buffer[0x1000];
 670     DWORD fflags, filter = 0;
 671     OVERLAPPED ov;
 672     WCHAR path[MAX_PATH], subdir[MAX_PATH];
 673     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 674     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 675     PFILE_NOTIFY_INFORMATION pfni;
 676
 677     if (!pReadDirectoryChangesW)
 678     {
 679         win_skip("ReadDirectoryChangesW is not available\n");
 680         return;
 681     }
 682     SetLastError(0xdeadbeef);
 683     r = GetTempPathW( MAX_PATH, path );
 684     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 685     {
 686         win_skip("GetTempPathW is not implemented\n");
 687         return;
 688     }
 689     ok( r != 0, "temp path failed\n");
 690     if (!r)
 691         return;
 692
 693     lstrcatW( path, szBoo );
 694     lstrcpyW( subdir, path );
 695     lstrcatW( subdir, szHoo );
 696
 697     RemoveDirectoryW( subdir );
 698     RemoveDirectoryW( path );
 699
 700     r = CreateDirectoryW(path, NULL);
 701     ok( r == TRUE, "failed to create directory\n");
 702
 703     fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
 704     hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
 705                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 706                         OPEN_EXISTING, fflags, NULL);
 707     ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 708
 709     ov.hEvent = CreateEventW( NULL, 1, 0, NULL );
 710
 711     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 712     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 713
 714     SetLastError(0xd0b00b00);
 715     ov.Internal = 0;
 716     ov.InternalHigh = 0;
 717     memset( buffer, 0, sizeof buffer );
 718
 719     r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,filter,NULL,&ov,NULL);
 720     ok(r==TRUE, "should return true\n");
 721
 722     r = WaitForSingleObject( ov.hEvent, 0 );
 723     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 724
 725     r = CreateDirectoryW( subdir, NULL );
 726     ok( r == TRUE, "failed to create directory\n");
 727
 728     r = WaitForSingleObject( ov.hEvent, 0 );
 729     ok( r == WAIT_OBJECT_0, "event should be ready\n" );
 730
 731     ok( (NTSTATUS)ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
 732     ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
 733
 734     ov.Internal = 0;
 735     ov.InternalHigh = 0;
 736     S(U(ov)).Offset = 0;
 737     S(U(ov)).OffsetHigh = 0;
 738     memset( buffer, 0, sizeof buffer );
 739
 740     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 741     ok(r==TRUE, "should return true\n");
 742
 743     r = WaitForSingleObject( ov.hEvent, 0 );
 744     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 745
 746     r = RemoveDirectoryW( subdir );
 747     ok( r == TRUE, "failed to remove directory\n");
 748
 749     r = WaitForSingleObject( ov.hEvent, 1000 );
 750     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 751
 752     ok( (NTSTATUS)ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
 753     ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
 754
 755     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 756     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 757
 758     CloseHandle(hdir);
 759
 760     r = RemoveDirectoryW( path );
 761     ok( r == TRUE, "failed to remove directory\n");
 762 }
 763
 764 static void test_readdirectorychanges_filedir(void)
 765 {
 766     NTSTATUS r;
 767     HANDLE hdir, hfile;
 768     char buffer[0x1000];
 769     DWORD fflags, filter = 0;
 770     OVERLAPPED ov;
 771     WCHAR path[MAX_PATH], subdir[MAX_PATH], file[MAX_PATH];
 772     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 773     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 774     static const WCHAR szFoo[] = { '\\','f','o','o',0 };
 775     PFILE_NOTIFY_INFORMATION pfni;
 776
 777     SetLastError(0xdeadbeef);
 778     r = GetTempPathW( MAX_PATH, path );
 779     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 780     {
 781         win_skip("GetTempPathW is not implemented\n");
 782         return;
 783     }
 784     ok( r != 0, "temp path failed\n");
 785     if (!r)
 786         return;
 787
 788     lstrcatW( path, szBoo );
 789     lstrcpyW( subdir, path );
 790     lstrcatW( subdir, szHoo );
 791
 792     lstrcpyW( file, path );
 793     lstrcatW( file, szFoo );
 794
 795     DeleteFileW( file );
 796     RemoveDirectoryW( subdir );
 797     RemoveDirectoryW( path );
 798
 799     r = CreateDirectoryW(path, NULL);
 800     ok( r == TRUE, "failed to create directory\n");
 801
 802     fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
 803     hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
 804                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 805                         OPEN_EXISTING, fflags, NULL);
 806     ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 807
 808     ov.hEvent = CreateEventW( NULL, 0, 0, NULL );
 809
 810     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 811
 812     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,TRUE,filter,NULL,&ov,NULL);
 813     ok(r==TRUE, "should return true\n");
 814
 815     r = WaitForSingleObject( ov.hEvent, 10 );
 816     ok( r == WAIT_TIMEOUT, "should timeout\n" );
 817
 818     r = CreateDirectoryW( subdir, NULL );
 819     ok( r == TRUE, "failed to create directory\n");
 820
 821     hfile = CreateFileW( file, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
 822     ok( hfile != INVALID_HANDLE_VALUE, "failed to create file\n");
 823     ok( CloseHandle(hfile), "failed to close file\n");
 824
 825     r = WaitForSingleObject( ov.hEvent, 1000 );
 826     ok( r == WAIT_OBJECT_0, "event should be ready\n" );
 827
 828     ok( (NTSTATUS)ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 829     ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
 830
 831     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 832     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 833     ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
 834     ok( pfni->FileNameLength == 6, "len wrong\n" );
 835     ok( !memcmp(pfni->FileName,&szFoo[1],6), "name wrong\n" );
 836
 837     r = DeleteFileW( file );
 838     ok( r == TRUE, "failed to delete file\n");
 839
 840     r = RemoveDirectoryW( subdir );
 841     ok( r == TRUE, "failed to remove directory\n");
 842
 843     CloseHandle(hdir);
 844
 845     r = RemoveDirectoryW( path );
 846     ok( r == TRUE, "failed to remove directory\n");
 847 }
 848
 849 static void CALLBACK readdirectorychanges_cr(DWORD error, DWORD len, LPOVERLAPPED ov)
 850 {
 851     ok(error == 0, "ReadDirectoryChangesW error %d\n", error);
 852     ok(ov->hEvent == (void*)0xdeadbeef, "hEvent should not have changed\n");
 853 }
 854
 855 static void test_readdirectorychanges_cr(void)
 856 {
 857     static const WCHAR szBoo[] = { '\\','b','o','o','\\',0 };
 858     static const WCHAR szDir[] = { 'd','i','r',0 };
 859     static const WCHAR szFile[] = { 'f','i','l','e',0 };
 860     static const WCHAR szBackslash[] = { '\\',0 };
 861
 862     WCHAR path[MAX_PATH], file[MAX_PATH], dir[MAX_PATH], sub_file[MAX_PATH];
 863     FILE_NOTIFY_INFORMATION fni[1024], *fni_next;
 864     OVERLAPPED ov;
 865     HANDLE hdir, hfile;
 866     NTSTATUS r;
 867
 868     if (!pReadDirectoryChangesW)
 869     {
 870         win_skip("ReadDirectoryChangesW is not available\n");
 871         return;
 872     }
 873
 874     SetLastError(0xdeadbeef);
 875     r = GetTempPathW(MAX_PATH, path);
 876     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 877     {
 878         win_skip("GetTempPathW is not implemented\n");
 879         return;
 880     }
 881     ok(r != 0, "temp path failed\n");
 882     if (!r)
 883         return;
 884
 885     lstrcatW(path, szBoo);
 886     lstrcpyW(dir, path);
 887     lstrcatW(dir, szDir);
 888     lstrcpyW(file, path);
 889     lstrcatW(file, szFile);
 890     lstrcpyW(sub_file, dir);
 891     lstrcatW(sub_file, szBackslash);
 892     lstrcatW(sub_file, szFile);
 893
 894     DeleteFileW(file);
 895     RemoveDirectoryW(dir);
 896     RemoveDirectoryW(path);
 897
 898     r = CreateDirectoryW(path, NULL);
 899     ok(r == TRUE, "failed to create directory\n");
 900
 901     hdir = CreateFileW(path, GENERIC_READ,
 902             FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
 903             FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);
 904     ok(hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 905
 906     memset(&ov, 0, sizeof(ov));
 907     ov.hEvent = (void*)0xdeadbeef;
 908     r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
 909             FILE_NOTIFY_CHANGE_FILE_NAME, NULL, &ov, readdirectorychanges_cr);
 910     ok(r == TRUE, "pReadDirectoryChangesW failed\n");
 911
 912     hfile = CreateFileW(file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
 913     ok(hfile != INVALID_HANDLE_VALUE, "failed to create file\n");
 914     CloseHandle(hfile);
 915
 916     r = SleepEx(1000, TRUE);
 917     ok(r != 0, "failed to receive file creation event\n");
 918     ok(fni->NextEntryOffset == 0, "there should be no more events in buffer\n");
 919     ok(fni->Action == FILE_ACTION_ADDED, "Action = %d\n", fni->Action);
 920     ok(fni->FileNameLength == lstrlenW(szFile)*sizeof(WCHAR),
 921             "FileNameLength = %d\n", fni->FileNameLength);
 922     ok(!memcmp(fni->FileName, szFile, lstrlenW(szFile)*sizeof(WCHAR)),
 923             "FileName = %s\n", wine_dbgstr_wn(fni->FileName, fni->FileNameLength/sizeof(WCHAR)));
 924
 925     r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
 926             FILE_NOTIFY_CHANGE_FILE_NAME, NULL, &ov, readdirectorychanges_cr);
 927     ok(r == TRUE, "pReadDirectoryChangesW failed\n");
 928
 929     /* This event will not be reported */
 930     r = CreateDirectoryW(dir, NULL);
 931     ok(r == TRUE, "failed to create directory\n");
 932
 933     r = MoveFileW(file, sub_file);
 934     ok(r == TRUE, "failed to move file\n");
 935
 936     r = SleepEx(1000, TRUE);
 937     ok(r != 0, "failed to receive file move event\n");
 938     ok(fni->NextEntryOffset == 0, "there should be no more events in buffer\n");
 939     ok(fni->Action == FILE_ACTION_REMOVED, "Action = %d\n", fni->Action);
 940     ok(fni->FileNameLength == lstrlenW(szFile)*sizeof(WCHAR),
 941             "FileNameLength = %d\n", fni->FileNameLength);
 942     ok(!memcmp(fni->FileName, szFile, lstrlenW(szFile)*sizeof(WCHAR)),
 943             "FileName = %s\n", wine_dbgstr_wn(fni->FileName, fni->FileNameLength/sizeof(WCHAR)));
 944
 945     r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
 946             FILE_NOTIFY_CHANGE_FILE_NAME, NULL, &ov, readdirectorychanges_cr);
 947     ok(r == TRUE, "pReadDirectoryChangesW failed\n");
 948
 949     r = MoveFileW(sub_file, file);
 950     ok(r == TRUE, "failed to move file\n");
 951
 952     r = SleepEx(1000, TRUE);
 953     ok(r != 0, "failed to receive file move event\n");
 954     ok(fni->NextEntryOffset == 0, "there should be no more events in buffer\n");
 955     ok(fni->Action == FILE_ACTION_ADDED, "Action = %d\n", fni->Action);
 956     ok(fni->FileNameLength == lstrlenW(szFile)*sizeof(WCHAR),
 957             "FileNameLength = %d\n", fni->FileNameLength);
 958     ok(!memcmp(fni->FileName, szFile, lstrlenW(szFile)*sizeof(WCHAR)),
 959             "FileName = %s\n", wine_dbgstr_wn(fni->FileName, fni->FileNameLength/sizeof(WCHAR)));
 960
 961     r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
 962             FILE_NOTIFY_CHANGE_FILE_NAME, NULL, &ov, readdirectorychanges_cr);
 963     ok(r == TRUE, "pReadDirectoryChangesW failed\n");
 964
 965     r = DeleteFileW(file);
 966     ok(r == TRUE, "failed to delete file\n");
 967
 968     r = SleepEx(1000, TRUE);
 969     ok(r != 0, "failed to receive file removal event\n");
 970     ok(fni->NextEntryOffset == 0, "there should be no more events in buffer\n");
 971     ok(fni->Action == FILE_ACTION_REMOVED, "Action = %d\n", fni->Action);
 972     ok(fni->FileNameLength == lstrlenW(szFile)*sizeof(WCHAR),
 973             "FileNameLength = %d\n", fni->FileNameLength);
 974     ok(!memcmp(fni->FileName, szFile, lstrlenW(szFile)*sizeof(WCHAR)),
 975             "FileName = %s\n", wine_dbgstr_wn(fni->FileName, fni->FileNameLength/sizeof(WCHAR)));
 976
 977     CloseHandle(hdir);
 978
 979     hdir = CreateFileW(path, GENERIC_READ,
 980             FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
 981             FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);
 982     ok(hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 983
 984     r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
 985             FILE_NOTIFY_CHANGE_DIR_NAME, NULL, &ov, readdirectorychanges_cr);
 986     ok(r == TRUE, "pReadDirectoryChangesW failed\n");
 987
 988     r = MoveFileW(dir, file);
 989     ok(r == TRUE, "failed to move directory\n");
 990
 991     r = SleepEx(1000, TRUE);
 992     ok(r != 0, "failed to receive directory move event\n");
 993     if (fni->Action == FILE_ACTION_RENAMED_OLD_NAME)
 994     {
 995         ok(fni->Action == FILE_ACTION_RENAMED_OLD_NAME, "Action = %d\n", fni->Action);
 996         ok(fni->FileNameLength == lstrlenW(szDir)*sizeof(WCHAR),
 997                 "FileNameLength = %d\n", fni->FileNameLength);
 998         ok(!memcmp(fni->FileName, szDir, lstrlenW(szDir)*sizeof(WCHAR)),
 999                 "FileName = %s\n", wine_dbgstr_wn(fni->FileName, fni->FileNameLength/sizeof(WCHAR)));
1000         ok(fni->NextEntryOffset != 0, "no next entry in movement event\n");
1001         fni_next = (FILE_NOTIFY_INFORMATION*)((char*)fni+fni->NextEntryOffset);
1002         ok(fni_next->NextEntryOffset == 0, "there should be no more events in buffer\n");
1003         ok(fni_next->Action == FILE_ACTION_RENAMED_NEW_NAME, "Action = %d\n", fni_next->Action);
1004         ok(fni_next->FileNameLength == lstrlenW(szFile)*sizeof(WCHAR),
1005                 "FileNameLength = %d\n", fni_next->FileNameLength);
1006         ok(!memcmp(fni_next->FileName, szFile, lstrlenW(szFile)*sizeof(WCHAR)),
1007                 "FileName = %s\n", wine_dbgstr_wn(fni_next->FileName, fni_next->FileNameLength/sizeof(WCHAR)));
1008     }
1009     else
1010     {
1011         todo_wine ok(0, "Expected rename event\n");
1012
1013         if (fni->NextEntryOffset == 0)
1014         {
1015             r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
1016                     FILE_NOTIFY_CHANGE_DIR_NAME, NULL, &ov, readdirectorychanges_cr);
1017             ok(r == TRUE, "pReadDirectoryChangesW failed\n");
1018
1019             r = SleepEx(1000, TRUE);
1020             ok(r != 0, "failed to receive directory move event\n");
1021         }
1022     }
1023
1024     r = CreateDirectoryW(dir, NULL);
1025     ok(r == TRUE, "failed to create directory\n");
1026
1027     r = RemoveDirectoryW(dir);
1028     ok(r == TRUE, "failed to remove directory\n");
1029
1030     r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
1031             FILE_NOTIFY_CHANGE_DIR_NAME, NULL, &ov, readdirectorychanges_cr);
1032     ok(r == TRUE, "pReadDirectoryChangesW failed\n");
1033
1034     r = SleepEx(1000, TRUE);
1035     ok(r != 0, "failed to receive directory creation event\n");
1036     ok(fni->Action == FILE_ACTION_ADDED, "Action = %d\n", fni->Action);
1037     ok(fni->FileNameLength == lstrlenW(szDir)*sizeof(WCHAR),
1038             "FileNameLength = %d\n", fni->FileNameLength);
1039     ok(!memcmp(fni->FileName, szDir, lstrlenW(szDir)*sizeof(WCHAR)),
1040             "FileName = %s\n", wine_dbgstr_wn(fni->FileName, fni->FileNameLength/sizeof(WCHAR)));
1041     if (fni->NextEntryOffset)
1042         fni_next = (FILE_NOTIFY_INFORMATION*)((char*)fni+fni->NextEntryOffset);
1043     else
1044     {
1045         r = pReadDirectoryChangesW(hdir, fni, sizeof(fni), FALSE,
1046                 FILE_NOTIFY_CHANGE_DIR_NAME, NULL, &ov, readdirectorychanges_cr);
1047         ok(r == TRUE, "pReadDirectoryChangesW failed\n");
1048
1049         r = SleepEx(1000, TRUE);
1050         ok(r != 0, "failed to receive directory removal event\n");
1051         fni_next = fni;
1052     }
1053     ok(fni_next->NextEntryOffset == 0, "there should be no more events in buffer\n");
1054     ok(fni_next->Action == FILE_ACTION_REMOVED, "Action = %d\n", fni_next->Action);
1055     ok(fni_next->FileNameLength == lstrlenW(szDir)*sizeof(WCHAR),
1056             "FileNameLength = %d\n", fni_next->FileNameLength);
1057     ok(!memcmp(fni_next->FileName, szDir, lstrlenW(szDir)*sizeof(WCHAR)),
1058             "FileName = %s\n", wine_dbgstr_wn(fni_next->FileName, fni_next->FileNameLength/sizeof(WCHAR)));
1059
1060     CloseHandle(hdir);
1061     RemoveDirectoryW(file);
1062     RemoveDirectoryW(path);
1063 }
1064
1065 static void test_ffcn_directory_overlap(void)
1066 {
1067     HANDLE parent_watch, child_watch, parent_thread, child_thread;
1068     char workdir[MAX_PATH], parentdir[MAX_PATH], childdir[MAX_PATH];
1069     char tempfile[MAX_PATH];
1070     DWORD threadId;
1071     BOOL ret;
1072
1073     /* Setup directory hierarchy */
1074     ret = GetTempPathA(MAX_PATH, workdir);
1075     ok((ret > 0) && (ret <= MAX_PATH),
1076        "GetTempPathA error: %d\n", GetLastError());
1077
1078     ret = GetTempFileNameA(workdir, "fcn", 0, tempfile);
1079     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
1080     ret = DeleteFileA(tempfile);
1081     ok(ret, "DeleteFileA error: %d\n", GetLastError());
1082
1083     lstrcpyA(parentdir, tempfile);
1084     ret = CreateDirectoryA(parentdir, NULL);
1085     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
1086
1087     lstrcpyA(childdir, parentdir);
1088     lstrcatA(childdir, "\\c");
1089     ret = CreateDirectoryA(childdir, NULL);
1090     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
1091
1092
1093     /* When recursively watching overlapping directories, changes in child
1094      * should trigger notifications for both child and parent */
1095     parent_thread = StartNotificationThread(parentdir, TRUE,
1096                                             FILE_NOTIFY_CHANGE_FILE_NAME);
1097     child_thread = StartNotificationThread(childdir, TRUE,
1098                                             FILE_NOTIFY_CHANGE_FILE_NAME);
1099
1100     /* Create a file in child */
1101     ret = GetTempFileNameA(childdir, "fcn", 0, tempfile);
1102     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
1103
1104     /* Both watches should trigger */
1105     ret = FinishNotificationThread(parent_thread);
1106     ok(ret, "Missed parent notification\n");
1107     ret = FinishNotificationThread(child_thread);
1108     ok(ret, "Missed child notification\n");
1109
1110     ret = DeleteFileA(tempfile);
1111     ok(ret, "DeleteFileA error: %d\n", GetLastError());
1112
1113
1114     /* Removing a recursive parent watch should not affect child watches. Doing
1115      * so used to crash wineserver. */
1116     parent_watch = FindFirstChangeNotificationA(parentdir, TRUE,
1117                                                 FILE_NOTIFY_CHANGE_FILE_NAME);
1118     ok(parent_watch != INVALID_HANDLE_VALUE,
1119        "FindFirstChangeNotification error: %d\n", GetLastError());
1120     child_watch = FindFirstChangeNotificationA(childdir, TRUE,
1121                                                FILE_NOTIFY_CHANGE_FILE_NAME);
1122     ok(child_watch != INVALID_HANDLE_VALUE,
1123        "FindFirstChangeNotification error: %d\n", GetLastError());
1124
1125     ret = FindCloseChangeNotification(parent_watch);
1126     ok(ret, "FindCloseChangeNotification error: %d\n", GetLastError());
1127
1128     child_thread = CreateThread(NULL, 0, NotificationThread, child_watch, 0,
1129                                 &threadId);
1130     ok(child_thread != NULL, "CreateThread error: %d\n", GetLastError());
1131
1132     /* Create a file in child */
1133     ret = GetTempFileNameA(childdir, "fcn", 0, tempfile);
1134     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
1135
1136     /* Child watch should trigger */
1137     ret = FinishNotificationThread(child_thread);
1138     ok(ret, "Missed child notification\n");
1139
1140     /* clean up */
1141     ret = DeleteFileA(tempfile);
1142     ok(ret, "DeleteFileA error: %d\n", GetLastError());
1143
1144     ret = RemoveDirectoryA(childdir);
1145     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
1146
1147     ret = RemoveDirectoryA(parentdir);
1148     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
1149 }
1150
1151 START_TEST(change)
1152 {
1153     HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
1154     pReadDirectoryChangesW = (void *)GetProcAddress(hkernel32, "ReadDirectoryChangesW");
1155
1156     test_ffcnMultipleThreads();
1157     /* The above function runs a test that must occur before FindCloseChangeNotification is run in the
1158        current thread to preserve the emptiness of the wine user APC queue. To ensure this it should be
1159        placed first. */
1160     test_FindFirstChangeNotification();
1161     test_ffcn();
1162     test_readdirectorychanges();
1163     test_readdirectorychanges_null();
1164     test_readdirectorychanges_filedir();
1165     test_readdirectorychanges_cr();
1166     test_ffcn_directory_overlap();
1167 }