ReactOS 0.4.15-dev-7897-g78dc504
file.c File Reference
#include "precomp.h"
#include <time.h>
#include <fileapi.h>
Include dependency graph for file.c:

Go to the source code of this file.

Classes

struct  test_list
 

Macros

#define IsDotDir(x)   ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
 
#define PATTERN_OFFSET   0x10
 
#define M(x)   {x, # x}
 
#define CHECK_NAME(fn)   (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
 
#define CHECK_LEVEL(fn)   (level != FindExInfoBasic || !(fn)[0])
 

Functions

static HANDLE (WINAPI *pFindFirstFileExA)(LPCSTR
 
static BOOL (WINAPI *pReplaceFileA)(LPCSTR
 
static UINT (WINAPI *pGetSystemWindowsDirectoryA)(LPSTR
 
static DWORD (WINAPI *pQueueUserAPC)(PAPCFUNC pfnAPC
 
static HRESULT (WINAPI *pCopyFile2)(PCWSTR
 
static NTSTATUS (WINAPI *pNtCreateFile)(PHANDLE
 
static void (WINAPI *pRtlInitAnsiString)(PANSI_STRING
 
static void InitFunctionPointers (void)
 
static void test__hread (void)
 
static void test__hwrite (void)
 
static void test__lclose (void)
 
static void get_nt_pathW (const char *name, UNICODE_STRING *nameW)
 
static void test__lcreat (void)
 
static void test__llseek (void)
 
static void test__llopen (void)
 
static void test__lread (void)
 
static void test__lwrite (void)
 
static void test_CopyFileA (void)
 
static void test_CopyFileW (void)
 
static void test_CopyFile2 (void)
 
static DWORD WINAPI copy_progress_cb (LARGE_INTEGER total_size, LARGE_INTEGER total_transferred, LARGE_INTEGER stream_size, LARGE_INTEGER stream_transferred, DWORD stream, DWORD reason, HANDLE source, HANDLE dest, LPVOID userdata)
 
static void test_CopyFileEx (void)
 
static void dumpmem (unsigned char *mem, int len)
 
static void test_CreateFileA (void)
 
static void test_CreateFileW (void)
 
static void test_CreateFile2 (void)
 
static void test_GetTempFileNameA (void)
 
static void test_DeleteFileA (void)
 
static void test_DeleteFileW (void)
 
static void test_MoveFileA (void)
 
static void test_MoveFileW (void)
 
static void test_offset_in_overlapped_structure (void)
 
static void test_LockFile (void)
 
static BOOL create_fake_dll (LPCSTR filename)
 
static unsigned int map_file_access (unsigned int access)
 
static BOOL is_sharing_compatible (DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2)
 
static BOOL is_sharing_map_compatible (DWORD map_access, DWORD access2, DWORD sharing2)
 
static void test_file_sharing (void)
 
static char get_windows_drive (void)
 
static void test_FindFirstFileA (void)
 
static void test_FindNextFileA (void)
 
static void test_FindFirstFileExA (FINDEX_INFO_LEVELS level, FINDEX_SEARCH_OPS search_ops, DWORD flags)
 
static void test_FindFirstFile_wildcards (void)
 
static int test_Mapfile_createtemp (HANDLE *handle)
 
static void test_MapFile (void)
 
static void test_GetFileType (void)
 
static void CALLBACK FileIOComplete (DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
 
static void test_async_file_errors (void)
 
static void CALLBACK user_apc (ULONG_PTR param)
 
static void test_read_write (void)
 
static void test_OpenFile (void)
 
static void test_overlapped (void)
 
static void test_RemoveDirectory (void)
 
static BOOL check_file_time (const FILETIME *ft1, const FILETIME *ft2, UINT tolerance)
 
static void test_ReplaceFileA (void)
 
static void test_ReplaceFileW (void)
 
static void test_CreateFile (void)
 
static void test_GetFileInformationByHandleEx (void)
 
static void test_OpenFileById (void)
 
static void test_SetFileValidData (void)
 
static void test_WriteFileGather (void)
 
static unsigned file_map_access (unsigned access)
 
static BOOL is_access_compatible (unsigned obj_access, unsigned desired_access)
 
static void test_file_access (void)
 
static void test_GetFinalPathNameByHandleA (void)
 
static void test_GetFinalPathNameByHandleW (void)
 
static void test_SetFileInformationByHandle (void)
 
static void test_GetFileAttributesExW (void)
 
 START_TEST (file)
 

Variables

static FINDEX_INFO_LEVELS
 
static LPVOID
 
static FINDEX_SEARCH_OPS
 
static DWORD
 
static LPCSTR
 
static LPCWSTR
 
static UINT
 
static LPSTR
 
static HANDLE hThread
 
static HANDLE ULONG_PTR dwData
 
static FILE_INFO_BY_HANDLE_CLASS
 
static LPFILE_ID_DESCRIPTOR
 
static LPSECURITY_ATTRIBUTES
 
static LONGLONG
 
static PCWSTR
 
static LPWSTR
 
static ACCESS_MASK
 
static POBJECT_ATTRIBUTES
 
static PIO_STATUS_BLOCK
 
static PLARGE_INTEGER
 
static ULONG
 
static PVOID
 
static PUNICODE_STRING
 
static PWSTR CURDIR *static PCANSI_STRING
 
static PWSTR CURDIR *static BOOLEAN
 
static PCSZ
 
static char filename [MAX_PATH]
 
static const char sillytext []
 
struct {
   const char *   path
 
   BOOL   expected
 
invalid_char_tests []
 
static int completion_count
 
static BOOL user_apc_ran
 

Macro Definition Documentation

◆ CHECK_LEVEL

#define CHECK_LEVEL (   fn)    (level != FindExInfoBasic || !(fn)[0])

◆ CHECK_NAME

#define CHECK_NAME (   fn)    (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)

◆ IsDotDir

#define IsDotDir (   x)    ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))

Definition at line 1853 of file file.c.

◆ M

#define M (   x)    {x, # x}

◆ PATTERN_OFFSET

#define PATTERN_OFFSET   0x10

Definition at line 2004 of file file.c.

Function Documentation

◆ BOOL()

static BOOL ( WINAPI pReplaceFileA)
static

◆ check_file_time()

static BOOL check_file_time ( const FILETIME ft1,
const FILETIME ft2,
UINT  tolerance 
)
static

Definition at line 3585 of file file.c.

3586{
3587 ULONGLONG t1 = ((ULONGLONG)ft1->dwHighDateTime << 32) | ft1->dwLowDateTime;
3588 ULONGLONG t2 = ((ULONGLONG)ft2->dwHighDateTime << 32) | ft2->dwLowDateTime;
3589 return abs(t1 - t2) <= tolerance;
3590}
#define abs(i)
Definition: fconv.c:206
DWORD dwHighDateTime
Definition: mapidefs.h:66
DWORD dwLowDateTime
Definition: mapidefs.h:65
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by test_ReplaceFileA().

◆ copy_progress_cb()

static DWORD WINAPI copy_progress_cb ( LARGE_INTEGER  total_size,
LARGE_INTEGER  total_transferred,
LARGE_INTEGER  stream_size,
LARGE_INTEGER  stream_transferred,
DWORD  stream,
DWORD  reason,
HANDLE  source,
HANDLE  dest,
LPVOID  userdata 
)
static

Definition at line 1111 of file file.c.

1114{
1115 ok(reason == CALLBACK_STREAM_SWITCH, "expected CALLBACK_STREAM_SWITCH, got %u\n", reason);
1116 CloseHandle(userdata);
1117 return PROGRESS_CANCEL;
1118}
#define ok(value,...)
Definition: atltest.h:57
static WCHAR reason[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1904
#define CloseHandle
Definition: compat.h:739
#define PROGRESS_CANCEL
Definition: winbase.h:147
#define CALLBACK_STREAM_SWITCH
Definition: winbase.h:151

Referenced by test_CopyFileEx().

◆ create_fake_dll()

static BOOL create_fake_dll ( LPCSTR  filename)
static

Definition at line 2209 of file file.c.

2210{
2214 BYTE *buffer;
2215 DWORD lfanew = sizeof(*dos);
2216 DWORD size = lfanew + sizeof(*nt) + sizeof(*sec);
2217 DWORD written;
2218 BOOL ret;
2219
2221 if (file == INVALID_HANDLE_VALUE) return FALSE;
2222
2224
2227 dos->e_cblp = sizeof(*dos);
2228 dos->e_cp = 1;
2229 dos->e_cparhdr = lfanew / 16;
2230 dos->e_minalloc = 0;
2231 dos->e_maxalloc = 0xffff;
2232 dos->e_ss = 0x0000;
2233 dos->e_sp = 0x00b8;
2234 dos->e_lfarlc = lfanew;
2235 dos->e_lfanew = lfanew;
2236
2237 nt = (IMAGE_NT_HEADERS *)(buffer + lfanew);
2239#if defined __i386__
2241#elif defined __x86_64__
2243#elif defined __powerpc__
2245#elif defined __arm__
2247#elif defined __aarch64__
2249#else
2250# error You must specify the machine type
2251#endif
2258 nt->OptionalHeader.ImageBase = 0x10000000;
2267 nt->OptionalHeader.SizeOfImage = 0x2000;
2271
2272 sec = (IMAGE_SECTION_HEADER *)(nt + 1);
2273 memcpy( sec->Name, ".rodata", sizeof(".rodata") );
2274 sec->Misc.VirtualSize = 0x1000;
2275 sec->VirtualAddress = 0x1000;
2276 sec->SizeOfRawData = 0;
2277 sec->PointerToRawData = 0;
2279
2280 ret = WriteFile( file, buffer, size, &written, NULL ) && written == size;
2282 CloseHandle( file );
2283 return ret;
2284}
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define IMAGE_FILE_MACHINE_ARMNT
Definition: compat.h:127
#define GetProcessHeap()
Definition: compat.h:736
#define IMAGE_FILE_MACHINE_POWERPC
Definition: compat.h:128
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
#define GENERIC_READ
Definition: compat.h:135
#define HeapFree(x, y, z)
Definition: compat.h:735
#define IMAGE_FILE_MACHINE_ARM64
Definition: compat.h:129
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES
Definition: ntddk_ex.h:135
GLsizeiptr size
Definition: glext.h:5919
GLuint buffer
Definition: glext.h:5915
const char * filename
Definition: ioapi.h:137
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define CREATE_ALWAYS
Definition: disk.h:72
IMAGE_NT_HEADERS nt
Definition: module.c:50
IMAGE_DOS_HEADER dos
Definition: module.c:49
#define GENERIC_WRITE
Definition: nt_native.h:90
#define IMAGE_SCN_MEM_WRITE
Definition: ntimage.h:241
#define IMAGE_SUBSYSTEM_WINDOWS_GUI
Definition: ntimage.h:437
#define IMAGE_FILE_MACHINE_AMD64
Definition: ntimage.h:17
#define IMAGE_SCN_MEM_READ
Definition: ntimage.h:240
#define IMAGE_NT_OPTIONAL_HDR_MAGIC
Definition: ntimage.h:387
#define IMAGE_FILE_EXECUTABLE_IMAGE
Definition: pedump.c:160
#define IMAGE_FILE_MACHINE_I386
Definition: pedump.c:174
struct _IMAGE_OPTIONAL_HEADER IMAGE_OPTIONAL_HEADER
#define IMAGE_NT_SIGNATURE
Definition: pedump.c:93
#define IMAGE_FILE_DLL
Definition: pedump.c:169
#define IMAGE_DOS_SIGNATURE
Definition: pedump.c:89
WORD SizeOfOptionalHeader
Definition: ntddk_ex.h:127
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
WORD MinorOperatingSystemVersion
Definition: ntddk_ex.h:161
WORD MajorOperatingSystemVersion
Definition: ntddk_ex.h:160
DWORD PointerToRawData
Definition: pedump.c:290
union _IMAGE_SECTION_HEADER::@1556 Misc
BYTE Name[IMAGE_SIZEOF_SHORT_NAME]
Definition: pedump.c:281
Definition: fci.c:127
int ret
unsigned char BYTE
Definition: xxhash.c:193

Referenced by test_file_sharing().

◆ dumpmem()

static void dumpmem ( unsigned char mem,
int  len 
)
static

Definition at line 1165 of file file.c.

1166{
1167 int x = 0;
1168 char hex[49], *p;
1169 char txt[17], *c;
1170
1171 while (x < len)
1172 {
1173 p = hex;
1174 c = txt;
1175 do {
1176 p += sprintf(p, "%02x ", mem[x]);
1177 *c++ = (mem[x] >= 32 && mem[x] <= 127) ? mem[x] : '.';
1178 } while (++x % 16 && x < len);
1179 *c = '\0';
1180 trace("%04x: %-48s- %s\n", x, hex, txt);
1181 }
1182}
#define trace
Definition: atltest.h:70
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const GLubyte * c
Definition: glext.h:8905
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
int hex(char ch)
#define c
Definition: ke_i.h:80
#define sprintf(buf, format,...)
Definition: sprintf.c:55
Definition: mem.c:156

Referenced by test_CreateFileA().

◆ DWORD()

static DWORD ( WINAPI pQueueUserAPC)
static

◆ file_map_access()

static unsigned file_map_access ( unsigned  access)
static

Definition at line 4487 of file file.c.

4488{
4494}
GLuint GLint GLboolean GLint GLenum access
Definition: glext.h:7866
#define FILE_GENERIC_EXECUTE
Definition: nt_native.h:668
#define GENERIC_ALL
Definition: nt_native.h:92
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
#define FILE_GENERIC_READ
Definition: nt_native.h:653
#define GENERIC_EXECUTE
Definition: nt_native.h:91
#define FILE_GENERIC_WRITE
Definition: nt_native.h:660

Referenced by is_access_compatible().

◆ FileIOComplete()

static void CALLBACK FileIOComplete ( DWORD  dwError,
DWORD  dwBytes,
LPOVERLAPPED  ovl 
)
static

Definition at line 3074 of file file.c.

3075{
3076/* printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
3077 ReleaseSemaphore(ovl->hEvent, 1, NULL);
3079}
static int completion_count
Definition: file.c:3072
HANDLE hEvent
Definition: winbase.h:820
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseSemaphore(IN HANDLE hSemaphore, IN LONG lReleaseCount, IN LPLONG lpPreviousCount)
Definition: synch.c:542

Referenced by test_async_file_errors().

◆ get_nt_pathW()

static void get_nt_pathW ( const char name,
UNICODE_STRING nameW 
)
static

Definition at line 254 of file file.c.

255{
259 BOOLEAN ret;
260
261 pRtlInitAnsiString( &str, name );
262
263 status = pRtlAnsiStringToUnicodeString( &strW, &str, TRUE );
264 ok( !status, "RtlAnsiStringToUnicodeString failed with %08x\n", status );
265
266 ret = pRtlDosPathNameToNtPathName_U( strW.Buffer, nameW, NULL, NULL );
267 ok( ret, "RtlDosPathNameToNtPathName_U failed\n" );
268
269 pRtlFreeUnicodeString( &strW );
270}
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
static const WCHAR nameW[]
Definition: main.c:46
#define TRUE
Definition: types.h:120
WCHAR strW[12]
Definition: clipboard.c:2029
const WCHAR * str
Definition: name.c:39
Definition: ps.c:97

Referenced by test__lcreat().

◆ get_windows_drive()

static char get_windows_drive ( void  )
static

Definition at line 2501 of file file.c.

2502{
2503 char windowsdir[MAX_PATH];
2504 GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
2505 return windowsdir[0];
2506}
#define MAX_PATH
Definition: compat.h:34
UINT WINAPI GetWindowsDirectoryA(OUT LPSTR lpBuffer, IN UINT uSize)
Definition: path.c:2337

Referenced by test_FindFirstFileA(), and test_FindNextFileA().

◆ HANDLE()

static HANDLE ( WINAPI pFindFirstFileExA)
static

◆ HRESULT()

static HRESULT ( WINAPI pCopyFile2)
static

◆ InitFunctionPointers()

static void InitFunctionPointers ( void  )
static

Definition at line 72 of file file.c.

73{
76
77 pNtCreateFile = (void *)GetProcAddress(hntdll, "NtCreateFile");
78 pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
79 pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
80 pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString");
81 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
82
83 pFindFirstFileExA=(void*)GetProcAddress(hkernel32, "FindFirstFileExA");
84 pReplaceFileA=(void*)GetProcAddress(hkernel32, "ReplaceFileA");
85 pReplaceFileW=(void*)GetProcAddress(hkernel32, "ReplaceFileW");
86 pGetSystemWindowsDirectoryA=(void*)GetProcAddress(hkernel32, "GetSystemWindowsDirectoryA");
87 pGetVolumeNameForVolumeMountPointA = (void *) GetProcAddress(hkernel32, "GetVolumeNameForVolumeMountPointA");
88 pQueueUserAPC = (void *) GetProcAddress(hkernel32, "QueueUserAPC");
89 pGetFileInformationByHandleEx = (void *) GetProcAddress(hkernel32, "GetFileInformationByHandleEx");
90 pOpenFileById = (void *) GetProcAddress(hkernel32, "OpenFileById");
91 pSetFileValidData = (void *) GetProcAddress(hkernel32, "SetFileValidData");
92 pCopyFile2 = (void *) GetProcAddress(hkernel32, "CopyFile2");
93 pCreateFile2 = (void *) GetProcAddress(hkernel32, "CreateFile2");
94 pGetFinalPathNameByHandleA = (void *) GetProcAddress(hkernel32, "GetFinalPathNameByHandleA");
95 pGetFinalPathNameByHandleW = (void *) GetProcAddress(hkernel32, "GetFinalPathNameByHandleW");
96 pSetFileInformationByHandle = (void *) GetProcAddress(hkernel32, "SetFileInformationByHandle");
97}
#define GetProcAddress(x, y)
Definition: compat.h:753
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
static HINSTANCE hkernel32
Definition: process.c:66
static HINSTANCE hntdll
Definition: process.c:66

Referenced by START_TEST().

◆ is_access_compatible()

static BOOL is_access_compatible ( unsigned  obj_access,
unsigned  desired_access 
)
static

Definition at line 4496 of file file.c.

4497{
4498 obj_access = file_map_access(obj_access);
4499 desired_access = file_map_access(desired_access);
4500 return (obj_access & desired_access) == desired_access;
4501}
static unsigned file_map_access(unsigned access)
Definition: file.c:4487

Referenced by test_file_access().

◆ is_sharing_compatible()

static BOOL is_sharing_compatible ( DWORD  access1,
DWORD  sharing1,
DWORD  access2,
DWORD  sharing2 
)
static

Definition at line 2295 of file file.c.

2296{
2297 access1 = map_file_access( access1 );
2298 access2 = map_file_access( access2 );
2301
2302 if (!access1) sharing1 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
2303 if (!access2) sharing2 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
2304
2305 if ((access1 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing2 & FILE_SHARE_READ)) return FALSE;
2306 if ((access1 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing2 & FILE_SHARE_WRITE)) return FALSE;
2307 if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return FALSE;
2308 if ((access2 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing1 & FILE_SHARE_READ)) return FALSE;
2309 if ((access2 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing1 & FILE_SHARE_WRITE)) return FALSE;
2310 if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return FALSE;
2311 return TRUE;
2312}
#define FILE_SHARE_READ
Definition: compat.h:136
static unsigned int map_file_access(unsigned int access)
Definition: file.c:2286
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define FILE_READ_DATA
Definition: nt_native.h:628
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
#define FILE_EXECUTE
Definition: nt_native.h:642
#define FILE_APPEND_DATA
Definition: nt_native.h:634
#define DELETE
Definition: nt_native.h:57

Referenced by test_file_sharing().

◆ is_sharing_map_compatible()

static BOOL is_sharing_map_compatible ( DWORD  map_access,
DWORD  access2,
DWORD  sharing2 
)
static

Definition at line 2314 of file file.c.

2315{
2316 if ((map_access == PAGE_READWRITE || map_access == PAGE_EXECUTE_READWRITE) &&
2317 !(sharing2 & FILE_SHARE_WRITE)) return FALSE;
2318 access2 = map_file_access( access2 );
2319 if ((map_access & SEC_IMAGE) && (access2 & FILE_WRITE_DATA)) return FALSE;
2320 return TRUE;
2321}
#define SEC_IMAGE
Definition: mmtypes.h:97
#define PAGE_READWRITE
Definition: nt_native.h:1304
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1308

Referenced by test_file_sharing().

◆ map_file_access()

static unsigned int map_file_access ( unsigned int  access)
static

◆ NTSTATUS()

static NTSTATUS ( WINAPI pNtCreateFile)
static

◆ START_TEST()

START_TEST ( file  )

Definition at line 4906 of file file.c.

4907{
4908 char temp_path[MAX_PATH];
4909 DWORD ret;
4910
4912
4914 ok(ret != 0, "GetTempPath error %u\n", GetLastError());
4915 ret = GetTempFileNameA(temp_path, "tmp", 0, filename);
4916 ok(ret != 0, "GetTempFileName error %u\n", GetLastError());
4918 ok(ret != 0, "DeleteFile error %u\n", GetLastError());
4919
4920 test__hread( );
4921 test__hwrite( );
4922 test__lclose( );
4923 test__lcreat( );
4924 test__llseek( );
4925 test__llopen( );
4926 test__lread( );
4927 test__lwrite( );
4948 /* FindExLimitToDirectories is ignored if the file system doesn't support directory filtering */
4953 test_LockFile();
4956 test_MapFile();
4960 test_OpenFile();
4974}
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
DWORD WINAPI GetTempPathA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2054
UINT WINAPI GetTempFileNameA(IN LPCSTR lpPathName, IN LPCSTR lpPrefixString, IN UINT uUnique, OUT LPSTR lpTempFileName)
Definition: filename.c:26
static void test_ReplaceFileA(void)
Definition: file.c:3592
static void test_FindFirstFileExA(FINDEX_INFO_LEVELS level, FINDEX_SEARCH_OPS search_ops, DWORD flags)
Definition: file.c:2799
static void test_GetFileInformationByHandleEx(void)
Definition: file.c:4023
static void test_ReplaceFileW(void)
Definition: file.c:3806
static void test_DeleteFileA(void)
Definition: file.c:1748
static void test_CreateFileA(void)
Definition: file.c:1184
static void test_FindNextFileA(void)
Definition: file.c:2780
static void test__lcreat(void)
Definition: file.c:272
static void test_OpenFileById(void)
Definition: file.c:4189
static void test_async_file_errors(void)
Definition: file.c:3081
static void test_GetFileType(void)
Definition: file.c:3051
static void test_CopyFile2(void)
Definition: file.c:882
static void test__hwrite(void)
Definition: file.c:146
static void test_MoveFileA(void)
Definition: file.c:1855
static void test_CreateFileW(void)
Definition: file.c:1541
static void test__llopen(void)
Definition: file.c:504
static void test_OpenFile(void)
Definition: file.c:3292
static void test_GetFinalPathNameByHandleA(void)
Definition: file.c:4609
static void test_RemoveDirectory(void)
Definition: file.c:3563
static void test_offset_in_overlapped_structure(void)
Definition: file.c:2006
static void test_WriteFileGather(void)
Definition: file.c:4430
static void test__hread(void)
Definition: file.c:99
static void test_LockFile(void)
Definition: file.c:2079
static void test_CreateFile(void)
Definition: file.c:3890
static void test_FindFirstFile_wildcards(void)
Definition: file.c:2902
static void test_file_access(void)
Definition: file.c:4503
static void test_DeleteFileW(void)
Definition: file.c:1801
static void test__lread(void)
Definition: file.c:544
static void test_file_sharing(void)
Definition: file.c:2323
static void test_GetTempFileNameA(void)
Definition: file.c:1711
static void test_CopyFileA(void)
Definition: file.c:675
static void test_FindFirstFileA(void)
Definition: file.c:2582
static void test_CopyFileEx(void)
Definition: file.c:1120
static void test_CopyFileW(void)
Definition: file.c:847
static void test_GetFinalPathNameByHandleW(void)
Definition: file.c:4696
static void test_MoveFileW(void)
Definition: file.c:1972
static void test_GetFileAttributesExW(void)
Definition: file.c:4882
static void test_overlapped(void)
Definition: file.c:3486
static void test__llseek(void)
Definition: file.c:466
static void test_SetFileValidData(void)
Definition: file.c:4293
static void test_SetFileInformationByHandle(void)
Definition: file.c:4819
static void test_CreateFile2(void)
Definition: file.c:1630
static void test_read_write(void)
Definition: file.c:3130
static void test__lclose(void)
Definition: file.c:233
static void test__lwrite(void)
Definition: file.c:589
static void InitFunctionPointers(void)
Definition: file.c:72
static void test_MapFile(void)
Definition: file.c:3007
char temp_path[MAX_PATH]
Definition: mspatcha.c:123
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
@ FindExSearchLimitToDirectories
Definition: winbase.h:1135
#define FIND_FIRST_EX_LARGE_FETCH
Definition: winbase.h:235
#define FIND_FIRST_EX_CASE_SENSITIVE
Definition: winbase.h:234
@ FindExInfoStandard
Definition: winbase.h:1128
@ FindExInfoBasic
Definition: winbase.h:1129

◆ test__hread()

static void test__hread ( void  )
static

Definition at line 99 of file file.c.

100{
101 HFILE filehandle;
102 char buffer[10000];
103 LONG bytes_read;
104 LONG bytes_wanted;
105 LONG i;
106 BOOL ret;
107
108 SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); /* be sure to remove stale files */
110 filehandle = _lcreat( filename, 0 );
111 if (filehandle == HFILE_ERROR)
112 {
113 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
114 return;
115 }
116
117 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
118
119 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
120
121 filehandle = _lopen( filename, OF_READ );
122
123 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError( ) );
124
125 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
126
127 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
128
129 for (bytes_wanted = 0; bytes_wanted < lstrlenA( sillytext ); bytes_wanted++)
130 {
131 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
132 ok( _hread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
133 for (i = 0; i < bytes_wanted; i++)
134 {
135 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
136 }
137 }
138
139 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
140
142 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
143}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define FILE_BEGIN
Definition: compat.h:761
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:776
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
int WINAPI _lclose(HFILE hFile)
Definition: lfile.c:138
LONG WINAPI _llseek(HFILE hFile, LONG lOffset, int iOrigin)
Definition: lfile.c:149
HFILE WINAPI _lopen(LPCSTR lpPathName, int iReadWrite)
Definition: lfile.c:70
HFILE WINAPI _lcreat(LPCSTR lpPathName, int iAttribute)
Definition: lfile.c:116
long WINAPI _hwrite(HFILE hFile, LPCSTR lpBuffer, long lBytes)
Definition: lfile.c:41
long WINAPI _hread(HFILE hFile, LPVOID lpBuffer, long lBytes)
Definition: lfile.c:20
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
static const char sillytext[]
Definition: file.c:52
long LONG
Definition: pedump.c:60
#define HFILE_ERROR
Definition: winbase.h:111
#define OF_READ
Definition: winbase.h:116
int HFILE
Definition: windef.h:298

Referenced by START_TEST().

◆ test__hwrite()

static void test__hwrite ( void  )
static

Definition at line 146 of file file.c.

147{
148 HFILE filehandle;
149 char buffer[10000];
150 LONG bytes_read;
151 LONG bytes_written;
153 LONG i;
154 char *contents;
155 HLOCAL memory_object;
156 char checksum[1];
157 BOOL ret;
158
159 filehandle = _lcreat( filename, 0 );
160 if (filehandle == HFILE_ERROR)
161 {
162 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
163 return;
164 }
165
166 ok( HFILE_ERROR != _hwrite( filehandle, "", 0 ), "_hwrite complains\n" );
167
168 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
169
170 filehandle = _lopen( filename, OF_READ );
171
172 bytes_read = _hread( filehandle, buffer, 1);
173
174 ok( 0 == bytes_read, "file read size error\n" );
175
176 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
177
178 filehandle = _lopen( filename, OF_READWRITE );
179
180 bytes_written = 0;
181 checksum[0] = '\0';
182 srand( (unsigned)time( NULL ) );
183 for (blocks = 0; blocks < 100; blocks++)
184 {
185 for (i = 0; i < (LONG)sizeof( buffer ); i++)
186 {
187 buffer[i] = rand( );
188 checksum[0] = checksum[0] + buffer[i];
189 }
190 ok( HFILE_ERROR != _hwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
191 bytes_written = bytes_written + sizeof( buffer );
192 }
193
194 ok( HFILE_ERROR != _hwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
195 bytes_written++;
196
197 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
198
199 memory_object = LocalAlloc( LPTR, bytes_written );
200
201 ok( 0 != memory_object, "LocalAlloc fails. (Could be out of memory.)\n" );
202
203 contents = LocalLock( memory_object );
204 ok( NULL != contents, "LocalLock whines\n" );
205
206 filehandle = _lopen( filename, OF_READ );
207
208 contents = LocalLock( memory_object );
209 ok( NULL != contents, "LocalLock whines\n" );
210
211 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
212
213 checksum[0] = '\0';
214 i = 0;
215 do
216 {
217 checksum[0] = checksum[0] + contents[i];
218 i++;
219 }
220 while (i < bytes_written - 1);
221
222 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
223
224 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
225
227 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
228
230}
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LPVOID NTAPI LocalLock(HLOCAL hMem)
Definition: heapmem.c:1616
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
void __cdecl srand(_In_ unsigned int _Seed)
_Check_return_ int __cdecl rand(void)
Definition: rand.c:10
__u16 time
Definition: mkdosfs.c:8
static int blocks
Definition: mkdosfs.c:527
static const char * contents
Definition: parser.c:511
uint32_t ULONG
Definition: typedefs.h:59
#define LPTR
Definition: winbase.h:381
#define OF_READWRITE
Definition: winbase.h:117

Referenced by START_TEST().

◆ test__lclose()

static void test__lclose ( void  )
static

Definition at line 233 of file file.c.

234{
235 HFILE filehandle;
236 BOOL ret;
237
238 filehandle = _lcreat( filename, 0 );
239 if (filehandle == HFILE_ERROR)
240 {
241 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
242 return;
243 }
244
245 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
246
247 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
248
250 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
251}

Referenced by START_TEST().

◆ test__lcreat()

static void test__lcreat ( void  )
static

Definition at line 272 of file file.c.

273{
277 HFILE filehandle;
278 char buffer[10000];
279 WIN32_FIND_DATAA search_results;
280 char slashname[] = "testfi/";
281 int err;
284 BOOL ret;
285
286 filehandle = _lcreat( filename, 0 );
287 if (filehandle == HFILE_ERROR)
288 {
289 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
290 return;
291 }
292
293 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
294
295 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
296
297 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
298
299 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
300
301 find = FindFirstFileA( filename, &search_results );
302 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
303 FindClose( find );
304
306 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError());
307
308 filehandle = _lcreat( filename, 1 ); /* readonly */
309 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
310
311 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write never the less\n" );
312
313 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
314
315 find = FindFirstFileA( filename, &search_results );
316 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
317 FindClose( find );
318
319 SetLastError( 0xdeadbeef );
320 ok( 0 == DeleteFileA( filename ), "shouldn't be able to delete a readonly file\n" );
321 ok( GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError() );
322
323 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
324
325 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file!\n" );
326
327 filehandle = _lcreat( filename, 1 ); /* readonly */
328 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError() );
329 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen(sillytext) ),
330 "_hwrite shouldn't be able to write never the less\n" );
331 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
332
333 find = FindFirstFileA( filename, &search_results );
334 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
335 FindClose( find );
336
338 attr.Length = sizeof(attr);
339 attr.RootDirectory = 0;
340 attr.Attributes = OBJ_CASE_INSENSITIVE;
341 attr.ObjectName = &filenameW;
342 attr.SecurityDescriptor = NULL;
343 attr.SecurityQualityOfService = NULL;
344
345 status = pNtCreateFile( &file, GENERIC_READ | GENERIC_WRITE | DELETE, &attr, &io, NULL, 0,
348 ok( status == STATUS_ACCESS_DENIED, "expected STATUS_ACCESS_DENIED, got %08x\n", status );
349 ok( GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES, "file was deleted\n" );
350
351 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
354 ok( status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08x\n", status );
355
356 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
359 ok( status == STATUS_NOT_A_DIRECTORY, "expected STATUS_NOT_A_DIRECTORY, got %08x\n", status );
360
361 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
365 ok( status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08x\n", status );
366 if (!status) CloseHandle( file );
367
368 pRtlFreeUnicodeString( &filenameW );
369
371 ok( GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES, "file was deleted\n" );
373 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
375 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file\n" );
376
377 filehandle = _lcreat( filename, 2 );
378 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
379
380 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
381
382 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
383
384 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
385
386 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
387
388 find = FindFirstFileA( filename, &search_results );
389 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
390 FindClose( find );
391
393 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
394
395 filehandle = _lcreat( filename, 4 ); /* SYSTEM file */
396 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
397
398 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
399
400 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
401
402 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
403
404 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
405
406 find = FindFirstFileA( filename, &search_results );
407 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
408 FindClose( find );
409
411 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
412
413 filehandle=_lcreat (slashname, 0); /* illegal name */
414 if (HFILE_ERROR==filehandle) {
415 err=GetLastError ();
417 "creating file \"%s\" failed with error %d\n", slashname, err);
418 } else { /* only NT succeeds */
419 _lclose(filehandle);
420 find=FindFirstFileA (slashname, &search_results);
422 {
423 ret = FindClose (find);
424 ok (0 != ret, "FindClose complains (%d)\n", GetLastError ());
425 slashname[strlen(slashname)-1]=0;
426 ok (!strcmp (slashname, search_results.cFileName),
427 "found unexpected name \"%s\"\n", search_results.cFileName);
428 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
429 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
430 search_results.dwFileAttributes);
431 }
432 ret = DeleteFileA( slashname );
433 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
434 }
435
436 filehandle=_lcreat (filename, 8); /* illegal attribute */
437 if (HFILE_ERROR==filehandle)
438 ok (0, "couldn't create volume label \"%s\"\n", filename);
439 else {
440 _lclose(filehandle);
441 find=FindFirstFileA (filename, &search_results);
443 ok (0, "file \"%s\" not found\n", filename);
444 else {
445 const char *name = strrchr(filename, '\\');
446
447 if (name) name++;
448 else name = filename;
449
450 ret = FindClose(find);
451 ok ( 0 != ret, "FindClose complains (%d)\n", GetLastError ());
452 ok (!strcmp (name, search_results.cFileName),
453 "expected \"%s\", got \"%s\"\n", name, search_results.cFileName);
454 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
455 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_COMPRESSED;
456 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
457 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
458 search_results.dwFileAttributes);
459 }
461 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
462 }
463}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define FILE_DIRECTORY_FILE
Definition: constants.h:491
#define FILE_NON_DIRECTORY_FILE
Definition: constants.h:492
#define FILE_DELETE_ON_CLOSE
Definition: constants.h:494
static TAGID TAGID find
Definition: db.cpp:155
#define SetLastError(x)
Definition: compat.h:752
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define ERROR_INVALID_NAME
Definition: compat.h:103
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:636
HANDLE WINAPI FindFirstFileA(IN LPCSTR lpFileName, OUT LPWIN32_FIND_DATAA lpFindFileData)
Definition: find.c:263
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
#define FILE_OPEN
Definition: from_kernel.h:54
#define FILE_OPEN_IF
Definition: from_kernel.h:56
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
static const WCHAR filenameW[]
Definition: amstream.c:41
static char filename[MAX_PATH]
Definition: file.c:51
static void get_nt_pathW(const char *name, UNICODE_STRING *nameW)
Definition: file.c:254
#define todo_wine
Definition: custom.c:79
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK io
Definition: file.c:100
#define FILE_ATTRIBUTE_ARCHIVE
Definition: nt_native.h:706
#define err(...)
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define STATUS_CANNOT_DELETE
Definition: shellext.h:71
Definition: cookie.c:202
#define STATUS_NOT_A_DIRECTORY
Definition: udferr_usr.h:169
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106

Referenced by START_TEST().

◆ test__llopen()

static void test__llopen ( void  )
static

Definition at line 504 of file file.c.

505{
506 HFILE filehandle;
507 UINT bytes_read;
508 char buffer[10000];
509 BOOL ret;
510
511 filehandle = _lcreat( filename, 0 );
512 if (filehandle == HFILE_ERROR)
513 {
514 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
515 return;
516 }
517
518 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
519 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
520
521 filehandle = _lopen( filename, OF_READ );
522 ok( HFILE_ERROR == _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write!\n" );
523 bytes_read = _hread( filehandle, buffer, strlen( sillytext ) );
524 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
525 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
526
527 filehandle = _lopen( filename, OF_READWRITE );
528 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
529 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
530 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
531 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
532
533 filehandle = _lopen( filename, OF_WRITE );
534 ok( HFILE_ERROR == _hread( filehandle, buffer, 1 ), "you should only be able to write this file\n" );
535 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
536 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
537
539 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
540 /* TODO - add tests for the SHARE modes - use two processes to pull this one off */
541}
unsigned int UINT
Definition: ndis.h:50
#define OF_WRITE
Definition: winbase.h:118

Referenced by START_TEST().

◆ test__llseek()

static void test__llseek ( void  )
static

Definition at line 466 of file file.c.

467{
468 INT i;
469 HFILE filehandle;
470 char buffer[1];
471 LONG bytes_read;
472 BOOL ret;
473
474 filehandle = _lcreat( filename, 0 );
475 if (filehandle == HFILE_ERROR)
476 {
477 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
478 return;
479 }
480
481 for (i = 0; i < 400; i++)
482 {
483 ok( _hwrite( filehandle, sillytext, strlen( sillytext ) ) != -1, "_hwrite complains\n" );
484 }
485 ok( _llseek( filehandle, 400 * strlen( sillytext ), FILE_CURRENT ) != -1, "should be able to seek\n" );
486 ok( _llseek( filehandle, 27 + 35 * strlen( sillytext ), FILE_BEGIN ) != -1, "should be able to seek\n" );
487
488 bytes_read = _hread( filehandle, buffer, 1);
489 ok( 1 == bytes_read, "file read size error\n" );
490 ok( buffer[0] == sillytext[27], "_llseek error, it got lost seeking\n" );
491 ok( _llseek( filehandle, -400 * (LONG)strlen( sillytext ), FILE_END ) != -1, "should be able to seek\n" );
492
493 bytes_read = _hread( filehandle, buffer, 1);
494 ok( 1 == bytes_read, "file read size error\n" );
495 ok( buffer[0] == sillytext[0], "_llseek error, it got lost seeking\n" );
496 ok( _llseek( filehandle, 1000000, FILE_END ) != -1, "should be able to seek past file; poor, poor Windows programmers\n" );
497 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
498
500 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
501}
int32_t INT
Definition: typedefs.h:58
#define FILE_END
Definition: winbase.h:114
#define FILE_CURRENT
Definition: winbase.h:113

Referenced by START_TEST().

◆ test__lread()

static void test__lread ( void  )
static

Definition at line 544 of file file.c.

545{
546 HFILE filehandle;
547 char buffer[10000];
548 UINT bytes_read;
549 UINT bytes_wanted;
550 UINT i;
551 BOOL ret;
552
553 filehandle = _lcreat( filename, 0 );
554 if (filehandle == HFILE_ERROR)
555 {
556 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
557 return;
558 }
559
560 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
561
562 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
563
564 filehandle = _lopen( filename, OF_READ );
565
566 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError());
567
568 bytes_read = _lread( filehandle, buffer, 2 * strlen( sillytext ) );
569
570 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
571
572 for (bytes_wanted = 0; bytes_wanted < strlen( sillytext ); bytes_wanted++)
573 {
574 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
575 ok( _lread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
576 for (i = 0; i < bytes_wanted; i++)
577 {
578 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
579 }
580 }
581
582 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
583
585 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
586}
#define _lread(a, b, c)
Definition: kernel32.h:171

Referenced by START_TEST().

◆ test__lwrite()

static void test__lwrite ( void  )
static

Definition at line 589 of file file.c.

590{
591 HFILE filehandle;
592 char buffer[10000];
593 UINT bytes_read;
594 UINT bytes_written;
595 UINT blocks;
596 INT i;
597 char *contents;
598 HLOCAL memory_object;
599 char checksum[1];
600 BOOL ret;
601
602 filehandle = _lcreat( filename, 0 );
603 if (filehandle == HFILE_ERROR)
604 {
605 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
606 return;
607 }
608
609 ok( HFILE_ERROR != _lwrite( filehandle, "", 0 ), "_hwrite complains\n" );
610
611 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
612
613 filehandle = _lopen( filename, OF_READ );
614
615 bytes_read = _hread( filehandle, buffer, 1);
616
617 ok( 0 == bytes_read, "file read size error\n" );
618
619 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
620
621 filehandle = _lopen( filename, OF_READWRITE );
622
623 bytes_written = 0;
624 checksum[0] = '\0';
625 srand( (unsigned)time( NULL ) );
626 for (blocks = 0; blocks < 100; blocks++)
627 {
628 for (i = 0; i < (INT)sizeof( buffer ); i++)
629 {
630 buffer[i] = rand( );
631 checksum[0] = checksum[0] + buffer[i];
632 }
633 ok( HFILE_ERROR != _lwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
634 bytes_written = bytes_written + sizeof( buffer );
635 }
636
637 ok( HFILE_ERROR != _lwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
638 bytes_written++;
639
640 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
641
642 memory_object = LocalAlloc( LPTR, bytes_written );
643
644 ok( 0 != memory_object, "LocalAlloc fails, could be out of memory\n" );
645
646 contents = LocalLock( memory_object );
647 ok( NULL != contents, "LocalLock whines\n" );
648
649 filehandle = _lopen( filename, OF_READ );
650
651 contents = LocalLock( memory_object );
652 ok( NULL != contents, "LocalLock whines\n" );
653
654 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
655
656 checksum[0] = '\0';
657 i = 0;
658 do
659 {
660 checksum[0] += contents[i];
661 i++;
662 }
663 while (i < bytes_written - 1);
664
665 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
666
667 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
668
670 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
671
673}
#define INT
Definition: polytest.cpp:20
UINT WINAPI _lwrite(_In_ HFILE hFile, _In_reads_bytes_(uBytes) LPCCH lpBuffer, _In_ UINT uBytes)

Referenced by START_TEST().

◆ test_async_file_errors()

static void test_async_file_errors ( void  )
static

Definition at line 3081 of file file.c.

3082{
3083 char szFile[MAX_PATH];
3084 HANDLE hSem = CreateSemaphoreW(NULL, 1, 1, NULL);
3085 HANDLE hFile;
3087 OVERLAPPED ovl;
3088 S(U(ovl)).Offset = 0;
3089 S(U(ovl)).OffsetHigh = 0;
3090 ovl.hEvent = hSem;
3091 completion_count = 0;
3092 szFile[0] = '\0';
3093 GetWindowsDirectoryA(szFile, sizeof(szFile)/sizeof(szFile[0])-1-strlen("\\win.ini"));
3094 strcat(szFile, "\\win.ini");
3097 if (hFile == INVALID_HANDLE_VALUE) /* win9x doesn't like FILE_SHARE_DELETE */
3100 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA(%s ...) failed\n", szFile);
3101 while (TRUE)
3102 {
3103 BOOL res;
3104 DWORD count;
3106 ;
3107 res = ReadFileEx(hFile, lpBuffer, 4096, &ovl, FileIOComplete);
3108 /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
3109 if (!res)
3110 break;
3111 if (!GetOverlappedResult(hFile, &ovl, &count, FALSE))
3112 break;
3113 S(U(ovl)).Offset += count;
3114 /* i/o completion routine only called if ReadFileEx returned success.
3115 * we only care about violations of this rule so undo what should have
3116 * been done */
3118 }
3119 ok(completion_count == 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count);
3120 /*printf("Error = %ld\n", GetLastError());*/
3122}
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
#define U(x)
Definition: wordpad.c:45
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
BOOL WINAPI ReadFileEx(IN HANDLE hFile, IN LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead OPTIONAL, IN LPOVERLAPPED lpOverlapped, IN LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
Definition: rw.c:299
#define INFINITE
Definition: serial.h:102
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint res
Definition: glext.h:9613
BOOL WINAPI GetOverlappedResult(IN HANDLE hFile, IN LPOVERLAPPED lpOverlapped, OUT LPDWORD lpNumberOfBytesTransferred, IN BOOL bWait)
Definition: iocompl.c:221
#define FILE_FLAG_OVERLAPPED
Definition: disk.h:46
#define OPEN_ALWAYS
Definition: disk.h:70
static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
Definition: file.c:3074
_In_ HANDLE hFile
Definition: mswsock.h:90
#define S(x)
Definition: test.h:217
DWORD WINAPI WaitForSingleObjectEx(IN HANDLE hHandle, IN DWORD dwMilliseconds, IN BOOL bAlertable)
Definition: synch.c:94
HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes OPTIONAL, IN LONG lInitialCount, IN LONG lMaximumCount, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:444
#define WAIT_IO_COMPLETION
Definition: winbase.h:411

Referenced by START_TEST().

◆ test_CopyFile2()

static void test_CopyFile2 ( void  )
static

Definition at line 882 of file file.c.

883{
884 static const WCHAR doesntexistW[] = {'d','o','e','s','n','t','e','x','i','s','t',0};
885 static const WCHAR prefix[] = {'p','f','x',0};
887 COPYFILE2_EXTENDED_PARAMETERS params;
888 HANDLE hfile, hmapfile;
889 FILETIME ft1, ft2;
890 DWORD ret, len;
891 char buf[10];
892 HRESULT hr;
893
894 if (!pCopyFile2)
895 {
896 skip("CopyFile2 is not available\n");
897 return;
898 }
899
901 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
902 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
903
904 ret = GetTempFileNameW(temp_path, prefix, 0, source);
905 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
906
907 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
908 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
909
910 /* fail if exists */
911 memset(&params, 0, sizeof(params));
912 params.dwSize = sizeof(params);
913 params.dwCopyFlags = COPY_FILE_FAIL_IF_EXISTS;
914
915 SetLastError(0xdeadbeef);
916 hr = pCopyFile2(source, dest, &params);
917 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "CopyFile2: unexpected error 0x%08x\n", hr);
918 ok(GetLastError() == ERROR_FILE_EXISTS, "CopyFile2: last error %d\n", GetLastError());
919
920 /* don't fail if exists */
921 params.dwSize = sizeof(params);
922 params.dwCopyFlags = 0;
923
924 hr = pCopyFile2(source, dest, &params);
925 ok(hr == S_OK, "CopyFile2: error 0x%08x\n", hr);
926
927 /* copying a file to itself must fail */
928 params.dwSize = sizeof(params);
929 params.dwCopyFlags = 0;
930
931 SetLastError(0xdeadbeef);
932 hr = pCopyFile2(source, source, &params);
933 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: copying a file to itself didn't fail, 0x%08x\n", hr);
934 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
935
936 /* make the source have not zero size */
937 hfile = CreateFileW(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
938 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
939 ret = WriteFile(hfile, prefix, sizeof(prefix), &len, NULL );
940 ok(ret && len == sizeof(prefix), "WriteFile error %d\n", GetLastError());
941 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
942
943 /* get the file time and change it to prove the difference */
944 ret = GetFileTime(hfile, NULL, NULL, &ft1);
945 ok(ret, "GetFileTime error %d\n", GetLastError());
946 ft1.dwLowDateTime -= 600000000; /* 60 second */
947 ret = SetFileTime(hfile, NULL, NULL, &ft1);
948 ok(ret, "SetFileTime error %d\n", GetLastError());
949 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
950 CloseHandle(hfile);
951
952 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
953 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
954
955 params.dwSize = sizeof(params);
956 params.dwCopyFlags = COPY_FILE_FAIL_IF_EXISTS;
957
958 SetLastError(0xdeadbeef);
959 hr = pCopyFile2(source, dest, &params);
960 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "CopyFile2: unexpected error 0x%08x\n", hr);
961 ok(GetLastError() == ERROR_FILE_EXISTS, "CopyFile2: last error %d\n", GetLastError());
962
963 params.dwSize = sizeof(params);
964 params.dwCopyFlags = 0;
965 hr = pCopyFile2(source, dest, &params);
966 ok(ret, "CopyFile2: error 0x%08x\n", hr);
967
968 /* copying from a read-locked source fails */
970 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
971
972 params.dwSize = sizeof(params);
973 params.dwCopyFlags = 0;
974 SetLastError(0xdeadbeef);
975 hr = pCopyFile2(source, dest, &params);
976 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
977 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
978
979 /* in addition, the source is opened before the destination */
980 params.dwSize = sizeof(params);
981 params.dwCopyFlags = 0;
982 SetLastError(0xdeadbeef);
983 hr = pCopyFile2(doesntexistW, dest, &params);
984 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
985 ok(GetLastError() == ERROR_FILE_NOT_FOUND, "CopyFile2: last error %d\n", GetLastError());
986 CloseHandle(hfile);
987
988 /* copying from a r+w opened, r shared source succeeds */
990 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
991
992 params.dwSize = sizeof(params);
993 params.dwCopyFlags = 0;
994 hr = pCopyFile2(source, dest, &params);
995 ok(hr == S_OK, "failed 0x%08x\n", hr);
996 CloseHandle(hfile);
997
998 /* copying from a delete-locked source mostly succeeds */
1000 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
1001
1002 params.dwSize = sizeof(params);
1003 params.dwCopyFlags = 0;
1004 hr = pCopyFile2(source, dest, &params);
1005 ok(hr == S_OK, "failed 0x%08x\n", hr);
1006 CloseHandle(hfile);
1007
1008 /* copying to a write-locked destination fails */
1010 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1011
1012 params.dwSize = sizeof(params);
1013 params.dwCopyFlags = 0;
1014 SetLastError(0xdeadbeef);
1015 hr = pCopyFile2(source, dest, FALSE);
1016 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1017 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1018 CloseHandle(hfile);
1019
1020 /* copying to a r+w opened, w shared destination mostly succeeds */
1022 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1023
1024 params.dwSize = sizeof(params);
1025 params.dwCopyFlags = 0;
1026 hr = pCopyFile2(source, dest, FALSE);
1027 ok(hr == S_OK, "got 0x%08x\n", hr);
1028 CloseHandle(hfile);
1029
1030 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
1032 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1033
1034 params.dwSize = sizeof(params);
1035 params.dwCopyFlags = 0;
1036 SetLastError(0xdeadbeef);
1037 hr = pCopyFile2(source, dest, &params);
1038 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1039 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1040 CloseHandle(hfile);
1041
1042 /* copy to a file that's opened the way Wine opens the source */
1044 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1045
1046 params.dwSize = sizeof(params);
1047 params.dwCopyFlags = 0;
1048 hr = pCopyFile2(source, dest, &params);
1049 ok(hr == S_OK, "got 0x%08x\n", hr);
1050 CloseHandle(hfile);
1051
1052 /* make sure that destination has correct size */
1054 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
1055 ret = GetFileSize(hfile, NULL);
1056 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
1057
1058 /* make sure that destination has the same filetime */
1059 ret = GetFileTime(hfile, NULL, NULL, &ft2);
1060 ok(ret, "GetFileTime error %d\n", GetLastError());
1061 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
1062
1063 params.dwSize = sizeof(params);
1064 params.dwCopyFlags = 0;
1065 SetLastError(0xdeadbeef);
1066 hr = pCopyFile2(source, dest, &params);
1067 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1068 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1069
1070 /* make sure that destination still has correct size */
1071 ret = GetFileSize(hfile, NULL);
1072 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
1073 ret = ReadFile(hfile, buf, sizeof(buf), &len, NULL);
1074 ok(ret && len == sizeof(prefix), "ReadFile: error %d\n", GetLastError());
1075 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
1076
1077 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
1078 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1079 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1080
1081 params.dwSize = sizeof(params);
1082 params.dwCopyFlags = 0;
1083 SetLastError(0xdeadbeef);
1084 hr = pCopyFile2(source, dest, &params);
1085 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1086 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1087
1088 CloseHandle(hmapfile);
1089 CloseHandle(hfile);
1090
1092 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
1093
1094 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
1095 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1096 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1097
1098 params.dwSize = sizeof(params);
1099 params.dwCopyFlags = 0;
1100 hr = pCopyFile2(source, dest, &params);
1101 ok(hr == HRESULT_FROM_WIN32(ERROR_USER_MAPPED_FILE), "CopyFile2: unexpected error 0x%08x\n", hr);
1102 ok(GetLastError() == ERROR_USER_MAPPED_FILE, "CopyFile2: last error %d\n", GetLastError());
1103
1104 CloseHandle(hmapfile);
1105 CloseHandle(hfile);
1106
1109}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define skip(...)
Definition: atltest.h:64
#define PAGE_READONLY
Definition: compat.h:138
#define OPEN_EXISTING
Definition: compat.h:775
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
#define CreateFileW
Definition: compat.h:741
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
BOOL WINAPI SetFileTime(IN HANDLE hFile, CONST FILETIME *lpCreationTime OPTIONAL, CONST FILETIME *lpLastAccessTime OPTIONAL, CONST FILETIME *lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:948
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
BOOL WINAPI GetFileTime(IN HANDLE hFile, OUT LPFILETIME lpCreationTime OPTIONAL, OUT LPFILETIME lpLastAccessTime OPTIONAL, OUT LPFILETIME lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:896
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
LONG WINAPI CompareFileTime(IN CONST FILETIME *lpFileTime1, IN CONST FILETIME *lpFileTime2)
Definition: time.c:106
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
GLenum const GLfloat * params
Definition: glext.h:5645
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define S_OK
Definition: intsafe.h:52
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static char * dest
Definition: rtl.c:135
#define SEC_COMMIT
Definition: mmtypes.h:100
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183
#define COPY_FILE_FAIL_IF_EXISTS
Definition: winbase.h:205
#define ERROR_SHARING_VIOLATION
Definition: winerror.h:135
#define ERROR_FILE_EXISTS
Definition: winerror.h:165
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_USER_MAPPED_FILE
Definition: winerror.h:727
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by START_TEST().

◆ test_CopyFileA()

static void test_CopyFileA ( void  )
static

Definition at line 675 of file file.c.

676{
677 char temp_path[MAX_PATH];
679 static const char prefix[] = "pfx";
680 HANDLE hfile;
681 HANDLE hmapfile;
682 FILETIME ft1, ft2;
683 char buf[10];
684 DWORD ret;
685 BOOL retok;
686
688 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
689 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
690
691 ret = GetTempFileNameA(temp_path, prefix, 0, source);
692 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
693
694 /* copying a file to itself must fail */
695 retok = CopyFileA(source, source, FALSE);
696 ok( !retok && (GetLastError() == ERROR_SHARING_VIOLATION || broken(GetLastError() == ERROR_FILE_EXISTS) /* Win 9x */),
697 "copying a file to itself didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
698
699 /* make the source have not zero size */
700 hfile = CreateFileA(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
701 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
702 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
703 ok( retok && ret == sizeof(prefix),
704 "WriteFile error %d\n", GetLastError());
705 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
706 /* get the file time and change it to prove the difference */
707 ret = GetFileTime(hfile, NULL, NULL, &ft1);
708 ok( ret, "GetFileTime error %d\n", GetLastError());
709 ft1.dwLowDateTime -= 600000000; /* 60 second */
710 ret = SetFileTime(hfile, NULL, NULL, &ft1);
711 ok( ret, "SetFileTime error %d\n", GetLastError());
712 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
713 CloseHandle(hfile);
714
715 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
716 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
717
718 SetLastError(0xdeadbeef);
721 "CopyFileA: unexpected error %d\n", GetLastError());
722
724 ok(ret, "CopyFileA: error %d\n", GetLastError());
725
726 /* copying from a read-locked source fails */
728 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
729 retok = CopyFileA(source, dest, FALSE);
731 "copying from a read-locked file succeeded when it shouldn't have\n");
732 /* in addition, the source is opened before the destination */
733 retok = CopyFileA("25f99d3b-4ba4-4f66-88f5-2906886993cc", dest, FALSE);
734 ok(!retok && GetLastError() == ERROR_FILE_NOT_FOUND,
735 "copying from a file that doesn't exist failed in an unexpected way (ret=%d, err=%d)\n", retok, GetLastError());
736 CloseHandle(hfile);
737
738 /* copying from a r+w opened, r shared source succeeds */
740 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
741 retok = CopyFileA(source, dest, FALSE);
742 ok(retok,
743 "copying from an r+w opened and r shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
744 CloseHandle(hfile);
745
746 /* copying from a delete-locked source mostly succeeds */
748 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
749 retok = CopyFileA(source, dest, FALSE);
750 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* NT, 2000, XP */,
751 "copying from a delete-locked file failed (ret=%d, err=%d)\n", retok, GetLastError());
752 CloseHandle(hfile);
753
754 /* copying to a write-locked destination fails */
756 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
757 retok = CopyFileA(source, dest, FALSE);
759 "copying to a write-locked file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
760 CloseHandle(hfile);
761
762 /* copying to a r+w opened, w shared destination mostly succeeds */
764 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
765 retok = CopyFileA(source, dest, FALSE);
766 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
767 "copying to a r+w opened and w shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
768 CloseHandle(hfile);
769
770 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
773 "failed to open destination file, error %d\n", GetLastError());
774 if (hfile != INVALID_HANDLE_VALUE)
775 {
776 retok = CopyFileA(source, dest, FALSE);
778 "copying to a delete-locked shared file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
779 CloseHandle(hfile);
780 }
781
782 /* copy to a file that's opened the way Wine opens the source */
784 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
785 retok = CopyFileA(source, dest, FALSE);
786 ok(retok || broken(GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
787 "copying to a file opened the way Wine opens the source failed (ret=%d, err=%d)\n", retok, GetLastError());
788 CloseHandle(hfile);
789
790 /* make sure that destination has correct size */
792 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
793 ret = GetFileSize(hfile, NULL);
794 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
795
796 /* make sure that destination has the same filetime */
797 ret = GetFileTime(hfile, NULL, NULL, &ft2);
798 ok( ret, "GetFileTime error %d\n", GetLastError());
799 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
800
801 SetLastError(0xdeadbeef);
804 "CopyFileA: ret = %d, unexpected error %d\n", ret, GetLastError());
805
806 /* make sure that destination still has correct size */
807 ret = GetFileSize(hfile, NULL);
808 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
809 retok = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
810 ok( retok && ret == sizeof(prefix),
811 "ReadFile: error %d\n", GetLastError());
812 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
813
814 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
815 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
816 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
817
820 "CopyFileA with mapped dest file: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
821
822 CloseHandle(hmapfile);
823 CloseHandle(hfile);
824
826 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
827
828 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
829 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
830 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
831
833 ok(!ret, "CopyFileA: expected failure\n");
836 "CopyFileA with mapped dest file: expected ERROR_USER_MAPPED_FILE, got %d\n", GetLastError());
837
838 CloseHandle(hmapfile);
839 CloseHandle(hfile);
840
842 ok(ret, "DeleteFileA: error %d\n", GetLastError());
844 ok(ret, "DeleteFileA: error %d\n", GetLastError());
845}
#define broken(x)
Definition: _sntprintf.h:21
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
BOOL WINAPI CopyFileA(IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:404

Referenced by START_TEST().

◆ test_CopyFileEx()

static void test_CopyFileEx ( void  )
static

Definition at line 1120 of file file.c.

1121{
1122 char temp_path[MAX_PATH];
1123 char source[MAX_PATH], dest[MAX_PATH];
1124 static const char prefix[] = "pfx";
1125 HANDLE hfile;
1126 DWORD ret;
1127 BOOL retok;
1128
1130 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1131 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1132
1133 ret = GetTempFileNameA(temp_path, prefix, 0, source);
1134 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1135
1136 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
1137 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1138
1140 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1141 SetLastError(0xdeadbeef);
1142 retok = CopyFileExA(source, dest, copy_progress_cb, hfile, NULL, 0);
1143 ok(!retok, "CopyFileExA unexpectedly succeeded\n");
1144 ok(GetLastError() == ERROR_REQUEST_ABORTED, "expected ERROR_REQUEST_ABORTED, got %d\n", GetLastError());
1145 ok(GetFileAttributesA(dest) != INVALID_FILE_ATTRIBUTES, "file was deleted\n");
1146
1148 NULL, OPEN_EXISTING, 0, 0);
1149 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1150 SetLastError(0xdeadbeef);
1151 retok = CopyFileExA(source, dest, copy_progress_cb, hfile, NULL, 0);
1152 ok(!retok, "CopyFileExA unexpectedly succeeded\n");
1153 ok(GetLastError() == ERROR_REQUEST_ABORTED, "expected ERROR_REQUEST_ABORTED, got %d\n", GetLastError());
1154 ok(GetFileAttributesA(dest) == INVALID_FILE_ATTRIBUTES, "file was not deleted\n");
1155
1157 ok(ret, "DeleteFileA failed with error %d\n", GetLastError());
1158 ret = DeleteFileA(dest);
1159 ok(!ret, "DeleteFileA unexpectedly succeeded\n");
1160}
BOOL WINAPI CopyFileExA(IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName, IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, IN LPVOID lpData OPTIONAL, IN LPBOOL pbCancel OPTIONAL, IN DWORD dwCopyFlags)
Definition: copy.c:366
static DWORD WINAPI copy_progress_cb(LARGE_INTEGER total_size, LARGE_INTEGER total_transferred, LARGE_INTEGER stream_size, LARGE_INTEGER stream_transferred, DWORD stream, DWORD reason, HANDLE source, HANDLE dest, LPVOID userdata)
Definition: file.c:1111
#define ERROR_REQUEST_ABORTED
Definition: winerror.h:738

Referenced by START_TEST().

◆ test_CopyFileW()

static void test_CopyFileW ( void  )
static

Definition at line 847 of file file.c.

848{
851 static const WCHAR prefix[] = {'p','f','x',0};
852 DWORD ret;
853
856 {
857 win_skip("GetTempPathW is not available\n");
858 return;
859 }
860 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
861 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
862
863 ret = GetTempFileNameW(temp_path, prefix, 0, source);
864 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
865
866 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
867 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
868
871 "CopyFileW: unexpected error %d\n", GetLastError());
872
874 ok(ret, "CopyFileW: error %d\n", GetLastError());
875
877 ok(ret, "DeleteFileW: error %d\n", GetLastError());
879 ok(ret, "DeleteFileW: error %d\n", GetLastError());
880}
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
BOOL WINAPI CopyFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:439
#define win_skip
Definition: test.h:160

Referenced by START_TEST().

◆ test_CreateFile()

static void test_CreateFile ( void  )
static

Definition at line 3890 of file file.c.

3891{
3892 static const struct test_data
3893 {
3894 DWORD disposition, access, error, clean_up;
3895 } td[] =
3896 {
3897 /* 0 */ { 0, 0, ERROR_INVALID_PARAMETER, 0 },
3898 /* 1 */ { 0, GENERIC_READ, ERROR_INVALID_PARAMETER, 0 },
3900 /* 3 */ { CREATE_NEW, 0, ERROR_FILE_EXISTS, 1 },
3901 /* 4 */ { CREATE_NEW, 0, 0, 1 },
3902 /* 5 */ { CREATE_NEW, GENERIC_READ, 0, 1 },
3903 /* 6 */ { CREATE_NEW, GENERIC_WRITE, 0, 1 },
3904 /* 7 */ { CREATE_NEW, GENERIC_READ|GENERIC_WRITE, 0, 0 },
3905 /* 8 */ { CREATE_ALWAYS, 0, 0, 0 },
3906 /* 9 */ { CREATE_ALWAYS, GENERIC_READ, 0, 0 },
3907 /* 10*/ { CREATE_ALWAYS, GENERIC_WRITE, 0, 0 },
3908 /* 11*/ { CREATE_ALWAYS, GENERIC_READ|GENERIC_WRITE, 0, 1 },
3909 /* 12*/ { OPEN_EXISTING, 0, ERROR_FILE_NOT_FOUND, 0 },
3910 /* 13*/ { CREATE_ALWAYS, 0, 0, 0 },
3911 /* 14*/ { OPEN_EXISTING, 0, 0, 0 },
3912 /* 15*/ { OPEN_EXISTING, GENERIC_READ, 0, 0 },
3913 /* 16*/ { OPEN_EXISTING, GENERIC_WRITE, 0, 0 },
3914 /* 17*/ { OPEN_EXISTING, GENERIC_READ|GENERIC_WRITE, 0, 1 },
3915 /* 18*/ { OPEN_ALWAYS, 0, 0, 0 },
3916 /* 19*/ { OPEN_ALWAYS, GENERIC_READ, 0, 0 },
3917 /* 20*/ { OPEN_ALWAYS, GENERIC_WRITE, 0, 0 },
3918 /* 21*/ { OPEN_ALWAYS, GENERIC_READ|GENERIC_WRITE, 0, 0 },
3919 /* 22*/ { TRUNCATE_EXISTING, 0, ERROR_INVALID_PARAMETER, 0 },
3921 /* 24*/ { TRUNCATE_EXISTING, GENERIC_WRITE, 0, 0 },
3922 /* 25*/ { TRUNCATE_EXISTING, GENERIC_READ|GENERIC_WRITE, 0, 0 },
3924 };
3925 char temp_path[MAX_PATH];
3926 char file_name[MAX_PATH];
3927 DWORD i, ret, written;
3928 HANDLE hfile;
3929
3932
3933 i = strlen(temp_path);
3934 if (i && temp_path[i - 1] == '\\') temp_path[i - 1] = 0;
3935
3936 for (i = 0; i <= 5; i++)
3937 {
3938 SetLastError(0xdeadbeef);
3939 hfile = CreateFileA(temp_path, GENERIC_READ, 0, NULL, i, 0, 0);
3940 ok(hfile == INVALID_HANDLE_VALUE, "CreateFile should fail\n");
3941 if (i == 0 || i == 5)
3942 {
3943/* FIXME: remove once Wine is fixed */
3944todo_wine_if (i == 5)
3946 }
3947 else
3948 {
3949/* FIXME: remove once Wine is fixed */
3950todo_wine_if (i == 1)
3952 }
3953
3954 SetLastError(0xdeadbeef);
3955 hfile = CreateFileA(temp_path, GENERIC_WRITE, 0, NULL, i, 0, 0);
3956 ok(hfile == INVALID_HANDLE_VALUE, "CreateFile should fail\n");
3957 if (i == 0)
3959 else
3960 {
3961/* FIXME: remove once Wine is fixed */
3962todo_wine_if (i == 1)
3964 }
3965 }
3966
3967 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3968 {
3969 SetLastError(0xdeadbeef);
3970 hfile = CreateFileA(file_name, td[i].access, 0, NULL, td[i].disposition, 0, 0);
3971 if (!td[i].error)
3972 {
3973 ok(hfile != INVALID_HANDLE_VALUE, "%d: CreateFile error %d\n", i, GetLastError());
3974 written = 0xdeadbeef;
3975 SetLastError(0xdeadbeef);
3976 ret = WriteFile(hfile, &td[i].error, sizeof(td[i].error), &written, NULL);
3977 if (td[i].access & GENERIC_WRITE)
3978 ok(ret, "%d: WriteFile error %d\n", i, GetLastError());
3979 else
3980 {
3981 ok(!ret, "%d: WriteFile should fail\n", i);
3982 ok(GetLastError() == ERROR_ACCESS_DENIED, "%d: expected ERROR_ACCESS_DENIED, got %d\n", i, GetLastError());
3983 }
3984 SetLastError(0xdeadbeef);
3985 ret = SetFileTime(hfile, NULL, NULL, NULL);
3986 if (td[i].access & GENERIC_WRITE) /* actually FILE_WRITE_ATTRIBUTES */
3987 ok(ret, "%d: SetFileTime error %d\n", i, GetLastError());
3988 else
3989 {
3990 todo_wine
3991 {
3992 ok(!ret, "%d: SetFileTime should fail\n", i);
3993 ok(GetLastError() == ERROR_ACCESS_DENIED, "%d: expected ERROR_ACCESS_DENIED, got %d\n", i, GetLastError());
3994 }
3995 }
3996 CloseHandle(hfile);
3997 }
3998 else
3999 {
4000 /* FIXME: remove the condition below once Wine is fixed */
4001 if (td[i].disposition == TRUNCATE_EXISTING && !(td[i].access & GENERIC_WRITE))
4002 {
4003 todo_wine
4004 {
4005 ok(hfile == INVALID_HANDLE_VALUE, "%d: CreateFile should fail\n", i);
4006 ok(GetLastError() == td[i].error, "%d: expected %d, got %d\n", i, td[i].error, GetLastError());
4007 }
4008 CloseHandle(hfile);
4009 }
4010 else
4011 {
4012 ok(hfile == INVALID_HANDLE_VALUE, "%d: CreateFile should fail\n", i);
4013 ok(GetLastError() == td[i].error, "%d: expected %d, got %d\n", i, td[i].error, GetLastError());
4014 }
4015 }
4016
4017 if (td[i].clean_up) DeleteFileA(file_name);
4018 }
4019
4021}
GLdouble n
Definition: glext.h:7729
#define d
Definition: ke_i.h:81
if(dx< 0)
Definition: linetemp.h:194
#define error(str)
Definition: mkdosfs.c:1605
#define for
Definition: utility.h:88
#define TRUNCATE_EXISTING
Definition: disk.h:71
#define CREATE_NEW
Definition: disk.h:69
BOOL expected
Definition: file.c:2511
#define todo_wine_if(is_todo)
Definition: custom.c:76
static LPCWSTR file_name
Definition: protocol.c:147
else
Definition: tritemp.h:161
#define CreateFile
Definition: winbase.h:3749
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

Referenced by START_TEST().

◆ test_CreateFile2()

static void test_CreateFile2 ( void  )
static

Definition at line 1630 of file file.c.

1631{
1632 HANDLE hFile;
1636 static const WCHAR emptyW[]={'\0'};
1637 static const WCHAR prefix[] = {'p','f','x',0};
1638 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1639 DWORD ret;
1640
1641 if (!pCreateFile2)
1642 {
1643 win_skip("CreateFile2 is missing\n");
1644 return;
1645 }
1646
1648 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1649 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1650
1651 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1652 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1653
1654 SetLastError(0xdeadbeef);
1655 exparams.dwSize = sizeof(exparams);
1657 exparams.dwFileFlags = 0;
1658 exparams.dwSecurityQosFlags = 0;
1659 exparams.lpSecurityAttributes = NULL;
1660 exparams.hTemplateFile = 0;
1661 hFile = pCreateFile2(filename, GENERIC_READ, 0, CREATE_NEW, &exparams);
1663 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1664
1665 SetLastError(0xdeadbeef);
1666 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, CREATE_ALWAYS, &exparams);
1668 "hFile %p, last error %u\n", hFile, GetLastError());
1670
1671 SetLastError(0xdeadbeef);
1672 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, &exparams);
1674 "hFile %p, last error %u\n", hFile, GetLastError());
1676
1678 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1679
1680 SetLastError(0xdeadbeef);
1681 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, &exparams);
1683 "hFile %p, last error %u\n", hFile, GetLastError());
1685
1687 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1688
1689 hFile = pCreateFile2(emptyW, GENERIC_READ, 0, CREATE_NEW, &exparams);
1691 "CreateFile2(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1692
1693 /* test the result of opening a nonexistent driver name */
1695 hFile = pCreateFile2(bogus, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING, &exparams);
1697 "CreateFile2 on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1698
1700 ok(ret == TRUE, "couldn't create temporary directory\n");
1702 hFile = pCreateFile2(filename, GENERIC_READ | GENERIC_WRITE, 0, OPEN_ALWAYS, &exparams);
1703 todo_wine
1705 "expected CreateFile2 to fail on existing directory, error: %d\n", GetLastError());
1708 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1709}
BOOL WINAPI CreateDirectoryW(IN LPCWSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:90
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732
static const WCHAR emptyW[]
Definition: navigate.c:40
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
#define FILE_FLAG_BACKUP_SEMANTICS
Definition: disk.h:41
#define FILE_FLAG_RANDOM_ACCESS
Definition: disk.h:44
LPSECURITY_ATTRIBUTES lpSecurityAttributes
Definition: fileapi.h:31

Referenced by START_TEST().

◆ test_CreateFileA()

static void test_CreateFileA ( void  )
static

Definition at line 1184 of file file.c.

1185{
1186 HANDLE hFile;
1188 char filename[MAX_PATH];
1189 static const char prefix[] = "pfx";
1190 char windowsdir[MAX_PATH];
1191 char Volume_1[MAX_PATH];
1192 unsigned char buffer[512];
1193 char directory[] = "removeme";
1194 static const char nt_drive[] = "\\\\?\\A:";
1195 DWORD i, ret, len;
1196 static const struct test_list p[] =
1197 {
1198 {"", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dir as file w \ */
1200 {"a", ERROR_FILE_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* non-exist file */
1202 {"removeme", ERROR_ACCESS_DENIED, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* exist dir w/o \ */
1203 {"removeme\\", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* exst dir w \ */
1204 {"c:", ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND, FILE_ATTRIBUTE_NORMAL, FALSE }, /* device in file namespace */
1205 {"c:", ERROR_SUCCESS, ERROR_PATH_NOT_FOUND, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* device in file namespace as dir */
1206 {"c:\\", ERROR_PATH_NOT_FOUND, ERROR_ACCESS_DENIED, FILE_ATTRIBUTE_NORMAL, TRUE }, /* root dir w \ */
1207 {"c:\\", ERROR_SUCCESS, ERROR_ACCESS_DENIED, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* root dir w \ as dir */
1208 {"c:c:\\windows", ERROR_INVALID_NAME, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* invalid path */
1209 {"\\\\?\\c:", ERROR_SUCCESS, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL,FALSE }, /* dev namespace drive */
1210 {"\\\\?\\c:\\", ERROR_PATH_NOT_FOUND, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dev namespace drive w \ */
1211 {NULL, 0, -1, 0, FALSE}
1212 };
1214 WCHAR curdir[MAX_PATH];
1215
1217 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1218 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1219
1220 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
1221 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1222
1223 SetLastError(0xdeadbeef);
1227 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1228
1229 SetLastError(0xdeadbeef);
1233 "hFile %p, last error %u\n", hFile, GetLastError());
1234
1236
1237 SetLastError(0xdeadbeef);
1241 "hFile %p, last error %u\n", hFile, GetLastError());
1242
1244
1246 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1247
1248 SetLastError(0xdeadbeef);
1252 "hFile %p, last error %u\n", hFile, GetLastError());
1253
1255
1257 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1258
1259 SetLastError(0xdeadbeef);
1261 ok(hFile == INVALID_HANDLE_VALUE, "hFile should have been INVALID_HANDLE_VALUE\n");
1263 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* Win98 */
1264 "LastError should have been ERROR_INVALID_NAME or ERROR_FILE_NOT_FOUND but got %u\n", GetLastError());
1265
1266 /* get windows drive letter */
1267 ret = GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
1268 ok(ret < sizeof(windowsdir), "windowsdir is abnormally long!\n");
1269 ok(ret != 0, "GetWindowsDirectory: error %d\n", GetLastError());
1270
1271 /* test error return codes from CreateFile for some cases */
1273 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1277 ok( ret, "Createdirectory failed, gle=%d\n", GetLastError() );
1278 /* set current drive & directory to known location */
1281 i = 0;
1282 while (p[i].file)
1283 {
1284 filename[0] = 0;
1285 /* update the drive id in the table entry with the current one */
1286 if (p[i].file[1] == ':')
1287 {
1288 strcpy(filename, p[i].file);
1289 filename[0] = windowsdir[0];
1290 }
1291 else if (p[i].file[0] == '\\' && p[i].file[5] == ':')
1292 {
1293 strcpy(filename, p[i].file);
1294 filename[4] = windowsdir[0];
1295 }
1296 else
1297 {
1298 /* prefix the table entry with the current temp directory */
1300 strcat(filename, p[i].file);
1301 }
1305 p[i].options, NULL );
1306 /* if we get ACCESS_DENIED when we do not expect it, assume
1307 * no access to the volume
1308 */
1309 if (hFile == INVALID_HANDLE_VALUE &&
1312 {
1313 if (p[i].todo_flag)
1314 skip("Either no authority to volume, or is todo_wine for %s err=%d should be %d\n", filename, GetLastError(), p[i].err);
1315 else
1316 skip("Do not have authority to access volumes. Test for %s skipped\n", filename);
1317 }
1318 /* otherwise validate results with expectations */
1319 else
1320 {
1323 (p[i].err == GetLastError() || p[i].err2 == GetLastError())) ||
1325 "CreateFileA failed on %s, hFile %p, err=%u, should be %u\n",
1327 }
1329 CloseHandle( hFile );
1330 i++;
1331 }
1333 ok(ret, "RemoveDirectoryA: error %d\n", GetLastError());
1334 SetCurrentDirectoryW(curdir);
1335
1336 /* test opening directory as a directory */
1339 NULL,
1343 {
1345 "CreateFileA did not work, last error %u on volume <%s>\n",
1347
1349 {
1351 if (ret)
1352 {
1354 "CreateFileA probably did not open temp directory %s correctly\n file information does not include FILE_ATTRIBUTE_DIRECTORY, actual=0x%08x\n",
1356 }
1357 CloseHandle( hFile );
1358 }
1359 }
1360 else
1361 skip("Probable Win9x, got ERROR_PATH_NOT_FOUND w/ FILE_FLAG_BACKUP_SEMANTICS or %s\n", temp_path);
1362
1363
1364 /* *** Test opening volumes/devices using drive letter *** */
1365
1366 /* test using drive letter in non-rewrite format without trailing \ */
1367 /* this should work */
1368 strcpy(filename, nt_drive);
1369 filename[4] = windowsdir[0];
1374 if (hFile != INVALID_HANDLE_VALUE ||
1376 {
1377 /* if we have adm rights to volume, then try rest of tests */
1378 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1381 {
1382 /* if we opened the volume/device, try to read it. Since it */
1383 /* opened, we should be able to read it. We don't care about*/
1384 /* what the data is at this time. */
1385 len = 512;
1386 ret = ReadFile( hFile, buffer, len, &len, NULL );
1387 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1389 if (ret)
1390 {
1391 trace("buffer is\n");
1392 dumpmem(buffer, 64);
1393 }
1394 CloseHandle( hFile );
1395 }
1396
1397 /* test using drive letter with trailing \ and in non-rewrite */
1398 /* this should not work */
1399 strcpy(filename, nt_drive);
1400 filename[4] = windowsdir[0];
1401 strcat( filename, "\\" );
1406 todo_wine
1408 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1411 CloseHandle( hFile );
1412
1413 /* test using temp path with trailing \ and in non-rewrite as dir */
1414 /* this should work */
1415 strcpy(filename, nt_drive);
1416 filename[4] = 0;
1423 "CreateFileA should have worked on %s, but got %u\n",
1426 CloseHandle( hFile );
1427
1428 /* test using drive letter without trailing \ and in device ns */
1429 /* this should work */
1430 strcpy(filename, nt_drive);
1431 filename[4] = windowsdir[0];
1432 filename[2] = '.';
1437 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1440 CloseHandle( hFile );
1441 }
1442 /* If we see ERROR_BAD_NETPATH then on Win9x or WinME, so skip */
1443 else if (GetLastError() == ERROR_BAD_NETPATH)
1444 skip("Probable Win9x, got ERROR_BAD_NETPATH (53)\n");
1445 else
1446 skip("Do not have authority to access volumes. Tests skipped\n");
1447
1448
1449 /* *** Test opening volumes/devices using GUID *** */
1450
1451 if (pGetVolumeNameForVolumeMountPointA)
1452 {
1453 strcpy(filename, "c:\\");
1454 filename[0] = windowsdir[0];
1455 ret = pGetVolumeNameForVolumeMountPointA( filename, Volume_1, MAX_PATH );
1456 ok(ret, "GetVolumeNameForVolumeMountPointA failed, for %s, last error=%d\n", filename, GetLastError());
1457 if (ret)
1458 {
1459 ok(strlen(Volume_1) == 49, "GetVolumeNameForVolumeMountPointA returned wrong length name <%s>\n", Volume_1);
1460
1461 /* test the result of opening a unique volume name (GUID)
1462 * with the trailing \
1463 * this should error out
1464 */
1465 strcpy(filename, Volume_1);
1470 todo_wine
1472 "CreateFileA should not have opened %s, hFile %p\n",
1473 filename, hFile);
1474 todo_wine
1476 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1479 CloseHandle( hFile );
1480
1481 /* test the result of opening a unique volume name (GUID)
1482 * with the temp path string as dir
1483 * this should work
1484 */
1485 strcpy(filename, Volume_1);
1491 todo_wine
1493 "CreateFileA should have opened %s, but got %u\n",
1496 CloseHandle( hFile );
1497
1498 /* test the result of opening a unique volume name (GUID)
1499 * without the trailing \ and in device namespace
1500 * this should work
1501 */
1502 strcpy(filename, Volume_1);
1503 filename[2] = '.';
1504 filename[48] = 0;
1510 {
1511 /* if we have adm rights to volume, then try rest of tests */
1512 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1515 {
1516 /* if we opened the volume/device, try to read it. Since it */
1517 /* opened, we should be able to read it. We don't care about*/
1518 /* what the data is at this time. */
1519 len = 512;
1520 ret = ReadFile( hFile, buffer, len, &len, NULL );
1521 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1523 if (ret)
1524 {
1525 trace("buffer is\n");
1526 dumpmem(buffer, 64);
1527 }
1528 CloseHandle( hFile );
1529 }
1530 }
1531 else
1532 skip("Do not have authority to access volumes. Tests skipped\n");
1533 }
1534 else
1535 win_skip("GetVolumeNameForVolumeMountPointA not functioning\n");
1536 }
1537 else
1538 win_skip("GetVolumeNameForVolumeMountPointA not found\n");
1539}
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define ERROR_SUCCESS
Definition: deptool.c:10
#define GetCurrentDirectoryW(x, y)
Definition: compat.h:756
BOOL WINAPI RemoveDirectoryA(IN LPCSTR lpPathName)
Definition: dir.c:714
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37
BOOL WINAPI GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation)
Definition: fileinfo.c:458
BOOL WINAPI SetCurrentDirectoryW(IN LPCWSTR lpPathName)
Definition: path.c:2249
BOOL WINAPI SetCurrentDirectoryA(IN LPCSTR lpPathName)
Definition: path.c:2206
__cdecl __MINGW_NOTHROW char * dirname(char *)
#define FILE_FLAG_NO_BUFFERING
Definition: disk.h:45
static void dumpmem(unsigned char *mem, int len)
Definition: file.c:1165
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
Definition: file.c:64
const LONG err2
Definition: file.c:67
const BOOL todo_flag
Definition: file.c:69
#define ERROR_BAD_NETPATH
Definition: winerror.h:145

Referenced by START_TEST().

◆ test_CreateFileW()

static void test_CreateFileW ( void  )
static

Definition at line 1541 of file file.c.

1542{
1543 HANDLE hFile;
1546 static const WCHAR emptyW[]={'\0'};
1547 static const WCHAR prefix[] = {'p','f','x',0};
1548 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1549 DWORD ret;
1550
1553 {
1554 win_skip("GetTempPathW is not available\n");
1555 return;
1556 }
1557 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1558 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1559
1560 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1561 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1562
1563 SetLastError(0xdeadbeef);
1567 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1568
1569 SetLastError(0xdeadbeef);
1573 "hFile %p, last error %u\n", hFile, GetLastError());
1574
1576
1577 SetLastError(0xdeadbeef);
1581 "hFile %p, last error %u\n", hFile, GetLastError());
1582
1584
1586 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1587
1588 SetLastError(0xdeadbeef);
1592 "hFile %p, last error %u\n", hFile, GetLastError());
1593
1595
1597 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1598
1599 if (0)
1600 {
1601 /* this crashes on NT4.0 */
1605 "CreateFileW(NULL) returned ret=%p error=%u\n",hFile,GetLastError());
1606 }
1607
1611 "CreateFileW(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1612
1613 /* test the result of opening a nonexistent driver name */
1617 "CreateFileW on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1618
1620 ok(ret == TRUE, "couldn't create temporary directory\n");
1624 "expected CreateFile to succeed on existing directory, error: %d\n", GetLastError());
1627 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1628}

Referenced by START_TEST().

◆ test_DeleteFileA()

static void test_DeleteFileA ( void  )
static

Definition at line 1748 of file file.c.

1749{
1750 BOOL ret;
1752 HANDLE hfile;
1753
1754 ret = DeleteFileA(NULL);
1757 "DeleteFileA(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1758
1759 ret = DeleteFileA("");
1762 "DeleteFileA(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1763
1764 ret = DeleteFileA("nul");
1769 "DeleteFileA(\"nul\") returned ret=%d error=%d\n",ret,GetLastError());
1770
1771 ret = DeleteFileA("nonexist.txt");
1772 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "DeleteFileA(\"nonexist.txt\") returned ret=%d error=%d\n",ret,GetLastError());
1773
1776
1777 SetLastError(0xdeadbeef);
1779 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
1780
1781 SetLastError(0xdeadbeef);
1783 ok(ret, "DeleteFile error %d\n", GetLastError());
1784
1785 SetLastError(0xdeadbeef);
1786 ret = CloseHandle(hfile);
1787 ok(ret, "CloseHandle error %d\n", GetLastError());
1789 ok(!ret, "DeleteFile should fail\n");
1790
1791 SetLastError(0xdeadbeef);
1792 ret = CreateDirectoryA("testdir", NULL);
1793 ok(ret, "CreateDirectory failed, got err %d\n", GetLastError());
1794 ret = DeleteFileA("testdir");
1796 "Expected ERROR_ACCESS_DENIED, got error %d\n", GetLastError());
1797 ret = RemoveDirectoryA("testdir");
1798 ok(ret, "Remove a directory failed, got error %d\n", GetLastError());
1799}
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
Definition: fci.c:110
#define ERROR_BAD_PATHNAME
Definition: winerror.h:233

Referenced by START_TEST().

◆ test_DeleteFileW()

static void test_DeleteFileW ( void  )
static

Definition at line 1801 of file file.c.

1802{
1803 BOOL ret;
1804 WCHAR pathW[MAX_PATH];
1805 WCHAR pathsubW[MAX_PATH];
1806 static const WCHAR dirW[] = {'d','e','l','e','t','e','f','i','l','e',0};
1807 static const WCHAR subdirW[] = {'\\','s','u','b',0};
1808 static const WCHAR emptyW[]={'\0'};
1809
1810 ret = DeleteFileW(NULL);
1812 {
1813 win_skip("DeleteFileW is not available\n");
1814 return;
1815 }
1817 "DeleteFileW(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1818
1821 "DeleteFileW(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1822
1823 /* test DeleteFile on empty directory */
1824 ret = GetTempPathW(MAX_PATH, pathW);
1825 if (ret + sizeof(dirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
1826 {
1827 ok(0, "MAX_PATH exceeded in constructing paths\n");
1828 return;
1829 }
1830 lstrcatW(pathW, dirW);
1831 lstrcpyW(pathsubW, pathW);
1832 lstrcatW(pathsubW, subdirW);
1833 ret = CreateDirectoryW(pathW, NULL);
1834 ok(ret == TRUE, "couldn't create directory deletefile\n");
1835 ret = DeleteFileW(pathW);
1836 ok(ret == FALSE, "DeleteFile should fail for empty directories\n");
1837 ret = RemoveDirectoryW(pathW);
1838 ok(ret == TRUE, "expected to remove directory deletefile\n");
1839
1840 /* test DeleteFile on non-empty directory */
1841 ret = CreateDirectoryW(pathW, NULL);
1842 ok(ret == TRUE, "couldn't create directory deletefile\n");
1843 ret = CreateDirectoryW(pathsubW, NULL);
1844 ok(ret == TRUE, "couldn't create directory deletefile\\sub\n");
1845 ret = DeleteFileW(pathW);
1846 ok(ret == FALSE, "DeleteFile should fail for non-empty directories\n");
1847 ret = RemoveDirectoryW(pathsubW);
1848 ok(ret == TRUE, "expected to remove directory deletefile\\sub\n");
1849 ret = RemoveDirectoryW(pathW);
1850 ok(ret == TRUE, "expected to remove directory deletefile\n");
1851}
#define lstrcpyW
Definition: compat.h:749
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274

Referenced by START_TEST().

◆ test_file_access()

static void test_file_access ( void  )
static

Definition at line 4503 of file file.c.

4504{
4505 static const struct
4506 {
4507 unsigned access, create_error, write_error, read_error;
4508 } td[] =
4509 {
4510 { GENERIC_READ | GENERIC_WRITE, 0, 0, 0 },
4513 { FILE_READ_DATA | FILE_WRITE_DATA, 0, 0, 0 },
4517 { FILE_READ_DATA | FILE_APPEND_DATA, 0, 0, 0 },
4520 };
4521 char path[MAX_PATH], fname[MAX_PATH];
4522 unsigned char buf[16];
4523 HANDLE hfile, hdup;
4524 DWORD i, j, ret, bytes;
4525
4527 GetTempFileNameA(path, "foo", 0, fname);
4528
4529 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
4530 {
4531 SetLastError(0xdeadbeef);
4532 hfile = CreateFileA(fname, td[i].access, 0, NULL, CREATE_ALWAYS,
4534 if (td[i].create_error)
4535 {
4536 ok(hfile == INVALID_HANDLE_VALUE, "%d: CreateFile should fail\n", i);
4537 ok(td[i].create_error == GetLastError(), "%d: expected %d, got %d\n", i, td[i].create_error, GetLastError());
4538 continue;
4539 }
4540 else
4541 ok(hfile != INVALID_HANDLE_VALUE, "%d: CreateFile error %d\n", i, GetLastError());
4542
4543 for (j = 0; j < sizeof(td)/sizeof(td[0]); j++)
4544 {
4545 SetLastError(0xdeadbeef);
4547 td[j].access, 0, 0);
4548 if (is_access_compatible(td[i].access, td[j].access))
4549 ok(ret, "DuplicateHandle(%#x => %#x) error %d\n", td[i].access, td[j].access, GetLastError());
4550 else
4551 {
4552 /* FIXME: Remove once Wine is fixed */
4554 (!(td[i].access & (GENERIC_WRITE | FILE_WRITE_DATA)) && (td[j].access & FILE_WRITE_DATA)) ||
4555 (!(td[i].access & (GENERIC_READ | FILE_READ_DATA)) && (td[j].access & FILE_READ_DATA)) ||
4556 (!(td[i].access & (GENERIC_WRITE)) && (td[j].access & FILE_APPEND_DATA))))
4557 {
4558 ok(!ret, "DuplicateHandle(%#x => %#x) should fail\n", td[i].access, td[j].access);
4559 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
4560 }
4561 }
4562 if (ret) CloseHandle(hdup);
4563 }
4564
4565 SetLastError(0xdeadbeef);
4566 bytes = 0xdeadbeef;
4567 ret = WriteFile(hfile, "\x5e\xa7", 2, &bytes, NULL);
4568 if (td[i].write_error)
4569 {
4570 ok(!ret, "%d: WriteFile should fail\n", i);
4571 ok(td[i].write_error == GetLastError(), "%d: expected %d, got %d\n", i, td[i].write_error, GetLastError());
4572 ok(bytes == 0, "%d: expected 0, got %u\n", i, bytes);
4573 }
4574 else
4575 {
4576 ok(ret, "%d: WriteFile error %d\n", i, GetLastError());
4577 ok(bytes == 2, "%d: expected 2, got %u\n", i, bytes);
4578 }
4579
4580 SetLastError(0xdeadbeef);
4581 ret = SetFilePointer(hfile, 0, NULL, FILE_BEGIN);
4582 ok(ret != INVALID_SET_FILE_POINTER, "SetFilePointer error %d\n", GetLastError());
4583
4584 SetLastError(0xdeadbeef);
4585 bytes = 0xdeadbeef;
4586 ret = ReadFile(hfile, buf, sizeof(buf), &bytes, NULL);
4587 if (td[i].read_error)
4588 {
4589 ok(!ret, "%d: ReadFile should fail\n", i);
4590 ok(td[i].read_error == GetLastError(), "%d: expected %d, got %d\n", i, td[i].read_error, GetLastError());
4591 ok(bytes == 0, "%d: expected 0, got %u\n", i, bytes);
4592 }
4593 else
4594 {
4595 ok(ret, "%d: ReadFile error %d\n", i, GetLastError());
4596 if (td[i].write_error)
4597 ok(bytes == 0, "%d: expected 0, got %u\n", i, bytes);
4598 else
4599 {
4600 ok(bytes == 2, "%d: expected 2, got %u\n", i, bytes);
4601 ok(buf[0] == 0x5e && buf[1] == 0xa7, "%d: expected 5ea7, got %02x%02x\n", i, buf[0], buf[1]);
4602 }
4603 }
4604
4605 CloseHandle(hfile);
4606 }
4607}
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
#define INVALID_SET_FILE_POINTER
Definition: compat.h:732
#define SetFilePointer
Definition: compat.h:743
#define GetCurrentProcess()
Definition: compat.h:759
static HRESULT create_error(script_ctx_t *ctx, jsdisp_t *constr, UINT number, jsstr_t *msg, jsdisp_t **ret)
Definition: error.c:188
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define FILE_FLAG_DELETE_ON_CLOSE
Definition: disk.h:42
static BOOL is_access_compatible(unsigned obj_access, unsigned desired_access)
Definition: file.c:4496

Referenced by START_TEST().

◆ test_file_sharing()

static void test_file_sharing ( void  )
static

Definition at line 2323 of file file.c.

2324{
2325 struct mode { DWORD dw; const char* str; };
2326#define M(x) {x, # x}
2327 static const struct mode access_modes[] =
2335 static const struct mode sharing_modes[] =
2336 { M(0), M(FILE_SHARE_READ),
2340 static const struct mode mapping_modes[] =
2342#undef M
2343 int a1, s1, a2, s2;
2344 int ret;
2345 HANDLE h, h2;
2346
2347 /* make sure the file exists */
2348 if (!create_fake_dll( filename ))
2349 {
2350 ok(0, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError());
2351 return;
2352 }
2353
2354 for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
2355 {
2356 for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
2357 {
2358 SetLastError(0xdeadbeef);
2359 h = CreateFileA( filename, access_modes[a1].dw, sharing_modes[s1].dw,
2360 NULL, OPEN_EXISTING, 0, 0 );
2361 if (h == INVALID_HANDLE_VALUE)
2362 {
2363 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2364 return;
2365 }
2366 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
2367 {
2368 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
2369 {
2370 SetLastError(0xdeadbeef);
2371 h2 = CreateFileA( filename, access_modes[a2].dw, sharing_modes[s2].dw,
2372 NULL, OPEN_EXISTING, 0, 0 );
2373 ret = GetLastError();
2374 if (is_sharing_compatible( access_modes[a1].dw, sharing_modes[s1].dw,
2375 access_modes[a2].dw, sharing_modes[s2].dw ))
2376 {
2377 ok( h2 != INVALID_HANDLE_VALUE,
2378 "open failed for modes %s / %s / %s / %s\n",
2379 access_modes[a1].str, sharing_modes[s1].str,
2380 access_modes[a2].str, sharing_modes[s2].str );
2381 ok( ret == 0, "wrong error code %d\n", ret );
2382 }
2383 else
2384 {
2385 ok( h2 == INVALID_HANDLE_VALUE,
2386 "open succeeded for modes %s / %s / %s / %s\n",
2387 access_modes[a1].str, sharing_modes[s1].str,
2388 access_modes[a2].str, sharing_modes[s2].str );
2390 "wrong error code %d\n", ret );
2391 }
2392 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2393 }
2394 }
2395 CloseHandle( h );
2396 }
2397 }
2398
2399 for (a1 = 0; a1 < sizeof(mapping_modes)/sizeof(mapping_modes[0]); a1++)
2400 {
2401 HANDLE m;
2402
2404 SetLastError(0xdeadbeef);
2406 if (h == INVALID_HANDLE_VALUE)
2407 {
2408 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2409 return;
2410 }
2411 m = CreateFileMappingA( h, NULL, mapping_modes[a1].dw, 0, 0, NULL );
2412 ok( m != 0, "failed to create mapping %s err %u\n", mapping_modes[a1].str, GetLastError() );
2413 CloseHandle( h );
2414 if (!m) continue;
2415
2416 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
2417 {
2418 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
2419 {
2420 SetLastError(0xdeadbeef);
2421 h2 = CreateFileA( filename, access_modes[a2].dw, sharing_modes[s2].dw,
2422 NULL, OPEN_EXISTING, 0, 0 );
2423
2424 ret = GetLastError();
2425 if (h2 == INVALID_HANDLE_VALUE)
2426 {
2427 ok( !is_sharing_map_compatible(mapping_modes[a1].dw, access_modes[