git.oblomov.eu Git - wine/blob - 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         ret = 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
  83     return exitcode;
  84 }
  85
  86 static void test_FindFirstChangeNotification(void)
  87 {
  88     HANDLE change, file, thread;
  89     DWORD attributes, count;
  90     BOOL ret;
  91
  92     char workdir[MAX_PATH], dirname1[MAX_PATH], dirname2[MAX_PATH];
  93     char filename1[MAX_PATH], filename2[MAX_PATH];
  94     static const char prefix[] = "FCN";
  95     char buffer[2048];
  96
  97     /* pathetic checks */
  98
  99     change = FindFirstChangeNotificationA("not-a-file", FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 100     ok(change == INVALID_HANDLE_VALUE, "Expected INVALID_HANDLE_VALUE, got %p\n", change);
 101     ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
 102        GetLastError() == ERROR_NO_MORE_FILES, /* win95 */
 103        "FindFirstChangeNotification error: %d\n", GetLastError());
 104
 105     if (0) /* This documents win2k behavior. It crashes on win98. */
 106     {
 107         change = FindFirstChangeNotificationA(NULL, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 108         ok(change == NULL && GetLastError() == ERROR_PATH_NOT_FOUND,
 109         "FindFirstChangeNotification error: %d\n", GetLastError());
 110     }
 111
 112     ret = FindNextChangeNotification(NULL);
 113     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindNextChangeNotification error: %d\n",
 114        GetLastError());
 115
 116     ret = FindCloseChangeNotification(NULL);
 117     ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindCloseChangeNotification error: %d\n",
 118        GetLastError());
 119
 120     ret = GetTempPathA(MAX_PATH, workdir);
 121     ok(ret, "GetTempPathA error: %d\n", GetLastError());
 122
 123     lstrcatA(workdir, "testFileChangeNotification");
 124
 125     ret = CreateDirectoryA(workdir, NULL);
 126     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 127
 128     ret = GetTempFileNameA(workdir, prefix, 0, filename1);
 129     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
 130
 131     file = CreateFileA(filename1, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS,
 132                        FILE_ATTRIBUTE_NORMAL, 0);
 133     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 134     ret = CloseHandle(file);
 135     ok( ret, "CloseHandle error: %d\n", GetLastError());
 136
 137     /* Try to register notification for a file. win98 and win2k behave differently here */
 138     change = FindFirstChangeNotificationA(filename1, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 139     ok(change == INVALID_HANDLE_VALUE && (GetLastError() == ERROR_DIRECTORY ||
 140                                           GetLastError() == ERROR_FILE_NOT_FOUND),
 141        "FindFirstChangeNotification error: %d\n", GetLastError());
 142
 143     lstrcpyA(dirname1, filename1);
 144     lstrcatA(dirname1, "dir");
 145
 146     lstrcpyA(dirname2, dirname1);
 147     lstrcatA(dirname2, "new");
 148
 149     ret = CreateDirectoryA(dirname1, NULL);
 150     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 151
 152     /* What if we move the directory we registered notification for? */
 153     thread = StartNotificationThread(dirname1, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 154     ret = MoveFileA(dirname1, dirname2);
 155     ok(ret, "MoveFileA error: %d\n", GetLastError());
 156     /* win9x and win2k behave differently here, don't check result */
 157     FinishNotificationThread(thread);
 158
 159     /* What if we remove the directory we registered notification for? */
 160     thread = StartNotificationThread(dirname2, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 161     ret = RemoveDirectoryA(dirname2);
 162     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 163     /* win9x and win2k behave differently here, don't check result */
 164     FinishNotificationThread(thread);
 165
 166     /* functional checks */
 167
 168     /* Create a directory */
 169     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 170     ret = CreateDirectoryA(dirname1, NULL);
 171     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 172     ok(FinishNotificationThread(thread), "Missed notification\n");
 173
 174     /* Rename a directory */
 175     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 176     ret = MoveFileA(dirname1, dirname2);
 177     ok(ret, "MoveFileA error: %d\n", GetLastError());
 178     ok(FinishNotificationThread(thread), "Missed notification\n");
 179
 180     /* Delete a directory */
 181     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
 182     ret = RemoveDirectoryA(dirname2);
 183     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 184     ok(FinishNotificationThread(thread), "Missed notification\n");
 185
 186     lstrcpyA(filename2, filename1);
 187     lstrcatA(filename2, "new");
 188
 189     /* Rename a file */
 190     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 191     ret = MoveFileA(filename1, filename2);
 192     ok(ret, "MoveFileA error: %d\n", GetLastError());
 193     ok(FinishNotificationThread(thread), "Missed notification\n");
 194
 195     /* Delete a file */
 196     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 197     ret = DeleteFileA(filename2);
 198     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 199     ok(FinishNotificationThread(thread), "Missed notification\n");
 200
 201     /* Create a file */
 202     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
 203     file = CreateFileA(filename2, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS,
 204                        FILE_ATTRIBUTE_NORMAL, 0);
 205     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 206     ret = CloseHandle(file);
 207     ok( ret, "CloseHandle error: %d\n", GetLastError());
 208     ok(FinishNotificationThread(thread), "Missed notification\n");
 209
 210     attributes = GetFileAttributesA(filename2);
 211     ok(attributes != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA error: %d\n", GetLastError());
 212     attributes &= FILE_ATTRIBUTE_READONLY;
 213
 214     /* Change file attributes */
 215     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_ATTRIBUTES);
 216     ret = SetFileAttributesA(filename2, attributes);
 217     ok(ret, "SetFileAttributesA error: %d\n", GetLastError());
 218     ok(FinishNotificationThread(thread), "Missed notification\n");
 219
 220     /* Change last write time by writing to a file */
 221     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE);
 222     file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 223                        FILE_ATTRIBUTE_NORMAL, 0);
 224     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 225     memset(buffer, 0, sizeof(buffer));
 226     ret = WriteFile(file, buffer, sizeof(buffer), &count, NULL);
 227     ok(ret && count == sizeof(buffer), "WriteFile error: %d\n", GetLastError());
 228     ret = CloseHandle(file);
 229     ok( ret, "CloseHandle error: %d\n", GetLastError());
 230     ok(FinishNotificationThread(thread), "Missed notification\n");
 231
 232     /* Change file size by truncating a file */
 233     thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_SIZE);
 234     file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 235                        FILE_ATTRIBUTE_NORMAL, 0);
 236     ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
 237     ret = WriteFile(file, buffer, sizeof(buffer) / 2, &count, NULL);
 238     ok(ret && count == sizeof(buffer) / 2, "WriteFileA error: %d\n", GetLastError());
 239     ret = CloseHandle(file);
 240     ok( ret, "CloseHandle error: %d\n", GetLastError());
 241     ok(FinishNotificationThread(thread), "Missed notification\n");
 242
 243     /* clean up */
 244
 245     ret = DeleteFileA(filename2);
 246     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 247
 248     ret = RemoveDirectoryA(workdir);
 249     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 250 }
 251
 252 /* this test concentrates more on the wait behaviour of the handle */
 253 static void test_ffcn(void)
 254 {
 255     DWORD filter;
 256     HANDLE handle;
 257     LONG r;
 258     WCHAR path[MAX_PATH], subdir[MAX_PATH];
 259     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 260     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 261
 262     SetLastError(0xdeadbeef);
 263     r = GetTempPathW( MAX_PATH, path );
 264     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 265     {
 266         win_skip("GetTempPathW is not implemented\n");
 267         return;
 268     }
 269     ok( r != 0, "temp path failed\n");
 270     if (!r)
 271         return;
 272
 273     lstrcatW( path, szBoo );
 274     lstrcpyW( subdir, path );
 275     lstrcatW( subdir, szHoo );
 276
 277     RemoveDirectoryW( subdir );
 278     RemoveDirectoryW( path );
 279
 280     r = CreateDirectoryW(path, NULL);
 281     ok( r == TRUE, "failed to create directory\n");
 282
 283     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 284     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 285
 286     handle = FindFirstChangeNotificationW( path, 1, filter);
 287     ok( handle != INVALID_HANDLE_VALUE, "invalid handle\n");
 288
 289     r = WaitForSingleObject( handle, 0 );
 290     ok( r == STATUS_TIMEOUT, "should time out\n");
 291
 292     r = CreateDirectoryW( subdir, NULL );
 293     ok( r == TRUE, "failed to create subdir\n");
 294
 295     r = WaitForSingleObject( handle, 0 );
 296     ok( r == WAIT_OBJECT_0, "should be ready\n");
 297
 298     r = WaitForSingleObject( handle, 0 );
 299     ok( r == WAIT_OBJECT_0, "should be ready\n");
 300
 301     r = FindNextChangeNotification(handle);
 302     ok( r == TRUE, "find next failed\n");
 303
 304     r = WaitForSingleObject( handle, 0 );
 305     ok( r == STATUS_TIMEOUT, "should time out\n");
 306
 307     r = RemoveDirectoryW( subdir );
 308     ok( r == TRUE, "failed to remove subdir\n");
 309
 310     r = WaitForSingleObject( handle, 0 );
 311     ok( r == WAIT_OBJECT_0, "should be ready\n");
 312
 313     r = WaitForSingleObject( handle, 0 );
 314     ok( r == WAIT_OBJECT_0, "should be ready\n");
 315
 316     r = FindNextChangeNotification(handle);
 317     ok( r == TRUE, "find next failed\n");
 318
 319     r = FindNextChangeNotification(handle);
 320     ok( r == TRUE, "find next failed\n");
 321
 322     r = FindCloseChangeNotification(handle);
 323     ok( r == TRUE, "should succeed\n");
 324
 325     r = RemoveDirectoryW( path );
 326     ok( r == TRUE, "failed to remove dir\n");
 327 }
 328
 329 /* this test concentrates on the wait behavior when multiple threads are
 330  * waiting on a change notification handle. */
 331 static void test_ffcnMultipleThreads(void)
 332 {
 333     LONG r;
 334     DWORD filter, threadId, status, exitcode;
 335     HANDLE handles[2];
 336     char path[MAX_PATH];
 337
 338     r = GetTempPathA(MAX_PATH, path);
 339     ok(r, "GetTempPathA error: %d\n", GetLastError());
 340
 341     lstrcatA(path, "ffcnTestMultipleThreads");
 342
 343     RemoveDirectoryA(path);
 344
 345     r = CreateDirectoryA(path, NULL);
 346     ok(r, "CreateDirectoryA error: %d\n", GetLastError());
 347
 348     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 349     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 350
 351     handles[0] = FindFirstChangeNotificationA(path, FALSE, filter);
 352     ok(handles[0] != INVALID_HANDLE_VALUE, "FindFirstChangeNotification error: %d\n", GetLastError());
 353
 354     /* Test behavior if a waiting thread holds the last reference to a change
 355      * directory object with an empty wine user APC queue for this thread (bug #7286) */
 356
 357     /* Create our notification thread */
 358     handles[1] = CreateThread(NULL, 0, NotificationThread, handles[0], 0,
 359                               &threadId);
 360     ok(handles[1] != NULL, "CreateThread error: %d\n", GetLastError());
 361
 362     status = WaitForMultipleObjects(2, handles, FALSE, 5000);
 363     ok(status == WAIT_OBJECT_0 || status == WAIT_OBJECT_0+1, "WaitForMultipleObjects status %d error %d\n", status, GetLastError());
 364     ok(GetExitCodeThread(handles[1], &exitcode), "Could not retrieve thread exit code\n");
 365
 366     /* Clean up */
 367     r = RemoveDirectoryA( path );
 368     ok( r == TRUE, "failed to remove dir\n");
 369 }
 370
 371 typedef BOOL (WINAPI *fnReadDirectoryChangesW)(HANDLE,LPVOID,DWORD,BOOL,DWORD,
 372                          LPDWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
 373 fnReadDirectoryChangesW pReadDirectoryChangesW;
 374
 375 static void test_readdirectorychanges(void)
 376 {
 377     HANDLE hdir;
 378     char buffer[0x1000];
 379     DWORD fflags, filter = 0, r, dwCount;
 380     OVERLAPPED ov;
 381     WCHAR path[MAX_PATH], subdir[MAX_PATH], subsubdir[MAX_PATH];
 382     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 383     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 384     static const WCHAR szGa[] = { '\\','h','o','o','\\','g','a',0 };
 385     PFILE_NOTIFY_INFORMATION pfni;
 386
 387     if (!pReadDirectoryChangesW)
 388     {
 389         win_skip("ReadDirectoryChangesW is not available\n");
 390         return;
 391     }
 392
 393     SetLastError(0xdeadbeef);
 394     r = GetTempPathW( MAX_PATH, path );
 395     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 396     {
 397         win_skip("GetTempPathW is not implemented\n");
 398         return;
 399     }
 400     ok( r != 0, "temp path failed\n");
 401     if (!r)
 402         return;
 403
 404     lstrcatW( path, szBoo );
 405     lstrcpyW( subdir, path );
 406     lstrcatW( subdir, szHoo );
 407
 408     lstrcpyW( subsubdir, path );
 409     lstrcatW( subsubdir, szGa );
 410
 411     RemoveDirectoryW( subsubdir );
 412     RemoveDirectoryW( subdir );
 413     RemoveDirectoryW( path );
 414
 415     r = CreateDirectoryW(path, NULL);
 416     ok( r == TRUE, "failed to create directory\n");
 417
 418     SetLastError(0xd0b00b00);
 419     r = pReadDirectoryChangesW(NULL,NULL,0,FALSE,0,NULL,NULL,NULL);
 420     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 421     ok(r==FALSE, "should return false\n");
 422
 423     fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
 424     hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
 425                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 426                         OPEN_EXISTING, fflags, NULL);
 427     ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 428
 429     ov.hEvent = CreateEvent( NULL, 1, 0, NULL );
 430
 431     SetLastError(0xd0b00b00);
 432     r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,0,NULL,NULL,NULL);
 433     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 434     ok(r==FALSE, "should return false\n");
 435
 436     SetLastError(0xd0b00b00);
 437     r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,0,NULL,&ov,NULL);
 438     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 439     ok(r==FALSE, "should return false\n");
 440
 441     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 442     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 443     filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
 444     filter |= FILE_NOTIFY_CHANGE_SIZE;
 445     filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
 446     filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
 447     filter |= FILE_NOTIFY_CHANGE_CREATION;
 448     filter |= FILE_NOTIFY_CHANGE_SECURITY;
 449
 450     SetLastError(0xd0b00b00);
 451     ov.Internal = 0;
 452     ov.InternalHigh = 0;
 453     memset( buffer, 0, sizeof buffer );
 454
 455     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,-1,NULL,&ov,NULL);
 456     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 457     ok(r==FALSE, "should return false\n");
 458
 459     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,&ov,NULL);
 460     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 461     ok(r==FALSE, "should return false\n");
 462
 463     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,TRUE,filter,NULL,&ov,NULL);
 464     ok(r==TRUE, "should return true\n");
 465
 466     r = WaitForSingleObject( ov.hEvent, 10 );
 467     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 468
 469     r = CreateDirectoryW( subdir, NULL );
 470     ok( r == TRUE, "failed to create directory\n");
 471
 472     r = WaitForSingleObject( ov.hEvent, 1000 );
 473     ok( r == WAIT_OBJECT_0, "event should be ready\n" );
 474
 475     ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 476     ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
 477
 478     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 479     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 480     ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
 481     ok( pfni->FileNameLength == 6, "len wrong\n" );
 482     ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
 483
 484     ResetEvent(ov.hEvent);
 485     SetLastError(0xd0b00b00);
 486     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,NULL,NULL);
 487     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 488     ok(r==FALSE, "should return false\n");
 489
 490     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,&ov,NULL);
 491     ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
 492     ok(r==FALSE, "should return false\n");
 493
 494     filter = FILE_NOTIFY_CHANGE_SIZE;
 495
 496     SetEvent(ov.hEvent);
 497     ov.Internal = 1;
 498     ov.InternalHigh = 1;
 499     S(U(ov)).Offset = 0;
 500     S(U(ov)).OffsetHigh = 0;
 501     memset( buffer, 0, sizeof buffer );
 502     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 503     ok(r==TRUE, "should return true\n");
 504
 505     ok( ov.Internal == STATUS_PENDING, "ov.Internal wrong\n");
 506     ok( ov.InternalHigh == 1, "ov.InternalHigh wrong\n");
 507
 508     r = WaitForSingleObject( ov.hEvent, 0 );
 509     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 510
 511     r = RemoveDirectoryW( subdir );
 512     ok( r == TRUE, "failed to remove directory\n");
 513
 514     r = WaitForSingleObject( ov.hEvent, 1000 );
 515     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 516
 517     ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 518     ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
 519
 520     if (ov.Internal == STATUS_SUCCESS)
 521     {
 522         r = GetOverlappedResult( hdir, &ov, &dwCount, TRUE );
 523         ok( r == TRUE, "getoverlappedresult failed\n");
 524         ok( dwCount == 0x12, "count wrong\n");
 525     }
 526
 527     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 528     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 529     ok( pfni->Action == FILE_ACTION_REMOVED, "action wrong\n" );
 530     ok( pfni->FileNameLength == 6, "len wrong\n" );
 531     ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
 532
 533     /* what happens if the buffer is too small? */
 534     r = pReadDirectoryChangesW(hdir,buffer,0x10,FALSE,filter,NULL,&ov,NULL);
 535     ok(r==TRUE, "should return true\n");
 536
 537     r = CreateDirectoryW( subdir, NULL );
 538     ok( r == TRUE, "failed to create directory\n");
 539
 540     r = WaitForSingleObject( ov.hEvent, 1000 );
 541     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 542
 543     ok( ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
 544     ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
 545
 546     /* test the recursive watch */
 547     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 548     ok(r==TRUE, "should return true\n");
 549
 550     r = CreateDirectoryW( subsubdir, NULL );
 551     ok( r == TRUE, "failed to create directory\n");
 552
 553     r = WaitForSingleObject( ov.hEvent, 1000 );
 554     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 555
 556     ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 557     ok( ov.InternalHigh == 0x18, "ov.InternalHigh wrong\n");
 558
 559     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 560     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 561     ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
 562     ok( pfni->FileNameLength == 6*sizeof(WCHAR), "len wrong\n" );
 563     ok( !memcmp(pfni->FileName,&szGa[1],6*sizeof(WCHAR)), "name wrong\n" );
 564
 565     r = RemoveDirectoryW( subsubdir );
 566     ok( r == TRUE, "failed to remove directory\n");
 567
 568     ov.Internal = 1;
 569     ov.InternalHigh = 1;
 570     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 571     ok(r==TRUE, "should return true\n");
 572
 573     r = RemoveDirectoryW( subdir );
 574     ok( r == TRUE, "failed to remove directory\n");
 575
 576     r = WaitForSingleObject( ov.hEvent, 1000 );
 577     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 578
 579     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 580     /* we may get a notification for the parent dir too */
 581     if (pfni->Action == FILE_ACTION_MODIFIED && pfni->NextEntryOffset)
 582     {
 583         ok( pfni->FileNameLength == 3*sizeof(WCHAR), "len wrong %u\n", pfni->FileNameLength );
 584         ok( !memcmp(pfni->FileName,&szGa[1],3*sizeof(WCHAR)), "name wrong\n" );
 585         pfni = (PFILE_NOTIFY_INFORMATION)((char *)pfni + pfni->NextEntryOffset);
 586     }
 587     ok( pfni->NextEntryOffset == 0, "offset wrong %u\n", pfni->NextEntryOffset );
 588     ok( pfni->Action == FILE_ACTION_REMOVED, "action wrong %u\n", pfni->Action );
 589     ok( pfni->FileNameLength == 6*sizeof(WCHAR), "len wrong %u\n", pfni->FileNameLength );
 590     ok( !memcmp(pfni->FileName,&szGa[1],6*sizeof(WCHAR)), "name wrong\n" );
 591
 592     ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 593     dwCount = (char *)&pfni->FileName[pfni->FileNameLength/sizeof(WCHAR)] - buffer;
 594     ok( ov.InternalHigh == dwCount, "ov.InternalHigh wrong %lu/%u\n",ov.InternalHigh, dwCount );
 595
 596     CloseHandle(hdir);
 597
 598     r = RemoveDirectoryW( path );
 599     ok( r == TRUE, "failed to remove directory\n");
 600 }
 601
 602 /* show the behaviour when a null buffer is passed */
 603 static void test_readdirectorychanges_null(void)
 604 {
 605     NTSTATUS r;
 606     HANDLE hdir;
 607     char buffer[0x1000];
 608     DWORD fflags, filter = 0;
 609     OVERLAPPED ov;
 610     WCHAR path[MAX_PATH], subdir[MAX_PATH];
 611     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 612     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 613     PFILE_NOTIFY_INFORMATION pfni;
 614
 615     if (!pReadDirectoryChangesW)
 616     {
 617         win_skip("ReadDirectoryChangesW is not available\n");
 618         return;
 619     }
 620     SetLastError(0xdeadbeef);
 621     r = GetTempPathW( MAX_PATH, path );
 622     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 623     {
 624         win_skip("GetTempPathW is not implemented\n");
 625         return;
 626     }
 627     ok( r != 0, "temp path failed\n");
 628     if (!r)
 629         return;
 630
 631     lstrcatW( path, szBoo );
 632     lstrcpyW( subdir, path );
 633     lstrcatW( subdir, szHoo );
 634
 635     RemoveDirectoryW( subdir );
 636     RemoveDirectoryW( path );
 637
 638     r = CreateDirectoryW(path, NULL);
 639     ok( r == TRUE, "failed to create directory\n");
 640
 641     fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
 642     hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
 643                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 644                         OPEN_EXISTING, fflags, NULL);
 645     ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 646
 647     ov.hEvent = CreateEvent( NULL, 1, 0, NULL );
 648
 649     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 650     filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
 651
 652     SetLastError(0xd0b00b00);
 653     ov.Internal = 0;
 654     ov.InternalHigh = 0;
 655     memset( buffer, 0, sizeof buffer );
 656
 657     r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,filter,NULL,&ov,NULL);
 658     ok(r==TRUE, "should return true\n");
 659
 660     r = WaitForSingleObject( ov.hEvent, 0 );
 661     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 662
 663     r = CreateDirectoryW( subdir, NULL );
 664     ok( r == TRUE, "failed to create directory\n");
 665
 666     r = WaitForSingleObject( ov.hEvent, 0 );
 667     ok( r == WAIT_OBJECT_0, "event should be ready\n" );
 668
 669     ok( ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
 670     ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
 671
 672     ov.Internal = 0;
 673     ov.InternalHigh = 0;
 674     S(U(ov)).Offset = 0;
 675     S(U(ov)).OffsetHigh = 0;
 676     memset( buffer, 0, sizeof buffer );
 677
 678     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
 679     ok(r==TRUE, "should return true\n");
 680
 681     r = WaitForSingleObject( ov.hEvent, 0 );
 682     ok( r == STATUS_TIMEOUT, "should timeout\n" );
 683
 684     r = RemoveDirectoryW( subdir );
 685     ok( r == TRUE, "failed to remove directory\n");
 686
 687     r = WaitForSingleObject( ov.hEvent, 1000 );
 688     ok( r == WAIT_OBJECT_0, "should be ready\n" );
 689
 690     ok( ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
 691     ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
 692
 693     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 694     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 695
 696     CloseHandle(hdir);
 697
 698     r = RemoveDirectoryW( path );
 699     ok( r == TRUE, "failed to remove directory\n");
 700 }
 701
 702 static void test_readdirectorychanges_filedir(void)
 703 {
 704     NTSTATUS r;
 705     HANDLE hdir, hfile;
 706     char buffer[0x1000];
 707     DWORD fflags, filter = 0;
 708     OVERLAPPED ov;
 709     WCHAR path[MAX_PATH], subdir[MAX_PATH], file[MAX_PATH];
 710     static const WCHAR szBoo[] = { '\\','b','o','o',0 };
 711     static const WCHAR szHoo[] = { '\\','h','o','o',0 };
 712     static const WCHAR szFoo[] = { '\\','f','o','o',0 };
 713     PFILE_NOTIFY_INFORMATION pfni;
 714
 715     SetLastError(0xdeadbeef);
 716     r = GetTempPathW( MAX_PATH, path );
 717     if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
 718     {
 719         win_skip("GetTempPathW is not implemented\n");
 720         return;
 721     }
 722     ok( r != 0, "temp path failed\n");
 723     if (!r)
 724         return;
 725
 726     lstrcatW( path, szBoo );
 727     lstrcpyW( subdir, path );
 728     lstrcatW( subdir, szHoo );
 729
 730     lstrcpyW( file, path );
 731     lstrcatW( file, szFoo );
 732
 733     DeleteFileW( file );
 734     RemoveDirectoryW( subdir );
 735     RemoveDirectoryW( path );
 736
 737     r = CreateDirectoryW(path, NULL);
 738     ok( r == TRUE, "failed to create directory\n");
 739
 740     fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
 741     hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
 742                         FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 743                         OPEN_EXISTING, fflags, NULL);
 744     ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
 745
 746     ov.hEvent = CreateEvent( NULL, 0, 0, NULL );
 747
 748     filter = FILE_NOTIFY_CHANGE_FILE_NAME;
 749
 750     r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,TRUE,filter,NULL,&ov,NULL);
 751     ok(r==TRUE, "should return true\n");
 752
 753     r = WaitForSingleObject( ov.hEvent, 10 );
 754     ok( r == WAIT_TIMEOUT, "should timeout\n" );
 755
 756     r = CreateDirectoryW( subdir, NULL );
 757     ok( r == TRUE, "failed to create directory\n");
 758
 759     hfile = CreateFileW( file, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
 760     ok( hfile != INVALID_HANDLE_VALUE, "failed to create file\n");
 761     ok( CloseHandle(hfile), "failed toc lose file\n");
 762
 763     r = WaitForSingleObject( ov.hEvent, 1000 );
 764     ok( r == WAIT_OBJECT_0, "event should be ready\n" );
 765
 766     ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
 767     ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
 768
 769     pfni = (PFILE_NOTIFY_INFORMATION) buffer;
 770     ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
 771     ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
 772     ok( pfni->FileNameLength == 6, "len wrong\n" );
 773     ok( !memcmp(pfni->FileName,&szFoo[1],6), "name wrong\n" );
 774
 775     r = DeleteFileW( file );
 776     ok( r == TRUE, "failed to delete file\n");
 777
 778     r = RemoveDirectoryW( subdir );
 779     ok( r == TRUE, "failed to remove directory\n");
 780
 781     CloseHandle(hdir);
 782
 783     r = RemoveDirectoryW( path );
 784     ok( r == TRUE, "failed to remove directory\n");
 785 }
 786
 787 static void test_ffcn_directory_overlap(void)
 788 {
 789     HANDLE parent_watch, child_watch, parent_thread, child_thread;
 790     char workdir[MAX_PATH], parentdir[MAX_PATH], childdir[MAX_PATH];
 791     char tempfile[MAX_PATH];
 792     DWORD threadId;
 793     BOOL ret;
 794
 795     /* Setup directory hierarchy */
 796     ret = GetTempPathA(MAX_PATH, workdir);
 797     ok((ret > 0) && (ret <= MAX_PATH),
 798        "GetTempPathA error: %d\n", GetLastError());
 799
 800     ret = GetTempFileNameA(workdir, "fcn", 0, tempfile);
 801     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
 802     ret = DeleteFileA(tempfile);
 803     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 804
 805     lstrcpyA(parentdir, tempfile);
 806     ret = CreateDirectoryA(parentdir, NULL);
 807     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 808
 809     lstrcpyA(childdir, parentdir);
 810     lstrcatA(childdir, "\\c");
 811     ret = CreateDirectoryA(childdir, NULL);
 812     ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
 813
 814
 815     /* When recursively watching overlapping directories, changes in child
 816      * should trigger notifications for both child and parent */
 817     parent_thread = StartNotificationThread(parentdir, TRUE,
 818                                             FILE_NOTIFY_CHANGE_FILE_NAME);
 819     child_thread = StartNotificationThread(childdir, TRUE,
 820                                             FILE_NOTIFY_CHANGE_FILE_NAME);
 821
 822     /* Create a file in child */
 823     ret = GetTempFileNameA(childdir, "fcn", 0, tempfile);
 824     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
 825
 826     /* Both watches should trigger */
 827     ret = FinishNotificationThread(parent_thread);
 828     ok(ret, "Missed parent notification\n");
 829     ret = FinishNotificationThread(child_thread);
 830     ok(ret, "Missed child notification\n");
 831
 832     ret = DeleteFileA(tempfile);
 833     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 834
 835
 836     /* Removing a recursive parent watch should not affect child watches. Doing
 837      * so used to crash wineserver. */
 838     parent_watch = FindFirstChangeNotificationA(parentdir, TRUE,
 839                                                 FILE_NOTIFY_CHANGE_FILE_NAME);
 840     ok(parent_watch != INVALID_HANDLE_VALUE,
 841        "FindFirstChangeNotification error: %d\n", GetLastError());
 842     child_watch = FindFirstChangeNotificationA(childdir, TRUE,
 843                                                FILE_NOTIFY_CHANGE_FILE_NAME);
 844     ok(child_watch != INVALID_HANDLE_VALUE,
 845        "FindFirstChangeNotification error: %d\n", GetLastError());
 846
 847     ret = FindCloseChangeNotification(parent_watch);
 848     ok(ret, "FindCloseChangeNotification error: %d\n", GetLastError());
 849
 850     child_thread = CreateThread(NULL, 0, NotificationThread, child_watch, 0,
 851                                 &threadId);
 852     ok(child_thread != NULL, "CreateThread error: %d\n", GetLastError());
 853
 854     /* Create a file in child */
 855     ret = GetTempFileNameA(childdir, "fcn", 0, tempfile);
 856     ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
 857
 858     /* Child watch should trigger */
 859     ret = FinishNotificationThread(child_thread);
 860     ok(ret, "Missed child notification\n");
 861
 862     /* clean up */
 863     ret = DeleteFileA(tempfile);
 864     ok(ret, "DeleteFileA error: %d\n", GetLastError());
 865
 866     ret = RemoveDirectoryA(childdir);
 867     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 868
 869     ret = RemoveDirectoryA(parentdir);
 870     ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
 871 }
 872
 873 START_TEST(change)
 874 {
 875     HMODULE hkernel32 = GetModuleHandle("kernel32");
 876     pReadDirectoryChangesW = (fnReadDirectoryChangesW)
 877         GetProcAddress(hkernel32, "ReadDirectoryChangesW");
 878
 879     test_ffcnMultipleThreads();
 880     /* The above function runs a test that must occur before FindCloseChangeNotification is run in the
 881        current thread to preserve the emptiness of the wine user APC queue. To ensure this it should be
 882        placed first. */
 883     test_FindFirstChangeNotification();
 884     test_ffcn();
 885     test_readdirectorychanges();
 886     test_readdirectorychanges_null();
 887     test_readdirectorychanges_filedir();
 888     test_ffcn_directory_overlap();
 889 }