889 lines
32 KiB
C
889 lines
32 KiB
C
/*
|
|
* Tests for file change notification functions
|
|
*
|
|
* Copyright (c) 2004 Hans Leidekker
|
|
* Copyright 2006 Mike McCormack for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/* TODO: - security attribute changes
|
|
* - compound filter and multiple notifications
|
|
* - subtree notifications
|
|
* - non-documented flags FILE_NOTIFY_CHANGE_LAST_ACCESS and
|
|
* FILE_NOTIFY_CHANGE_CREATION
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "wine/test.h"
|
|
#include <windef.h>
|
|
#include <winbase.h>
|
|
#include <winternl.h>
|
|
|
|
static DWORD CALLBACK NotificationThread(LPVOID arg)
|
|
{
|
|
HANDLE change = arg;
|
|
BOOL notified = FALSE;
|
|
BOOL ret = FALSE;
|
|
DWORD status;
|
|
|
|
status = WaitForSingleObject(change, 100);
|
|
|
|
if (status == WAIT_OBJECT_0 ) {
|
|
notified = TRUE;
|
|
ret = FindNextChangeNotification(change);
|
|
}
|
|
|
|
ret = FindCloseChangeNotification(change);
|
|
ok( ret, "FindCloseChangeNotification error: %d\n",
|
|
GetLastError());
|
|
|
|
ExitThread((DWORD)notified);
|
|
}
|
|
|
|
static HANDLE StartNotificationThread(LPCSTR path, BOOL subtree, DWORD flags)
|
|
{
|
|
HANDLE change, thread;
|
|
DWORD threadId;
|
|
|
|
change = FindFirstChangeNotificationA(path, subtree, flags);
|
|
ok(change != INVALID_HANDLE_VALUE, "FindFirstChangeNotification error: %d\n", GetLastError());
|
|
|
|
thread = CreateThread(NULL, 0, NotificationThread, change, 0, &threadId);
|
|
ok(thread != NULL, "CreateThread error: %d\n", GetLastError());
|
|
|
|
return thread;
|
|
}
|
|
|
|
static DWORD FinishNotificationThread(HANDLE thread)
|
|
{
|
|
DWORD status, exitcode;
|
|
|
|
status = WaitForSingleObject(thread, 5000);
|
|
ok(status == WAIT_OBJECT_0, "WaitForSingleObject status %d error %d\n", status, GetLastError());
|
|
|
|
ok(GetExitCodeThread(thread, &exitcode), "Could not retrieve thread exit code\n");
|
|
CloseHandle(thread);
|
|
|
|
return exitcode;
|
|
}
|
|
|
|
static void test_FindFirstChangeNotification(void)
|
|
{
|
|
HANDLE change, file, thread;
|
|
DWORD attributes, count;
|
|
BOOL ret;
|
|
|
|
char workdir[MAX_PATH], dirname1[MAX_PATH], dirname2[MAX_PATH];
|
|
char filename1[MAX_PATH], filename2[MAX_PATH];
|
|
static const char prefix[] = "FCN";
|
|
char buffer[2048];
|
|
|
|
/* pathetic checks */
|
|
|
|
change = FindFirstChangeNotificationA("not-a-file", FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ok(change == INVALID_HANDLE_VALUE, "Expected INVALID_HANDLE_VALUE, got %p\n", change);
|
|
ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
|
|
GetLastError() == ERROR_NO_MORE_FILES, /* win95 */
|
|
"FindFirstChangeNotification error: %d\n", GetLastError());
|
|
|
|
if (0) /* This documents win2k behavior. It crashes on win98. */
|
|
{
|
|
change = FindFirstChangeNotificationA(NULL, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ok(change == NULL && GetLastError() == ERROR_PATH_NOT_FOUND,
|
|
"FindFirstChangeNotification error: %d\n", GetLastError());
|
|
}
|
|
|
|
ret = FindNextChangeNotification(NULL);
|
|
ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindNextChangeNotification error: %d\n",
|
|
GetLastError());
|
|
|
|
ret = FindCloseChangeNotification(NULL);
|
|
ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "FindCloseChangeNotification error: %d\n",
|
|
GetLastError());
|
|
|
|
ret = GetTempPathA(MAX_PATH, workdir);
|
|
ok(ret, "GetTempPathA error: %d\n", GetLastError());
|
|
|
|
lstrcatA(workdir, "testFileChangeNotification");
|
|
|
|
ret = CreateDirectoryA(workdir, NULL);
|
|
ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
|
|
|
|
ret = GetTempFileNameA(workdir, prefix, 0, filename1);
|
|
ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
|
|
|
|
file = CreateFileA(filename1, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
|
|
ret = CloseHandle(file);
|
|
ok( ret, "CloseHandle error: %d\n", GetLastError());
|
|
|
|
/* Try to register notification for a file. win98 and win2k behave differently here */
|
|
change = FindFirstChangeNotificationA(filename1, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ok(change == INVALID_HANDLE_VALUE && (GetLastError() == ERROR_DIRECTORY ||
|
|
GetLastError() == ERROR_FILE_NOT_FOUND),
|
|
"FindFirstChangeNotification error: %d\n", GetLastError());
|
|
|
|
lstrcpyA(dirname1, filename1);
|
|
lstrcatA(dirname1, "dir");
|
|
|
|
lstrcpyA(dirname2, dirname1);
|
|
lstrcatA(dirname2, "new");
|
|
|
|
ret = CreateDirectoryA(dirname1, NULL);
|
|
ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
|
|
|
|
/* What if we move the directory we registered notification for? */
|
|
thread = StartNotificationThread(dirname1, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
|
|
ret = MoveFileA(dirname1, dirname2);
|
|
ok(ret, "MoveFileA error: %d\n", GetLastError());
|
|
/* win9x and win2k behave differently here, don't check result */
|
|
FinishNotificationThread(thread);
|
|
|
|
/* What if we remove the directory we registered notification for? */
|
|
thread = StartNotificationThread(dirname2, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
|
|
ret = RemoveDirectoryA(dirname2);
|
|
ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
|
|
/* win9x and win2k behave differently here, don't check result */
|
|
FinishNotificationThread(thread);
|
|
|
|
/* functional checks */
|
|
|
|
/* Create a directory */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
|
|
ret = CreateDirectoryA(dirname1, NULL);
|
|
ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* Rename a directory */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
|
|
ret = MoveFileA(dirname1, dirname2);
|
|
ok(ret, "MoveFileA error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* Delete a directory */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_DIR_NAME);
|
|
ret = RemoveDirectoryA(dirname2);
|
|
ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
lstrcpyA(filename2, filename1);
|
|
lstrcatA(filename2, "new");
|
|
|
|
/* Rename a file */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ret = MoveFileA(filename1, filename2);
|
|
ok(ret, "MoveFileA error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* Delete a file */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ret = DeleteFileA(filename2);
|
|
ok(ret, "DeleteFileA error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* Create a file */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
file = CreateFileA(filename2, GENERIC_WRITE|GENERIC_READ, 0, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
|
|
ret = CloseHandle(file);
|
|
ok( ret, "CloseHandle error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
attributes = GetFileAttributesA(filename2);
|
|
ok(attributes != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA error: %d\n", GetLastError());
|
|
attributes &= FILE_ATTRIBUTE_READONLY;
|
|
|
|
/* Change file attributes */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_ATTRIBUTES);
|
|
ret = SetFileAttributesA(filename2, attributes);
|
|
ok(ret, "SetFileAttributesA error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* Change last write time by writing to a file */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE);
|
|
file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
|
|
memset(buffer, 0, sizeof(buffer));
|
|
ret = WriteFile(file, buffer, sizeof(buffer), &count, NULL);
|
|
ok(ret && count == sizeof(buffer), "WriteFile error: %d\n", GetLastError());
|
|
ret = CloseHandle(file);
|
|
ok( ret, "CloseHandle error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* Change file size by truncating a file */
|
|
thread = StartNotificationThread(workdir, FALSE, FILE_NOTIFY_CHANGE_SIZE);
|
|
file = CreateFileA(filename2, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
ok(file != INVALID_HANDLE_VALUE, "CreateFileA error: %d\n", GetLastError());
|
|
ret = WriteFile(file, buffer, sizeof(buffer) / 2, &count, NULL);
|
|
ok(ret && count == sizeof(buffer) / 2, "WriteFileA error: %d\n", GetLastError());
|
|
ret = CloseHandle(file);
|
|
ok( ret, "CloseHandle error: %d\n", GetLastError());
|
|
ok(FinishNotificationThread(thread), "Missed notification\n");
|
|
|
|
/* clean up */
|
|
|
|
ret = DeleteFileA(filename2);
|
|
ok(ret, "DeleteFileA error: %d\n", GetLastError());
|
|
|
|
ret = RemoveDirectoryA(workdir);
|
|
ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
|
|
}
|
|
|
|
/* this test concentrates more on the wait behaviour of the handle */
|
|
static void test_ffcn(void)
|
|
{
|
|
DWORD filter;
|
|
HANDLE handle;
|
|
LONG r;
|
|
WCHAR path[MAX_PATH], subdir[MAX_PATH];
|
|
static const WCHAR szBoo[] = { '\\','b','o','o',0 };
|
|
static const WCHAR szHoo[] = { '\\','h','o','o',0 };
|
|
|
|
SetLastError(0xdeadbeef);
|
|
r = GetTempPathW( MAX_PATH, path );
|
|
if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
|
|
{
|
|
win_skip("GetTempPathW is not implemented\n");
|
|
return;
|
|
}
|
|
ok( r != 0, "temp path failed\n");
|
|
if (!r)
|
|
return;
|
|
|
|
lstrcatW( path, szBoo );
|
|
lstrcpyW( subdir, path );
|
|
lstrcatW( subdir, szHoo );
|
|
|
|
RemoveDirectoryW( subdir );
|
|
RemoveDirectoryW( path );
|
|
|
|
r = CreateDirectoryW(path, NULL);
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
filter = FILE_NOTIFY_CHANGE_FILE_NAME;
|
|
filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
|
|
|
|
handle = FindFirstChangeNotificationW( path, 1, filter);
|
|
ok( handle != INVALID_HANDLE_VALUE, "invalid handle\n");
|
|
|
|
r = WaitForSingleObject( handle, 0 );
|
|
ok( r == STATUS_TIMEOUT, "should time out\n");
|
|
|
|
r = CreateDirectoryW( subdir, NULL );
|
|
ok( r == TRUE, "failed to create subdir\n");
|
|
|
|
r = WaitForSingleObject( handle, 0 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n");
|
|
|
|
r = WaitForSingleObject( handle, 0 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n");
|
|
|
|
r = FindNextChangeNotification(handle);
|
|
ok( r == TRUE, "find next failed\n");
|
|
|
|
r = WaitForSingleObject( handle, 0 );
|
|
ok( r == STATUS_TIMEOUT, "should time out\n");
|
|
|
|
r = RemoveDirectoryW( subdir );
|
|
ok( r == TRUE, "failed to remove subdir\n");
|
|
|
|
r = WaitForSingleObject( handle, 0 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n");
|
|
|
|
r = WaitForSingleObject( handle, 0 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n");
|
|
|
|
r = FindNextChangeNotification(handle);
|
|
ok( r == TRUE, "find next failed\n");
|
|
|
|
r = FindNextChangeNotification(handle);
|
|
ok( r == TRUE, "find next failed\n");
|
|
|
|
r = FindCloseChangeNotification(handle);
|
|
ok( r == TRUE, "should succeed\n");
|
|
|
|
r = RemoveDirectoryW( path );
|
|
ok( r == TRUE, "failed to remove dir\n");
|
|
}
|
|
|
|
/* this test concentrates on the wait behavior when multiple threads are
|
|
* waiting on a change notification handle. */
|
|
static void test_ffcnMultipleThreads(void)
|
|
{
|
|
LONG r;
|
|
DWORD filter, threadId, status, exitcode;
|
|
HANDLE handles[2];
|
|
char path[MAX_PATH];
|
|
|
|
r = GetTempPathA(MAX_PATH, path);
|
|
ok(r, "GetTempPathA error: %d\n", GetLastError());
|
|
|
|
lstrcatA(path, "ffcnTestMultipleThreads");
|
|
|
|
RemoveDirectoryA(path);
|
|
|
|
r = CreateDirectoryA(path, NULL);
|
|
ok(r, "CreateDirectoryA error: %d\n", GetLastError());
|
|
|
|
filter = FILE_NOTIFY_CHANGE_FILE_NAME;
|
|
filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
|
|
|
|
handles[0] = FindFirstChangeNotificationA(path, FALSE, filter);
|
|
ok(handles[0] != INVALID_HANDLE_VALUE, "FindFirstChangeNotification error: %d\n", GetLastError());
|
|
|
|
/* Test behavior if a waiting thread holds the last reference to a change
|
|
* directory object with an empty wine user APC queue for this thread (bug #7286) */
|
|
|
|
/* Create our notification thread */
|
|
handles[1] = CreateThread(NULL, 0, NotificationThread, handles[0], 0,
|
|
&threadId);
|
|
ok(handles[1] != NULL, "CreateThread error: %d\n", GetLastError());
|
|
|
|
status = WaitForMultipleObjects(2, handles, FALSE, 5000);
|
|
ok(status == WAIT_OBJECT_0 || status == WAIT_OBJECT_0+1, "WaitForMultipleObjects status %d error %d\n", status, GetLastError());
|
|
ok(GetExitCodeThread(handles[1], &exitcode), "Could not retrieve thread exit code\n");
|
|
|
|
/* Clean up */
|
|
r = RemoveDirectoryA( path );
|
|
ok( r == TRUE, "failed to remove dir\n");
|
|
}
|
|
|
|
static BOOL (WINAPI *pReadDirectoryChangesW)(HANDLE,LPVOID,DWORD,BOOL,DWORD,
|
|
LPDWORD,LPOVERLAPPED,LPOVERLAPPED_COMPLETION_ROUTINE);
|
|
|
|
static void test_readdirectorychanges(void)
|
|
{
|
|
HANDLE hdir;
|
|
char buffer[0x1000];
|
|
DWORD fflags, filter = 0, r, dwCount;
|
|
OVERLAPPED ov;
|
|
WCHAR path[MAX_PATH], subdir[MAX_PATH], subsubdir[MAX_PATH];
|
|
static const WCHAR szBoo[] = { '\\','b','o','o',0 };
|
|
static const WCHAR szHoo[] = { '\\','h','o','o',0 };
|
|
static const WCHAR szGa[] = { '\\','h','o','o','\\','g','a',0 };
|
|
PFILE_NOTIFY_INFORMATION pfni;
|
|
|
|
if (!pReadDirectoryChangesW)
|
|
{
|
|
win_skip("ReadDirectoryChangesW is not available\n");
|
|
return;
|
|
}
|
|
|
|
SetLastError(0xdeadbeef);
|
|
r = GetTempPathW( MAX_PATH, path );
|
|
if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
|
|
{
|
|
win_skip("GetTempPathW is not implemented\n");
|
|
return;
|
|
}
|
|
ok( r != 0, "temp path failed\n");
|
|
if (!r)
|
|
return;
|
|
|
|
lstrcatW( path, szBoo );
|
|
lstrcpyW( subdir, path );
|
|
lstrcatW( subdir, szHoo );
|
|
|
|
lstrcpyW( subsubdir, path );
|
|
lstrcatW( subsubdir, szGa );
|
|
|
|
RemoveDirectoryW( subsubdir );
|
|
RemoveDirectoryW( subdir );
|
|
RemoveDirectoryW( path );
|
|
|
|
r = CreateDirectoryW(path, NULL);
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
SetLastError(0xd0b00b00);
|
|
r = pReadDirectoryChangesW(NULL,NULL,0,FALSE,0,NULL,NULL,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
|
|
hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
|
|
OPEN_EXISTING, fflags, NULL);
|
|
ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
|
|
|
|
ov.hEvent = CreateEvent( NULL, 1, 0, NULL );
|
|
|
|
SetLastError(0xd0b00b00);
|
|
r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,0,NULL,NULL,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
SetLastError(0xd0b00b00);
|
|
r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,0,NULL,&ov,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
filter = FILE_NOTIFY_CHANGE_FILE_NAME;
|
|
filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
|
|
filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
|
|
filter |= FILE_NOTIFY_CHANGE_SIZE;
|
|
filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
|
|
filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
|
|
filter |= FILE_NOTIFY_CHANGE_CREATION;
|
|
filter |= FILE_NOTIFY_CHANGE_SECURITY;
|
|
|
|
SetLastError(0xd0b00b00);
|
|
ov.Internal = 0;
|
|
ov.InternalHigh = 0;
|
|
memset( buffer, 0, sizeof buffer );
|
|
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,-1,NULL,&ov,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,&ov,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,TRUE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 10 );
|
|
ok( r == STATUS_TIMEOUT, "should timeout\n" );
|
|
|
|
r = CreateDirectoryW( subdir, NULL );
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "event should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
|
|
|
|
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
|
|
ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
|
|
ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
|
|
ok( pfni->FileNameLength == 6, "len wrong\n" );
|
|
ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
|
|
|
|
ResetEvent(ov.hEvent);
|
|
SetLastError(0xd0b00b00);
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,NULL,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,0,NULL,&ov,NULL);
|
|
ok(GetLastError()==ERROR_INVALID_PARAMETER,"last error wrong\n");
|
|
ok(r==FALSE, "should return false\n");
|
|
|
|
filter = FILE_NOTIFY_CHANGE_SIZE;
|
|
|
|
SetEvent(ov.hEvent);
|
|
ov.Internal = 1;
|
|
ov.InternalHigh = 1;
|
|
S(U(ov)).Offset = 0;
|
|
S(U(ov)).OffsetHigh = 0;
|
|
memset( buffer, 0, sizeof buffer );
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
ok( ov.Internal == STATUS_PENDING, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 1, "ov.InternalHigh wrong\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 0 );
|
|
ok( r == STATUS_TIMEOUT, "should timeout\n" );
|
|
|
|
r = RemoveDirectoryW( subdir );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
|
|
|
|
if (ov.Internal == STATUS_SUCCESS)
|
|
{
|
|
r = GetOverlappedResult( hdir, &ov, &dwCount, TRUE );
|
|
ok( r == TRUE, "getoverlappedresult failed\n");
|
|
ok( dwCount == 0x12, "count wrong\n");
|
|
}
|
|
|
|
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
|
|
ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
|
|
ok( pfni->Action == FILE_ACTION_REMOVED, "action wrong\n" );
|
|
ok( pfni->FileNameLength == 6, "len wrong\n" );
|
|
ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
|
|
|
|
/* what happens if the buffer is too small? */
|
|
r = pReadDirectoryChangesW(hdir,buffer,0x10,FALSE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = CreateDirectoryW( subdir, NULL );
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
|
|
|
|
/* test the recursive watch */
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = CreateDirectoryW( subsubdir, NULL );
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0x18, "ov.InternalHigh wrong\n");
|
|
|
|
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
|
|
ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
|
|
ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
|
|
ok( pfni->FileNameLength == 6*sizeof(WCHAR), "len wrong\n" );
|
|
ok( !memcmp(pfni->FileName,&szGa[1],6*sizeof(WCHAR)), "name wrong\n" );
|
|
|
|
r = RemoveDirectoryW( subsubdir );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
|
|
ov.Internal = 1;
|
|
ov.InternalHigh = 1;
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = RemoveDirectoryW( subdir );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n" );
|
|
|
|
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
|
|
/* we may get a notification for the parent dir too */
|
|
if (pfni->Action == FILE_ACTION_MODIFIED && pfni->NextEntryOffset)
|
|
{
|
|
ok( pfni->FileNameLength == 3*sizeof(WCHAR), "len wrong %u\n", pfni->FileNameLength );
|
|
ok( !memcmp(pfni->FileName,&szGa[1],3*sizeof(WCHAR)), "name wrong\n" );
|
|
pfni = (PFILE_NOTIFY_INFORMATION)((char *)pfni + pfni->NextEntryOffset);
|
|
}
|
|
ok( pfni->NextEntryOffset == 0, "offset wrong %u\n", pfni->NextEntryOffset );
|
|
ok( pfni->Action == FILE_ACTION_REMOVED, "action wrong %u\n", pfni->Action );
|
|
ok( pfni->FileNameLength == 6*sizeof(WCHAR), "len wrong %u\n", pfni->FileNameLength );
|
|
ok( !memcmp(pfni->FileName,&szGa[1],6*sizeof(WCHAR)), "name wrong\n" );
|
|
|
|
ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
|
|
dwCount = (char *)&pfni->FileName[pfni->FileNameLength/sizeof(WCHAR)] - buffer;
|
|
ok( ov.InternalHigh == dwCount, "ov.InternalHigh wrong %lu/%u\n",ov.InternalHigh, dwCount );
|
|
|
|
CloseHandle(hdir);
|
|
|
|
r = RemoveDirectoryW( path );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
}
|
|
|
|
/* show the behaviour when a null buffer is passed */
|
|
static void test_readdirectorychanges_null(void)
|
|
{
|
|
NTSTATUS r;
|
|
HANDLE hdir;
|
|
char buffer[0x1000];
|
|
DWORD fflags, filter = 0;
|
|
OVERLAPPED ov;
|
|
WCHAR path[MAX_PATH], subdir[MAX_PATH];
|
|
static const WCHAR szBoo[] = { '\\','b','o','o',0 };
|
|
static const WCHAR szHoo[] = { '\\','h','o','o',0 };
|
|
PFILE_NOTIFY_INFORMATION pfni;
|
|
|
|
if (!pReadDirectoryChangesW)
|
|
{
|
|
win_skip("ReadDirectoryChangesW is not available\n");
|
|
return;
|
|
}
|
|
SetLastError(0xdeadbeef);
|
|
r = GetTempPathW( MAX_PATH, path );
|
|
if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
|
|
{
|
|
win_skip("GetTempPathW is not implemented\n");
|
|
return;
|
|
}
|
|
ok( r != 0, "temp path failed\n");
|
|
if (!r)
|
|
return;
|
|
|
|
lstrcatW( path, szBoo );
|
|
lstrcpyW( subdir, path );
|
|
lstrcatW( subdir, szHoo );
|
|
|
|
RemoveDirectoryW( subdir );
|
|
RemoveDirectoryW( path );
|
|
|
|
r = CreateDirectoryW(path, NULL);
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
|
|
hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
|
|
OPEN_EXISTING, fflags, NULL);
|
|
ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
|
|
|
|
ov.hEvent = CreateEvent( NULL, 1, 0, NULL );
|
|
|
|
filter = FILE_NOTIFY_CHANGE_FILE_NAME;
|
|
filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
|
|
|
|
SetLastError(0xd0b00b00);
|
|
ov.Internal = 0;
|
|
ov.InternalHigh = 0;
|
|
memset( buffer, 0, sizeof buffer );
|
|
|
|
r = pReadDirectoryChangesW(hdir,NULL,0,FALSE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 0 );
|
|
ok( r == STATUS_TIMEOUT, "should timeout\n" );
|
|
|
|
r = CreateDirectoryW( subdir, NULL );
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 0 );
|
|
ok( r == WAIT_OBJECT_0, "event should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
|
|
|
|
ov.Internal = 0;
|
|
ov.InternalHigh = 0;
|
|
S(U(ov)).Offset = 0;
|
|
S(U(ov)).OffsetHigh = 0;
|
|
memset( buffer, 0, sizeof buffer );
|
|
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,FALSE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 0 );
|
|
ok( r == STATUS_TIMEOUT, "should timeout\n" );
|
|
|
|
r = RemoveDirectoryW( subdir );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_NOTIFY_ENUM_DIR, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0, "ov.InternalHigh wrong\n");
|
|
|
|
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
|
|
ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
|
|
|
|
CloseHandle(hdir);
|
|
|
|
r = RemoveDirectoryW( path );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
}
|
|
|
|
static void test_readdirectorychanges_filedir(void)
|
|
{
|
|
NTSTATUS r;
|
|
HANDLE hdir, hfile;
|
|
char buffer[0x1000];
|
|
DWORD fflags, filter = 0;
|
|
OVERLAPPED ov;
|
|
WCHAR path[MAX_PATH], subdir[MAX_PATH], file[MAX_PATH];
|
|
static const WCHAR szBoo[] = { '\\','b','o','o',0 };
|
|
static const WCHAR szHoo[] = { '\\','h','o','o',0 };
|
|
static const WCHAR szFoo[] = { '\\','f','o','o',0 };
|
|
PFILE_NOTIFY_INFORMATION pfni;
|
|
|
|
SetLastError(0xdeadbeef);
|
|
r = GetTempPathW( MAX_PATH, path );
|
|
if (!r && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
|
|
{
|
|
win_skip("GetTempPathW is not implemented\n");
|
|
return;
|
|
}
|
|
ok( r != 0, "temp path failed\n");
|
|
if (!r)
|
|
return;
|
|
|
|
lstrcatW( path, szBoo );
|
|
lstrcpyW( subdir, path );
|
|
lstrcatW( subdir, szHoo );
|
|
|
|
lstrcpyW( file, path );
|
|
lstrcatW( file, szFoo );
|
|
|
|
DeleteFileW( file );
|
|
RemoveDirectoryW( subdir );
|
|
RemoveDirectoryW( path );
|
|
|
|
r = CreateDirectoryW(path, NULL);
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
|
|
hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE|FILE_LIST_DIRECTORY,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
|
|
OPEN_EXISTING, fflags, NULL);
|
|
ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
|
|
|
|
ov.hEvent = CreateEvent( NULL, 0, 0, NULL );
|
|
|
|
filter = FILE_NOTIFY_CHANGE_FILE_NAME;
|
|
|
|
r = pReadDirectoryChangesW(hdir,buffer,sizeof buffer,TRUE,filter,NULL,&ov,NULL);
|
|
ok(r==TRUE, "should return true\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 10 );
|
|
ok( r == WAIT_TIMEOUT, "should timeout\n" );
|
|
|
|
r = CreateDirectoryW( subdir, NULL );
|
|
ok( r == TRUE, "failed to create directory\n");
|
|
|
|
hfile = CreateFileW( file, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL );
|
|
ok( hfile != INVALID_HANDLE_VALUE, "failed to create file\n");
|
|
ok( CloseHandle(hfile), "failed toc lose file\n");
|
|
|
|
r = WaitForSingleObject( ov.hEvent, 1000 );
|
|
ok( r == WAIT_OBJECT_0, "event should be ready\n" );
|
|
|
|
ok( ov.Internal == STATUS_SUCCESS, "ov.Internal wrong\n");
|
|
ok( ov.InternalHigh == 0x12, "ov.InternalHigh wrong\n");
|
|
|
|
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
|
|
ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
|
|
ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
|
|
ok( pfni->FileNameLength == 6, "len wrong\n" );
|
|
ok( !memcmp(pfni->FileName,&szFoo[1],6), "name wrong\n" );
|
|
|
|
r = DeleteFileW( file );
|
|
ok( r == TRUE, "failed to delete file\n");
|
|
|
|
r = RemoveDirectoryW( subdir );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
|
|
CloseHandle(hdir);
|
|
|
|
r = RemoveDirectoryW( path );
|
|
ok( r == TRUE, "failed to remove directory\n");
|
|
}
|
|
|
|
static void test_ffcn_directory_overlap(void)
|
|
{
|
|
HANDLE parent_watch, child_watch, parent_thread, child_thread;
|
|
char workdir[MAX_PATH], parentdir[MAX_PATH], childdir[MAX_PATH];
|
|
char tempfile[MAX_PATH];
|
|
DWORD threadId;
|
|
BOOL ret;
|
|
|
|
/* Setup directory hierarchy */
|
|
ret = GetTempPathA(MAX_PATH, workdir);
|
|
ok((ret > 0) && (ret <= MAX_PATH),
|
|
"GetTempPathA error: %d\n", GetLastError());
|
|
|
|
ret = GetTempFileNameA(workdir, "fcn", 0, tempfile);
|
|
ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
|
|
ret = DeleteFileA(tempfile);
|
|
ok(ret, "DeleteFileA error: %d\n", GetLastError());
|
|
|
|
lstrcpyA(parentdir, tempfile);
|
|
ret = CreateDirectoryA(parentdir, NULL);
|
|
ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
|
|
|
|
lstrcpyA(childdir, parentdir);
|
|
lstrcatA(childdir, "\\c");
|
|
ret = CreateDirectoryA(childdir, NULL);
|
|
ok(ret, "CreateDirectoryA error: %d\n", GetLastError());
|
|
|
|
|
|
/* When recursively watching overlapping directories, changes in child
|
|
* should trigger notifications for both child and parent */
|
|
parent_thread = StartNotificationThread(parentdir, TRUE,
|
|
FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
child_thread = StartNotificationThread(childdir, TRUE,
|
|
FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
|
|
/* Create a file in child */
|
|
ret = GetTempFileNameA(childdir, "fcn", 0, tempfile);
|
|
ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
|
|
|
|
/* Both watches should trigger */
|
|
ret = FinishNotificationThread(parent_thread);
|
|
ok(ret, "Missed parent notification\n");
|
|
ret = FinishNotificationThread(child_thread);
|
|
ok(ret, "Missed child notification\n");
|
|
|
|
ret = DeleteFileA(tempfile);
|
|
ok(ret, "DeleteFileA error: %d\n", GetLastError());
|
|
|
|
|
|
/* Removing a recursive parent watch should not affect child watches. Doing
|
|
* so used to crash wineserver. */
|
|
parent_watch = FindFirstChangeNotificationA(parentdir, TRUE,
|
|
FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ok(parent_watch != INVALID_HANDLE_VALUE,
|
|
"FindFirstChangeNotification error: %d\n", GetLastError());
|
|
child_watch = FindFirstChangeNotificationA(childdir, TRUE,
|
|
FILE_NOTIFY_CHANGE_FILE_NAME);
|
|
ok(child_watch != INVALID_HANDLE_VALUE,
|
|
"FindFirstChangeNotification error: %d\n", GetLastError());
|
|
|
|
ret = FindCloseChangeNotification(parent_watch);
|
|
ok(ret, "FindCloseChangeNotification error: %d\n", GetLastError());
|
|
|
|
child_thread = CreateThread(NULL, 0, NotificationThread, child_watch, 0,
|
|
&threadId);
|
|
ok(child_thread != NULL, "CreateThread error: %d\n", GetLastError());
|
|
|
|
/* Create a file in child */
|
|
ret = GetTempFileNameA(childdir, "fcn", 0, tempfile);
|
|
ok(ret, "GetTempFileNameA error: %d\n", GetLastError());
|
|
|
|
/* Child watch should trigger */
|
|
ret = FinishNotificationThread(child_thread);
|
|
ok(ret, "Missed child notification\n");
|
|
|
|
/* clean up */
|
|
ret = DeleteFileA(tempfile);
|
|
ok(ret, "DeleteFileA error: %d\n", GetLastError());
|
|
|
|
ret = RemoveDirectoryA(childdir);
|
|
ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
|
|
|
|
ret = RemoveDirectoryA(parentdir);
|
|
ok(ret, "RemoveDirectoryA error: %d\n", GetLastError());
|
|
}
|
|
|
|
START_TEST(change)
|
|
{
|
|
HMODULE hkernel32 = GetModuleHandle("kernel32");
|
|
pReadDirectoryChangesW = (void *)GetProcAddress(hkernel32, "ReadDirectoryChangesW");
|
|
|
|
test_ffcnMultipleThreads();
|
|
/* The above function runs a test that must occur before FindCloseChangeNotification is run in the
|
|
current thread to preserve the emptiness of the wine user APC queue. To ensure this it should be
|
|
placed first. */
|
|
test_FindFirstChangeNotification();
|
|
test_ffcn();
|
|
test_readdirectorychanges();
|
|
test_readdirectorychanges_null();
|
|
test_readdirectorychanges_filedir();
|
|
test_ffcn_directory_overlap();
|
|
}
|