virtual.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winnt.h"
#include "winternl.h"
#include "winerror.h"
#include "winuser.h"
#include "excpt.h"
#include "wine/test.h"

Include dependency graph for virtual.c:

Go to the source code of this file.

Classes
struct	read_pipe_args

Macros
#define	WIN32_NO_STATUS
#define	NUM_THREADS   4
#define	MAPPING_SIZE   0x100000
#define	ACCESS_READ   0x01
#define	ACCESS_WRITE   0x02
#define	ACCESS_EXECUTE   0x04

Functions
static	UINT (WINAPI *pGetWriteWatch)(DWORD
static	NTSTATUS (WINAPI *pNtAreMappedFilesTheSame)(PVOID
static	DWORD (WINAPI *pNtUnmapViewOfSection)(HANDLE
static void SIZE_T *static	PVOID (WINAPI *pRtlAddVectoredExceptionHandler)(ULONG
static	ULONG (WINAPI *pRtlRemoveVectoredExceptionHandler)(PVOID)
static	BOOL (WINAPI *pGetProcessDEPPolicy)(HANDLE
static HANDLE	create_target_process (const char *arg)
static void	test_VirtualAllocEx (void)
static void	test_VirtualAlloc (void)
static void	test_MapViewOfFile (void)
static void	test_NtAreMappedFilesTheSame (void)
static void	test_CreateFileMapping (void)
static void	test_IsBadReadPtr (void)
static void	test_IsBadWritePtr (void)
static void	test_IsBadCodePtr (void)
static DWORD CALLBACK	read_pipe (void *arg)
static void	test_write_watch (void)
static void	test_VirtualProtect (void)
static BOOL	is_mem_writable (DWORD prot)
static void	test_VirtualAlloc_protection (void)
static void	test_CreateFileMapping_protection (void)
static DWORD	page_prot_to_access (DWORD prot)
static BOOL	is_compatible_protection (DWORD view_prot, DWORD prot)
static DWORD	map_prot_to_access (DWORD prot)
static DWORD	map_prot_no_write (DWORD prot)
static DWORD	map_prot_written (DWORD prot)
static DWORD	file_access_to_prot (DWORD access)
static BOOL	is_compatible_access (DWORD map_prot, DWORD view_prot)
static void *	map_view_of_file (HANDLE handle, DWORD access)
static void	test_mapping (HANDLE hfile, DWORD sec_flags, BOOL readonly)
static void	test_mappings (void)
static void	test_shared_memory (BOOL is_child)
static void	test_shared_memory_ro (BOOL is_child, DWORD child_access)
static void	test_PrefetchVirtualMemory (void)
static void	test_ReadProcessMemory (void)
	START_TEST (virtual)

Variables
static HINSTANCE	hkernel32
static HINSTANCE	hkernelbase
static HINSTANCE	hntdll
static SYSTEM_INFO	si
static BOOL	is_wow64
static	LPVOID
static	SIZE_T
static	PVOID
static	ACCESS_MASK
static const OBJECT_ATTRIBUTES const LARGE_INTEGER	ULONG
static const OBJECT_ATTRIBUTES const LARGE_INTEGER	HANDLE
static PVOID	ULONG_PTR
static	SECTION_INFORMATION_CLASS
static void SIZE_T *static	PVECTORED_EXCEPTION_HANDLER
static	LPDWORD
static	PBOOL
static PVOID SIZE_T ULONG *static const void void SIZE_T *static void const void SIZE_T *static	PWIN32_MEMORY_RANGE_ENTRY
static const char	testdata [] = "Hello World"

Macro Definition Documentation

ACCESS_EXECUTE

#define ACCESS_EXECUTE   0x04

Definition at line 3783 of file virtual.c.

ACCESS_READ

#define ACCESS_READ   0x01

Definition at line 3781 of file virtual.c.

ACCESS_WRITE

#define ACCESS_WRITE   0x02

Definition at line 3782 of file virtual.c.

MAPPING_SIZE

#define MAPPING_SIZE   0x100000

Definition at line 36 of file virtual.c.

NUM_THREADS

#define NUM_THREADS   4

Definition at line 35 of file virtual.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 25 of file virtual.c.

Function Documentation

BOOL()

static BOOL ( WINAPI *  pGetProcessDEPPolicy )

static

create_target_process()

static HANDLE create_target_process ( const char *  arg )

static

Definition at line 62 of file virtual.c.

{
    char **argv;
    char cmdline[MAX_PATH];
    PROCESS_INFORMATION pi;
    BOOL ret;
    STARTUPINFOA si = { 0 };
    si.cb = sizeof(si);
 
    winetest_get_mainargs( &argv );
    sprintf(cmdline, "%s %s %s", argv[0], argv[1], arg);
    ret = CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "error: %lu\n", GetLastError());
    ret = CloseHandle(pi.hThread);
    ok(ret, "error %lu\n", GetLastError());
    return pi.hProcess;
}

Referenced by test_VirtualAllocEx().

DWORD()

static DWORD ( WINAPI *  pNtUnmapViewOfSection )

static

file_access_to_prot()

static DWORD file_access_to_prot ( DWORD  access )

static

Definition at line 3855 of file virtual.c.

{
    BOOL exec = access & FILE_MAP_EXECUTE;
    access &= ~FILE_MAP_EXECUTE;
 
    if (access == FILE_MAP_COPY) return exec ? PAGE_EXECUTE_WRITECOPY : PAGE_WRITECOPY;
    if (access & FILE_MAP_WRITE) return exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
    if (access & FILE_MAP_READ)  return exec ? PAGE_EXECUTE_READ : PAGE_READONLY;
    return PAGE_NOACCESS;
}

Referenced by is_compatible_access(), and map_view_of_file().

is_compatible_access()

static BOOL is_compatible_access ( DWORD  map_prot, DWORD  view_prot  )

static

Definition at line 3866 of file virtual.c.

{
    DWORD access = map_prot_to_access(map_prot);
    DWORD view_access = map_prot_to_access( file_access_to_prot( view_prot ));
    if (!view_access) view_access = SECTION_MAP_READ;
    return (view_access & access) == view_access;
}

Referenced by test_mapping().

is_compatible_protection()

static BOOL is_compatible_protection ( DWORD  view_prot, DWORD  prot  )

static

Definition at line 3805 of file virtual.c.

{
    DWORD view_access, prot_access;
 
    view_access = page_prot_to_access(view_prot);
    prot_access = page_prot_to_access(prot);
 
    return ((view_access & prot_access) == prot_access);
}

Referenced by test_mapping().

is_mem_writable()

static BOOL is_mem_writable ( DWORD  prot )

static

Definition at line 3446 of file virtual.c.

{
    switch (prot & 0xff)
    {
        case PAGE_READWRITE:
        case PAGE_WRITECOPY:
        case PAGE_EXECUTE_READWRITE:
        case PAGE_EXECUTE_WRITECOPY:
            return TRUE;
 
        default:
            return FALSE;
    }
}

Referenced by test_CreateFileMapping_protection(), and test_VirtualAlloc_protection().

map_prot_no_write()

static DWORD map_prot_no_write ( DWORD  prot )

static

Definition at line 3835 of file virtual.c.

{
    switch (prot)
    {
    case PAGE_READWRITE: return PAGE_WRITECOPY;
    case PAGE_EXECUTE_READWRITE: return PAGE_EXECUTE_WRITECOPY;
    default: return prot;
    }
}

Referenced by test_mapping().

map_prot_to_access()

static DWORD map_prot_to_access ( DWORD  prot )

static

Definition at line 3815 of file virtual.c.

{
    switch (prot)
    {
    case PAGE_READWRITE:
        return SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_QUERY;
    case PAGE_EXECUTE_READWRITE:
        return SECTION_MAP_READ | SECTION_MAP_WRITE | SECTION_MAP_EXECUTE | SECTION_QUERY;
    case PAGE_READONLY:
    case PAGE_WRITECOPY:
        return SECTION_MAP_READ | SECTION_QUERY;
    case PAGE_EXECUTE:
    case PAGE_EXECUTE_READ:
    case PAGE_EXECUTE_WRITECOPY:
        return SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_QUERY;
    default:
        return 0;
    }
}

Referenced by is_compatible_access().

map_prot_written()

static DWORD map_prot_written ( DWORD  prot )

static

Definition at line 3845 of file virtual.c.

{
    switch (prot)
    {
    case PAGE_WRITECOPY: return PAGE_READWRITE;
    case PAGE_EXECUTE_WRITECOPY: return PAGE_EXECUTE_READWRITE;
    default: return prot;
    }
}

Referenced by test_mapping().

map_view_of_file()

static void * map_view_of_file ( HANDLE  handle, DWORD  access  )

static

Definition at line 3874 of file virtual.c.

{
    NTSTATUS status;
    LARGE_INTEGER offset;
    SIZE_T count;
    ULONG protect;
    void *addr;
 
    if (!pNtMapViewOfSection) return NULL;
 
    count = 0;
    offset.u.LowPart  = 0;
    offset.u.HighPart = 0;
 
    protect = file_access_to_prot( access );
    addr = NULL;
    status = pNtMapViewOfSection(handle, GetCurrentProcess(), &addr, 0, 0, &offset,
                                 &count, 1 /* ViewShare */, 0, protect);
    if ((int)status < 0) addr = NULL;
    return addr;
}

Referenced by test_mapping().

NTSTATUS()

static NTSTATUS ( WINAPI *  pNtAreMappedFilesTheSame )

static

page_prot_to_access()

static DWORD page_prot_to_access ( DWORD  prot )

static

Definition at line 3785 of file virtual.c.

{
    switch (prot)
    {
    case PAGE_READONLY:
    case PAGE_WRITECOPY:
        return ACCESS_READ;
    case PAGE_READWRITE:
        return ACCESS_READ | ACCESS_WRITE;
    case PAGE_EXECUTE:
    case PAGE_EXECUTE_READ:
    case PAGE_EXECUTE_WRITECOPY:
        return ACCESS_READ | ACCESS_EXECUTE;
    case PAGE_EXECUTE_READWRITE:
        return ACCESS_READ | ACCESS_WRITE | ACCESS_EXECUTE;
    default:
        return 0;
    }
}

Referenced by is_compatible_protection().

PVOID()

static void SIZE_T *static PVOID ( WINAPI *  pRtlAddVectoredExceptionHandler )

static

read_pipe()

static DWORD CALLBACK read_pipe ( void *  arg )

static

Definition at line 1717 of file virtual.c.

{
    struct read_pipe_args *args = arg;
    DWORD num_bytes;
    BOOL success = ConnectNamedPipe( args->pipe, NULL );
    ok( success || GetLastError() == ERROR_PIPE_CONNECTED,
        "%u: ConnectNamedPipe failed %lu\n", args->index, GetLastError() );
 
    success = ReadFile( args->pipe, args->base, args->size, &num_bytes, NULL );
    ok( success, "%u: ReadFile failed %lu\n", args->index, GetLastError() );
    ok( num_bytes == sizeof(testdata), "%u: wrong number of bytes read %lu\n", args->index, num_bytes );
    ok( !memcmp( args->base, testdata, sizeof(testdata)),
        "%u: didn't receive expected data\n", args->index );
    return 0;
}

Referenced by _wpopen(), CreatePipe(), test_parent_process_attribute(), and test_write_watch().

START_TEST()

START_TEST

(

virtual

)

Definition at line 4478 of file virtual.c.

{
    int argc;
    char **argv;
    argc = winetest_get_mainargs( &argv );
 
#if defined(__REACTOS__) && defined(SKIPBADHEAP_K32_WINETEST)
    if (is_reactos()) {
        ok(FALSE, "FIXME: These tests are too rough on ReactOS heap manager on x64. It will eventually finish but it takes over an hour to complete the test suite with it which isn't acceptable.\n");
        return;
    }
#endif
    if (argc >= 3)
    {
        if (!strcmp(argv[2], "sleep"))
        {
            Sleep(5000); /* spawned process runs for at most 5 seconds */
            return;
        }
        if (!strcmp(argv[2], "sharedmem"))
        {
            test_shared_memory(TRUE);
            return;
        }
        if (!strcmp(argv[2], "sharedmemro"))
        {
            test_shared_memory_ro(TRUE, strtol(argv[3], NULL, 16));
            return;
        }
        while (1)
        {
            void *mem;
            BOOL ret;
            mem = VirtualAlloc(NULL, 1<<20, MEM_COMMIT|MEM_RESERVE,
                               PAGE_EXECUTE_READWRITE);
            ok(mem != NULL, "VirtualAlloc failed %lu\n", GetLastError());
            if (mem == NULL) break;
            ret = VirtualFree(mem, 0, MEM_RELEASE);
            ok(ret, "VirtualFree failed %lu\n", GetLastError());
            if (!ret) break;
        }
        return;
    }
 
    hkernel32 = GetModuleHandleA("kernel32.dll");
    hkernelbase = GetModuleHandleA("kernelbase.dll");
    hntdll    = GetModuleHandleA("ntdll.dll");
 
    pGetWriteWatch = (void *) GetProcAddress(hkernel32, "GetWriteWatch");
    pResetWriteWatch = (void *) GetProcAddress(hkernel32, "ResetWriteWatch");
    pGetProcessDEPPolicy = (void *)GetProcAddress( hkernel32, "GetProcessDEPPolicy" );
    pIsWow64Process = (void *)GetProcAddress( hkernel32, "IsWow64Process" );
    pNtAreMappedFilesTheSame = (void *)GetProcAddress( hntdll, "NtAreMappedFilesTheSame" );
    pNtCreateSection = (void *)GetProcAddress( hntdll, "NtCreateSection" );
    pNtMapViewOfSection = (void *)GetProcAddress( hntdll, "NtMapViewOfSection" );
    pNtUnmapViewOfSection = (void *)GetProcAddress( hntdll, "NtUnmapViewOfSection" );
    pNtQuerySection = (void *)GetProcAddress( hntdll, "NtQuerySection" );
    pRtlAddVectoredExceptionHandler = (void *)GetProcAddress( hntdll, "RtlAddVectoredExceptionHandler" );
    pRtlRemoveVectoredExceptionHandler = (void *)GetProcAddress( hntdll, "RtlRemoveVectoredExceptionHandler" );
    pNtProtectVirtualMemory = (void *)GetProcAddress( hntdll, "NtProtectVirtualMemory" );
    pNtReadVirtualMemory = (void *)GetProcAddress( hntdll, "NtReadVirtualMemory" );
    pNtWriteVirtualMemory = (void *)GetProcAddress( hntdll, "NtWriteVirtualMemory" );
#ifndef __REACTOS__ // TODO: Enable when kernelbase is fixed. ROSTESTS-414
    pPrefetchVirtualMemory = (void *)GetProcAddress( hkernelbase, "PrefetchVirtualMemory" );
#endif
 
    GetSystemInfo(&si);
    trace("system page size %#lx\n", si.dwPageSize);
 
    if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) is_wow64 = FALSE;
 
    test_shared_memory(FALSE);
    test_shared_memory_ro(FALSE, FILE_MAP_READ|FILE_MAP_WRITE);
    test_shared_memory_ro(FALSE, FILE_MAP_COPY);
    test_shared_memory_ro(FALSE, FILE_MAP_COPY|FILE_MAP_WRITE);
    test_mappings();
    test_CreateFileMapping_protection();
    test_VirtualAlloc_protection();
    test_VirtualProtect();
    test_VirtualAllocEx();
    test_VirtualAlloc();
    test_MapViewOfFile();
    test_NtAreMappedFilesTheSame();
    test_CreateFileMapping();
    test_IsBadReadPtr();
    test_IsBadWritePtr();
    test_IsBadCodePtr();
    test_write_watch();
    test_PrefetchVirtualMemory();
    test_ReadProcessMemory();
#if defined(__i386__) || defined(__x86_64__)
    test_stack_commit();
#endif
#ifdef __i386__
    test_guard_page();
    /* The following tests should be executed as a last step, and in exactly this
     * order, since ATL thunk emulation cannot be enabled anymore on Windows. */
    test_atl_thunk_emulation( MEM_EXECUTE_OPTION_ENABLE );
    test_atl_thunk_emulation( MEM_EXECUTE_OPTION_DISABLE );
    test_atl_thunk_emulation( MEM_EXECUTE_OPTION_DISABLE | MEM_EXECUTE_OPTION_DISABLE_THUNK_EMULATION );
#endif
}

test_CreateFileMapping()

static void test_CreateFileMapping ( void  )

static

Definition at line 1480 of file virtual.c.

{
    HANDLE handle, handle2, file[3];
    char path[MAX_PATH], filename[MAX_PATH];
    unsigned int i;
    NTSTATUS status;
 
    static const struct { DWORD file, flags, error, attrs; } sec_flag_tests[] =
    {
        /* anonymous mapping */
        { 0, SEC_RESERVE, 0 }, /* 0 */
        { 0, SEC_RESERVE | SEC_NOCACHE, 0 },
        { 0, SEC_RESERVE | SEC_LARGE_PAGES, ERROR_INVALID_PARAMETER },
        { 0, SEC_RESERVE | SEC_WRITECOMBINE, 0 },
        { 0, SEC_COMMIT, 0 },
        { 0, SEC_COMMIT | SEC_NOCACHE, 0 }, /* 5 */
        { 0, SEC_COMMIT | SEC_WRITECOMBINE, 0 },
        { 0, SEC_RESERVE | SEC_COMMIT, ERROR_INVALID_PARAMETER },
        { 0, SEC_IMAGE, ERROR_BAD_EXE_FORMAT },
        { 0, SEC_IMAGE | SEC_RESERVE, ERROR_INVALID_PARAMETER },
        { 0, SEC_IMAGE | SEC_COMMIT, ERROR_INVALID_PARAMETER }, /* 10 */
        { 0, SEC_NOCACHE, ERROR_INVALID_PARAMETER },
        { 0, SEC_LARGE_PAGES, ERROR_INVALID_PARAMETER },
        { 0, SEC_WRITECOMBINE, ERROR_INVALID_PARAMETER },
        { 0, SEC_FILE, ERROR_INVALID_PARAMETER },
        { 0, SEC_FILE | SEC_RESERVE, ERROR_INVALID_PARAMETER }, /* 15 */
        { 0, SEC_FILE | SEC_COMMIT, ERROR_INVALID_PARAMETER },
        { 0, 0, 0, SEC_COMMIT },
        /* normal file */
        { 1, SEC_RESERVE, 0, SEC_FILE },
        { 1, SEC_RESERVE | SEC_NOCACHE, 0, SEC_FILE | SEC_NOCACHE },
        { 1, SEC_RESERVE | SEC_LARGE_PAGES, ERROR_INVALID_PARAMETER }, /* 20 */
        { 1, SEC_RESERVE | SEC_WRITECOMBINE, 0, SEC_FILE | SEC_WRITECOMBINE },
        { 1, SEC_COMMIT, 0, SEC_FILE },
        { 1, SEC_COMMIT | SEC_NOCACHE, 0, SEC_FILE | SEC_NOCACHE },
        { 1, SEC_COMMIT | SEC_LARGE_PAGES, ERROR_INVALID_PARAMETER },
        { 1, SEC_COMMIT | SEC_WRITECOMBINE, 0, SEC_FILE | SEC_WRITECOMBINE }, /* 25 */
        { 1, SEC_RESERVE | SEC_COMMIT, ERROR_INVALID_PARAMETER },
        { 1, SEC_IMAGE, ERROR_BAD_EXE_FORMAT },
        { 1, SEC_IMAGE | SEC_RESERVE, ERROR_INVALID_PARAMETER },
        { 1, SEC_IMAGE | SEC_COMMIT, ERROR_INVALID_PARAMETER },
        { 1, SEC_NOCACHE, ERROR_INVALID_PARAMETER }, /* 30 */
        { 1, SEC_LARGE_PAGES, ERROR_INVALID_PARAMETER },
        { 1, SEC_WRITECOMBINE, ERROR_INVALID_PARAMETER },
        { 1, SEC_FILE, ERROR_INVALID_PARAMETER },
        { 1, SEC_FILE | SEC_RESERVE, ERROR_INVALID_PARAMETER },
        { 1, SEC_FILE | SEC_COMMIT, ERROR_INVALID_PARAMETER }, /* 35 */
        { 1, 0, 0, SEC_FILE },
        /* PE image file */
        { 2, SEC_IMAGE, 0, SEC_FILE | SEC_IMAGE },
        { 2, SEC_IMAGE | SEC_FILE, ERROR_INVALID_PARAMETER },
        { 2, SEC_IMAGE | SEC_NOCACHE, 0, SEC_FILE | SEC_IMAGE },
        { 2, SEC_IMAGE | SEC_LARGE_PAGES, ERROR_INVALID_PARAMETER }, /* 40 */
        { 2, SEC_IMAGE | SEC_WRITECOMBINE, ERROR_INVALID_PARAMETER },
        { 2, SEC_IMAGE | SEC_RESERVE, ERROR_INVALID_PARAMETER },
        { 2, SEC_IMAGE | SEC_COMMIT, ERROR_INVALID_PARAMETER },
    };
 
    /* test case sensitivity */
 
    SetLastError(0xdeadbeef);
    handle = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE, 0, 0x1000,
                                 "Wine Test Mapping");
    ok( handle != NULL, "CreateFileMapping failed with error %lu\n", GetLastError());
    ok( GetLastError() == 0, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    handle2 = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE, 0, 0x1000,
                                  "Wine Test Mapping");
    ok( handle2 != NULL, "CreateFileMapping failed with error %ld\n", GetLastError());
    ok( GetLastError() == ERROR_ALREADY_EXISTS, "wrong error %lu\n", GetLastError());
    CloseHandle( handle2 );
 
    SetLastError(0xdeadbeef);
    handle2 = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE, 0, 0x1000,
                                 "WINE TEST MAPPING");
    ok( handle2 != NULL, "CreateFileMapping failed with error %ld\n", GetLastError());
    ok( GetLastError() == 0, "wrong error %lu\n", GetLastError());
    CloseHandle( handle2 );
 
    SetLastError(0xdeadbeef);
    handle2 = OpenFileMappingA( FILE_MAP_ALL_ACCESS, FALSE, "Wine Test Mapping");
    ok( handle2 != NULL, "OpenFileMapping failed with error %ld\n", GetLastError());
    CloseHandle( handle2 );
 
    SetLastError(0xdeadbeef);
    handle2 = OpenFileMappingA( FILE_MAP_ALL_ACCESS, FALSE, "WINE TEST MAPPING");
    ok( !handle2, "OpenFileMapping succeeded\n");
    ok( GetLastError() == ERROR_FILE_NOT_FOUND, "wrong error %lu\n", GetLastError());
 
    CloseHandle( handle );
 
    /* test SEC_* flags */
 
    file[0] = INVALID_HANDLE_VALUE;
    GetTempPathA( MAX_PATH, path );
    GetTempFileNameA( path, "map", 0, filename );
 
    file[1] = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
    ok( file[1] != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
    SetFilePointer( file[1], 0x2000, NULL, FILE_BEGIN );
    SetEndOfFile( file[1] );
 
    GetSystemDirectoryA( path, MAX_PATH );
    strcat( path, "\\kernel32.dll" );
    file[2] = CreateFileA( path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
    ok( file[2] != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
 
    for (i = 0; i < ARRAY_SIZE(sec_flag_tests); i++)
    {
        DWORD flags = sec_flag_tests[i].flags;
        DWORD perm = sec_flag_tests[i].file == 2 ? PAGE_READONLY : PAGE_READWRITE;
        SetLastError( 0xdeadbeef );
        handle = CreateFileMappingA( file[sec_flag_tests[i].file], NULL,
                                     flags | perm, 0, 0x1000, "Wine Test Mapping" );
        if (sec_flag_tests[i].error)
        {
            ok( !handle, "%u: CreateFileMapping succeeded\n", i );
            ok( GetLastError() == sec_flag_tests[i].error, "%u: wrong error %lu\n", i, GetLastError());
        }
        else
        {
            /* SEC_WRITECOMBINE and SEC_IMAGE_NO_EXECUTE not supported on older Windows */
            BOOL new_flags = ((flags & SEC_WRITECOMBINE) ||
                              ((flags & SEC_IMAGE_NO_EXECUTE) == SEC_IMAGE_NO_EXECUTE));
            ok( handle != NULL || broken(new_flags),
                "%u: CreateFileMapping failed with error %lu\n", i, GetLastError());
            ok( GetLastError() == 0 || broken(new_flags && GetLastError() == ERROR_INVALID_PARAMETER),
                "%u: wrong error %lu\n", i, GetLastError());
        }
 
        if (handle)
        {
            SECTION_BASIC_INFORMATION info;
            DWORD expect = sec_flag_tests[i].attrs ? sec_flag_tests[i].attrs : sec_flag_tests[i].flags;
 
            status = pNtQuerySection( handle, SectionBasicInformation, &info, sizeof(info), NULL );
            ok( !status, "%u: NtQuerySection failed err %lx\n", i, status );
            /* SEC_NOCACHE not supported on older Windows */
            ok( info.Attributes == expect || broken( info.Attributes == (expect & ~SEC_NOCACHE) ),
                "%u: NtQuerySection wrong attr %08lx\n", i, info.Attributes );
            CloseHandle( handle );
        }
    }
    CloseHandle( file[1] );
    CloseHandle( file[2] );
    DeleteFileA( filename );
}

Referenced by START_TEST().

test_CreateFileMapping_protection()

static void test_CreateFileMapping_protection ( void  )

static

Definition at line 3550 of file virtual.c.

{
    static const struct test_data
    {
        DWORD prot;
        BOOL success;
        DWORD prot_after_write;
    } td[] =
    {
        { 0, FALSE, 0 }, /* 0x00 */
        { PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x01 */
        { PAGE_READONLY, TRUE, PAGE_READONLY }, /* 0x02 */
        { PAGE_READONLY | PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x03 */
        { PAGE_READWRITE, TRUE, PAGE_READWRITE }, /* 0x04 */
        { PAGE_READWRITE | PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x05 */
        { PAGE_READWRITE | PAGE_READONLY, FALSE, PAGE_NOACCESS }, /* 0x06 */
        { PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x07 */
        { PAGE_WRITECOPY, TRUE, PAGE_READWRITE }, /* 0x08 */
        { PAGE_WRITECOPY | PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x09 */
        { PAGE_WRITECOPY | PAGE_READONLY, FALSE, PAGE_NOACCESS }, /* 0x0a */
        { PAGE_WRITECOPY | PAGE_NOACCESS | PAGE_READONLY, FALSE, PAGE_NOACCESS }, /* 0x0b */
        { PAGE_WRITECOPY | PAGE_READWRITE, FALSE, PAGE_NOACCESS }, /* 0x0c */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x0d */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY, FALSE, PAGE_NOACCESS }, /* 0x0e */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, FALSE, PAGE_NOACCESS }, /* 0x0f */
 
        { PAGE_EXECUTE, FALSE, PAGE_EXECUTE }, /* 0x10 */
        { PAGE_EXECUTE_READ, TRUE, PAGE_EXECUTE_READ }, /* 0x20 */
        { PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE, PAGE_EXECUTE_READ }, /* 0x30 */
        { PAGE_EXECUTE_READWRITE, TRUE, PAGE_EXECUTE_READWRITE }, /* 0x40 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, FALSE, PAGE_NOACCESS }, /* 0x50 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, FALSE, PAGE_NOACCESS }, /* 0x60 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE, PAGE_NOACCESS }, /* 0x70 */
        { PAGE_EXECUTE_WRITECOPY, TRUE, PAGE_EXECUTE_READWRITE }, /* 0x80 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE, FALSE, PAGE_NOACCESS }, /* 0x90 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ, FALSE, PAGE_NOACCESS }, /* 0xa0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE, PAGE_NOACCESS }, /* 0xb0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE, FALSE, PAGE_NOACCESS }, /* 0xc0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, FALSE, PAGE_NOACCESS }, /* 0xd0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, FALSE, PAGE_NOACCESS }, /* 0xe0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE, PAGE_NOACCESS } /* 0xf0 */
    };
    char *base, *ptr;
    DWORD ret, i, alloc_prot, old_prot;
    MEMORY_BASIC_INFORMATION info;
    char temp_path[MAX_PATH];
    char file_name[MAX_PATH];
    HANDLE hfile, hmap;
    BOOL page_exec_supported = TRUE;
 
    GetTempPathA(MAX_PATH, temp_path);
    GetTempFileNameA(temp_path, "map", 0, file_name);
 
    SetLastError(0xdeadbeef);
    hfile = CreateFileA(file_name, GENERIC_READ|GENERIC_WRITE|GENERIC_EXECUTE, 0, NULL, CREATE_ALWAYS, 0, 0);
    ok(hfile != INVALID_HANDLE_VALUE, "CreateFile(%s) error %ld\n", file_name, GetLastError());
    SetFilePointer(hfile, si.dwPageSize, NULL, FILE_BEGIN);
    SetEndOfFile(hfile);
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        SetLastError(0xdeadbeef);
        hmap = CreateFileMappingW(hfile, NULL, td[i].prot | SEC_COMMIT, 0, si.dwPageSize, NULL);
 
        if (td[i].success)
        {
            if (!hmap)
            {
                trace("%ld: CreateFileMapping(%04lx) failed: %ld\n", i, td[i].prot, GetLastError());
                /* NT4 and win2k don't support EXEC on file mappings */
                if (td[i].prot == PAGE_EXECUTE_READ || td[i].prot == PAGE_EXECUTE_READWRITE)
                {
                    page_exec_supported = FALSE;
                    ok(broken(!hmap), "%ld: CreateFileMapping doesn't support PAGE_EXECUTE\n", i);
                    continue;
                }
                /* Vista+ supports PAGE_EXECUTE_WRITECOPY, earlier versions don't */
                if (td[i].prot == PAGE_EXECUTE_WRITECOPY)
                {
                    page_exec_supported = FALSE;
                    ok(broken(!hmap), "%ld: CreateFileMapping doesn't support PAGE_EXECUTE_WRITECOPY\n", i);
                    continue;
                }
            }
            ok(hmap != 0, "%ld: CreateFileMapping(%04lx) error %ld\n", i, td[i].prot, GetLastError());
 
            base = MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
            ok(base != NULL, "%ld: MapViewOfFile failed %ld\n", i, GetLastError());
 
            SetLastError(0xdeadbeef);
            ret = VirtualQuery(base, &info, sizeof(info));
            ok(ret, "VirtualQuery failed %ld\n", GetLastError());
            ok(info.BaseAddress == base, "%ld: got %p != expected %p\n", i, info.BaseAddress, base);
            ok(info.RegionSize == si.dwPageSize, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, si.dwPageSize);
            ok(info.Protect == PAGE_READONLY, "%ld: got %#lx != expected PAGE_READONLY\n", i, info.Protect);
            ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
            ok(info.AllocationProtect == PAGE_READONLY, "%ld: %#lx != PAGE_READONLY\n", i, info.AllocationProtect);
            ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
            ok(info.Type == MEM_MAPPED, "%ld: %#lx != MEM_MAPPED\n", i, info.Type);
 
            SetLastError(0xdeadbeef);
            ptr = VirtualAlloc(base, si.dwPageSize, MEM_COMMIT, td[i].prot);
            ok(!ptr, "%ld: VirtualAlloc(%02lx) should fail\n", i, td[i].prot);
            ok(GetLastError() == ERROR_ACCESS_DENIED, "%ld: expected ERROR_ACCESS_DENIED, got %ld\n", i, GetLastError());
 
            SetLastError(0xdeadbeef);
            ret = VirtualProtect(base, si.dwPageSize, td[i].prot, &old_prot);
            if (td[i].prot == PAGE_READONLY || td[i].prot == PAGE_WRITECOPY)
                ok(ret, "%ld: VirtualProtect(%02lx) error %ld\n", i, td[i].prot, GetLastError());
            else
            {
                ok(!ret, "%ld: VirtualProtect(%02lx) should fail\n", i, td[i].prot);
                ok(GetLastError() == ERROR_INVALID_PARAMETER, "%ld: expected ERROR_INVALID_PARAMETER, got %ld\n", i, GetLastError());
            }
 
            UnmapViewOfFile(base);
            CloseHandle(hmap);
        }
        else
        {
            ok(!hmap, "%ld: CreateFileMapping should fail\n", i);
            ok(GetLastError() == ERROR_INVALID_PARAMETER, "%ld: expected ERROR_INVALID_PARAMETER, got %ld\n", i, GetLastError());
        }
    }
 
    if (page_exec_supported) alloc_prot = PAGE_EXECUTE_READWRITE;
    else alloc_prot = PAGE_READWRITE;
    SetLastError(0xdeadbeef);
    hmap = CreateFileMappingW(hfile, NULL, alloc_prot, 0, si.dwPageSize, NULL);
    ok(hmap != 0, "%ld: CreateFileMapping error %ld\n", i, GetLastError());
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        SetLastError(0xdeadbeef);
        base = MapViewOfFile(hmap, FILE_MAP_READ | FILE_MAP_WRITE | (page_exec_supported ? FILE_MAP_EXECUTE : 0), 0, 0, 0);
        ok(base != NULL, "MapViewOfFile failed %ld\n", GetLastError());
 
        old_prot = 0xdeadbeef;
        SetLastError(0xdeadbeef);
        ret = VirtualProtect(base, si.dwPageSize, PAGE_NOACCESS, &old_prot);
        ok(ret, "VirtualProtect error %ld\n", GetLastError());
        ok(old_prot == alloc_prot, "got %#lx != expected %#lx\n", old_prot, alloc_prot);
 
        SetLastError(0xdeadbeef);
        ret = VirtualQuery(base, &info, sizeof(info));
        ok(ret, "VirtualQuery failed %ld\n", GetLastError());
        ok(info.BaseAddress == base, "%ld: got %p != expected %p\n", i, info.BaseAddress, base);
        ok(info.RegionSize == si.dwPageSize, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, si.dwPageSize);
        ok(info.Protect == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, info.Protect);
        ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
        ok(info.AllocationProtect == alloc_prot, "%ld: %#lx != %#lx\n", i, info.AllocationProtect, alloc_prot);
        ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
        ok(info.Type == MEM_MAPPED, "%ld: %#lx != MEM_MAPPED\n", i, info.Type);
 
        old_prot = 0xdeadbeef;
        SetLastError(0xdeadbeef);
        ret = VirtualProtect(base, si.dwPageSize, td[i].prot, &old_prot);
        if (td[i].success || td[i].prot == PAGE_NOACCESS || td[i].prot == PAGE_EXECUTE)
        {
            if (!ret)
            {
                /* win2k and XP don't support EXEC on file mappings */
                if (td[i].prot == PAGE_EXECUTE)
                {
                    ok(broken(!ret), "%ld: VirtualProtect doesn't support PAGE_EXECUTE\n", i);
                    continue;
                }
                /* NT4 and win2k don't support EXEC on file mappings */
                if (td[i].prot == PAGE_EXECUTE_READ || td[i].prot == PAGE_EXECUTE_READWRITE)
                {
                    ok(broken(!ret), "%ld: VirtualProtect doesn't support PAGE_EXECUTE\n", i);
                    continue;
                }
                /* Vista+ supports PAGE_EXECUTE_WRITECOPY, earlier versions don't */
                if (td[i].prot == PAGE_EXECUTE_WRITECOPY)
                {
                    ok(broken(!ret), "%ld: VirtualProtect doesn't support PAGE_EXECUTE_WRITECOPY\n", i);
                    continue;
                }
            }
 
            ok(ret, "%ld: VirtualProtect error %ld\n", i, GetLastError());
            ok(old_prot == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, old_prot);
 
            SetLastError(0xdeadbeef);
            ret = VirtualQuery(base, &info, sizeof(info));
            ok(ret, "VirtualQuery failed %ld\n", GetLastError());
            ok(info.BaseAddress == base, "%ld: got %p != expected %p\n", i, info.BaseAddress, base);
            ok(info.RegionSize == si.dwPageSize, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, si.dwPageSize);
            ok(info.Protect == td[i].prot, "%ld: got %#lx != expected %#lx\n", i, info.Protect, td[i].prot);
            ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
            ok(info.AllocationProtect == alloc_prot, "%ld: %#lx != %#lx\n", i, info.AllocationProtect, alloc_prot);
            ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
            ok(info.Type == MEM_MAPPED, "%ld: %#lx != MEM_MAPPED\n", i, info.Type);
 
            if (is_mem_writable(info.Protect))
            {
                base[0] = 0xfe;
 
                SetLastError(0xdeadbeef);
                ret = VirtualQuery(base, &info, sizeof(info));
                ok(ret, "VirtualQuery failed %ld\n", GetLastError());
                /* FIXME: remove the condition below once Wine is fixed */
                todo_wine_if (td[i].prot == PAGE_WRITECOPY || td[i].prot == PAGE_EXECUTE_WRITECOPY)
                    ok(info.Protect == td[i].prot_after_write, "%ld: got %#lx != expected %#lx\n", i, info.Protect, td[i].prot_after_write);
            }
        }
        else
        {
            ok(!ret, "%ld: VirtualProtect should fail\n", i);
            ok(GetLastError() == ERROR_INVALID_PARAMETER, "%ld: expected ERROR_INVALID_PARAMETER, got %ld\n", i, GetLastError());
            continue;
        }
 
        old_prot = 0xdeadbeef;
        SetLastError(0xdeadbeef);
        ret = VirtualProtect(base, si.dwPageSize, PAGE_NOACCESS, &old_prot);
        ok(ret, "%ld: VirtualProtect error %ld\n", i, GetLastError());
        /* FIXME: remove the condition below once Wine is fixed */
        todo_wine_if (td[i].prot == PAGE_WRITECOPY || td[i].prot == PAGE_EXECUTE_WRITECOPY)
            ok(old_prot == td[i].prot_after_write, "%ld: got %#lx != expected %#lx\n", i, old_prot, td[i].prot_after_write);
 
        UnmapViewOfFile(base);
    }
 
    CloseHandle(hmap);
 
    CloseHandle(hfile);
    DeleteFileA(file_name);
}

Referenced by START_TEST().

test_IsBadCodePtr()

static void test_IsBadCodePtr ( void  )

static

Definition at line 1691 of file virtual.c.

{
    BOOL ret;
    void *ptr = (void *)0xdeadbeef;
    char stackval;
 
    ret = IsBadCodePtr(NULL);
    ok(ret == TRUE, "Expected IsBadCodePtr to return TRUE, got %d\n", ret);
 
    ret = IsBadCodePtr(ptr);
    ok(ret == TRUE, "Expected IsBadCodePtr to return TRUE, got %d\n", ret);
 
    ret = IsBadCodePtr((void *)&stackval);
    ok(ret == FALSE, "Expected IsBadCodePtr to return FALSE, got %d\n", ret);
}

Referenced by START_TEST().

test_IsBadReadPtr()

static void test_IsBadReadPtr ( void  )

static

Definition at line 1629 of file virtual.c.

{
    BOOL ret;
    void *ptr = (void *)0xdeadbeef;
    char stackvar;
 
    ret = IsBadReadPtr(NULL, 0);
    ok(ret == FALSE, "Expected IsBadReadPtr to return FALSE, got %d\n", ret);
 
    ret = IsBadReadPtr(NULL, 1);
    ok(ret == TRUE, "Expected IsBadReadPtr to return TRUE, got %d\n", ret);
 
    ret = IsBadReadPtr(ptr, 0);
    ok(ret == FALSE, "Expected IsBadReadPtr to return FALSE, got %d\n", ret);
 
    ret = IsBadReadPtr(ptr, 1);
    ok(ret == TRUE, "Expected IsBadReadPtr to return TRUE, got %d\n", ret);
 
    ret = IsBadReadPtr(&stackvar, 0);
    ok(ret == FALSE, "Expected IsBadReadPtr to return FALSE, got %d\n", ret);
 
    ret = IsBadReadPtr(&stackvar, sizeof(char));
    ok(ret == FALSE, "Expected IsBadReadPtr to return FALSE, got %d\n", ret);
 
    ret = IsBadReadPtr((char *)NtCurrentTeb()->DeallocationStack + 4096, sizeof(DWORD));
    ok(ret == TRUE, "Expected IsBadReadPtr to return TRUE, got %d\n", ret);
 
    ret = IsBadReadPtr((char *)NtCurrentTeb()->DeallocationStack + 4096, sizeof(DWORD));
    ok(ret == TRUE, "Expected IsBadReadPtr to return TRUE, got %d\n", ret);
}

Referenced by START_TEST().

test_IsBadWritePtr()

static void test_IsBadWritePtr ( void  )

static

Definition at line 1660 of file virtual.c.

{
    BOOL ret;
    void *ptr = (void *)0xdeadbeef;
    char stackval;
 
    ret = IsBadWritePtr(NULL, 0);
    ok(ret == FALSE, "Expected IsBadWritePtr to return FALSE, got %d\n", ret);
 
    ret = IsBadWritePtr(NULL, 1);
    ok(ret == TRUE, "Expected IsBadWritePtr to return TRUE, got %d\n", ret);
 
    ret = IsBadWritePtr(ptr, 0);
    ok(ret == FALSE, "Expected IsBadWritePtr to return FALSE, got %d\n", ret);
 
    ret = IsBadWritePtr(ptr, 1);
    ok(ret == TRUE, "Expected IsBadWritePtr to return TRUE, got %d\n", ret);
 
    ret = IsBadWritePtr(&stackval, 0);
    ok(ret == FALSE, "Expected IsBadWritePtr to return FALSE, got %d\n", ret);
 
    ret = IsBadWritePtr(&stackval, sizeof(char));
    ok(ret == FALSE, "Expected IsBadWritePtr to return FALSE, got %d\n", ret);
 
    ret = IsBadWritePtr((char *)NtCurrentTeb()->DeallocationStack + 4096, sizeof(DWORD));
    ok(ret == TRUE, "Expected IsBadWritePtr to return TRUE, got %d\n", ret);
 
    ret = IsBadWritePtr((char *)NtCurrentTeb()->DeallocationStack + 4096, sizeof(DWORD));
    ok(ret == TRUE, "Expected IsBadWritePtr to return TRUE, got %d\n", ret);
}

Referenced by START_TEST().

test_mapping()

static void test_mapping ( HANDLE  hfile, DWORD  sec_flags, BOOL  readonly  )

static

Definition at line 3896 of file virtual.c.

{
    static const DWORD page_prot[] =
    {
        PAGE_NOACCESS, PAGE_READONLY, PAGE_READWRITE, PAGE_WRITECOPY,
        PAGE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE, PAGE_EXECUTE_WRITECOPY
    };
    static const struct
    {
        DWORD access, prot;
    } view[] =
    {
        { 0, PAGE_NOACCESS }, /* 0x00 */
        { FILE_MAP_COPY, PAGE_WRITECOPY }, /* 0x01 */
        { FILE_MAP_WRITE, PAGE_READWRITE }, /* 0x02 */
        { FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_READWRITE }, /* 0x03 */
        { FILE_MAP_READ, PAGE_READONLY }, /* 0x04 */
        { FILE_MAP_READ | FILE_MAP_COPY, PAGE_READONLY }, /* 0x05 */
        { FILE_MAP_READ | FILE_MAP_WRITE, PAGE_READWRITE }, /* 0x06 */
        { FILE_MAP_READ | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_READWRITE }, /* 0x07 */
        { SECTION_MAP_EXECUTE, PAGE_NOACCESS }, /* 0x08 */
        { SECTION_MAP_EXECUTE | FILE_MAP_COPY, PAGE_NOACCESS }, /* 0x09 */
        { SECTION_MAP_EXECUTE | FILE_MAP_WRITE, PAGE_READWRITE }, /* 0x0a */
        { SECTION_MAP_EXECUTE | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_READWRITE }, /* 0x0b */
        { SECTION_MAP_EXECUTE | FILE_MAP_READ, PAGE_READONLY }, /* 0x0c */
        { SECTION_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_COPY, PAGE_READONLY }, /* 0x0d */
        { SECTION_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_WRITE, PAGE_READWRITE }, /* 0x0e */
        { SECTION_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_READWRITE }, /* 0x0f */
        { FILE_MAP_EXECUTE, PAGE_NOACCESS }, /* 0x20 */
        { FILE_MAP_EXECUTE | FILE_MAP_COPY, PAGE_EXECUTE_WRITECOPY }, /* 0x21 */
        { FILE_MAP_EXECUTE | FILE_MAP_WRITE, PAGE_EXECUTE_READWRITE }, /* 0x22 */
        { FILE_MAP_EXECUTE | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_EXECUTE_READWRITE }, /* 0x23 */
        { FILE_MAP_EXECUTE | FILE_MAP_READ, PAGE_EXECUTE_READ }, /* 0x24 */
        { FILE_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_COPY, PAGE_EXECUTE_READ }, /* 0x25 */
        { FILE_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_WRITE, PAGE_EXECUTE_READWRITE }, /* 0x26 */
        { FILE_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_EXECUTE_READWRITE }, /* 0x27 */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE, PAGE_NOACCESS }, /* 0x28 */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_COPY, PAGE_NOACCESS }, /* 0x29 */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_WRITE, PAGE_EXECUTE_READWRITE }, /* 0x2a */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_EXECUTE_READWRITE }, /* 0x2b */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_READ, PAGE_EXECUTE_READ }, /* 0x2c */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_COPY, PAGE_EXECUTE_READ }, /* 0x2d */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_WRITE, PAGE_EXECUTE_READWRITE }, /* 0x2e */
        { FILE_MAP_EXECUTE | SECTION_MAP_EXECUTE | FILE_MAP_READ | FILE_MAP_WRITE | FILE_MAP_COPY, PAGE_EXECUTE_READWRITE } /* 0x2f */
    };
    void *base, *nt_base, *ptr;
    DWORD i, j, k, ret, old_prot, prev_prot, alloc_prot;
    HANDLE hmap;
    MEMORY_BASIC_INFORMATION info, nt_info;
    BOOL anon_mapping = (hfile == INVALID_HANDLE_VALUE);
 
    trace( "testing %s mapping flags %08lx %s\n", anon_mapping ? "anonymous" : "file",
            sec_flags, readonly ? "readonly file" : "" );
    for (i = 0; i < ARRAY_SIZE(page_prot); i++)
    {
        SetLastError(0xdeadbeef);
        hmap = CreateFileMappingW(hfile, NULL, page_prot[i] | sec_flags, 0, 2*si.dwPageSize, NULL);
 
        if (readonly && (page_prot[i] == PAGE_READWRITE || page_prot[i] == PAGE_EXECUTE_READ
                    || page_prot[i] == PAGE_EXECUTE_READWRITE || page_prot[i] == PAGE_EXECUTE_WRITECOPY))
        {
            todo_wine_if(page_prot[i] == PAGE_EXECUTE_READ || page_prot[i] == PAGE_EXECUTE_WRITECOPY)
            {
                ok(!hmap, "%ld: CreateFileMapping(%04lx) should fail\n", i, page_prot[i]);
                ok(GetLastError() == ERROR_ACCESS_DENIED || broken(GetLastError() == ERROR_INVALID_PARAMETER),
                        "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
            }
            if (hmap) CloseHandle(hmap);
            continue;
        }
 
        if (page_prot[i] == PAGE_NOACCESS)
        {
            HANDLE hmap2;
 
            ok(!hmap, "CreateFileMapping(PAGE_NOACCESS) should fail\n");
            ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
 
            /* A trick to create a not accessible mapping */
            SetLastError(0xdeadbeef);
            if (sec_flags & SEC_IMAGE)
                hmap = CreateFileMappingW(hfile, NULL, PAGE_WRITECOPY | sec_flags, 0, si.dwPageSize, NULL);
            else
                hmap = CreateFileMappingW(hfile, NULL, PAGE_READONLY | sec_flags, 0, si.dwPageSize, NULL);
            ok(hmap != 0, "CreateFileMapping(PAGE_READWRITE) error %ld\n", GetLastError());
            SetLastError(0xdeadbeef);
            ret = DuplicateHandle(GetCurrentProcess(), hmap, GetCurrentProcess(), &hmap2, 0, FALSE, 0);
            ok(ret, "DuplicateHandle error %ld\n", GetLastError());
            CloseHandle(hmap);
            hmap = hmap2;
        }
        if (page_prot[i] == PAGE_EXECUTE)
        {
            ok(!hmap, "CreateFileMapping(PAGE_EXECUTE) should fail\n");
            ok(GetLastError() == ERROR_INVALID_PARAMETER,
               "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
            continue;
        }
 
        if (!hmap)
        {
            trace("%ld: CreateFileMapping(%04lx) failed: %ld\n", i, page_prot[i], GetLastError());
 
            if ((sec_flags & SEC_IMAGE) &&
                (page_prot[i] == PAGE_READWRITE || page_prot[i] == PAGE_EXECUTE_READWRITE))
                continue;  /* SEC_IMAGE doesn't support write access */
 
            /* NT4 and win2k don't support EXEC on file mappings */
            if (page_prot[i] == PAGE_EXECUTE_READ || page_prot[i] == PAGE_EXECUTE_READWRITE)
            {
                ok(broken(!hmap), "%ld: CreateFileMapping doesn't support PAGE_EXECUTE\n", i);
                continue;
            }
            /* Vista+ supports PAGE_EXECUTE_WRITECOPY, earlier versions don't */
            if (page_prot[i] == PAGE_EXECUTE_WRITECOPY)
            {
                ok(broken(!hmap), "%ld: CreateFileMapping doesn't support PAGE_EXECUTE_WRITECOPY\n", i);
                continue;
            }
        }
 
        ok(hmap != 0, "%ld: CreateFileMapping(%04lx) error %ld\n", i, page_prot[i], GetLastError());
 
        for (j = 0; j < ARRAY_SIZE(view); j++)
        {
            nt_base = map_view_of_file(hmap, view[j].access);
            if (nt_base)
            {
                SetLastError(0xdeadbeef);
                ret = VirtualQuery(nt_base, &nt_info, sizeof(nt_info));
                ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
                UnmapViewOfFile(nt_base);
            }
 
            SetLastError(0xdeadbeef);
            base = MapViewOfFile(hmap, view[j].access, 0, 0, 0);
 
            /* Vista+ supports FILE_MAP_EXECUTE properly, earlier versions don't */
            ok(!nt_base == !base ||
               broken((view[j].access & FILE_MAP_EXECUTE) && !nt_base != !base),
               "%ld: (%04lx/%04lx) NT %p kernel %p\n", j, page_prot[i], view[j].access, nt_base, base);
 
            if (!is_compatible_access(page_prot[i], view[j].access))
            {
                /* FILE_MAP_EXECUTE | FILE_MAP_COPY broken on XP */
                if (base != NULL && view[j].access == (FILE_MAP_EXECUTE | FILE_MAP_COPY))
                {
                    ok( broken(base != NULL), "%ld: MapViewOfFile(%04lx/%04lx) should fail\n",
                        j, page_prot[i], view[j].access);
                    UnmapViewOfFile( base );
                }
                else
                {
                    ok(!base, "%ld: MapViewOfFile(%04lx/%04lx) should fail\n",
                       j, page_prot[i], view[j].access);
                    ok(GetLastError() == ERROR_ACCESS_DENIED, "wrong error %ld\n", GetLastError());
                }
                continue;
            }
 
            /* Vista+ properly supports FILE_MAP_EXECUTE, earlier versions don't */
            if (!base && (view[j].access & FILE_MAP_EXECUTE))
            {
                ok(broken(!base), "%ld: MapViewOfFile(%04lx/%04lx) failed %ld\n", j, page_prot[i], view[j].access, GetLastError());
                continue;
            }
 
            ok(base != NULL, "%ld: MapViewOfFile(%04lx/%04lx) failed %ld\n", j, page_prot[i], view[j].access, GetLastError());
 
            SetLastError(0xdeadbeef);
            ret = VirtualQuery(base, &info, sizeof(info));
            ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
            ok(info.BaseAddress == base, "%ld: (%04lx) got %p, expected %p\n", j, view[j].access, info.BaseAddress, base);
            ok(info.RegionSize == 2*si.dwPageSize || (info.RegionSize == si.dwPageSize && (sec_flags & SEC_IMAGE)),
               "%ld: (%04lx) got %#Ix != expected %#lx\n", j, view[j].access, info.RegionSize, 2*si.dwPageSize);
            if (sec_flags & SEC_IMAGE)
                ok(info.Protect == PAGE_READONLY,
                    "%ld: (%04lx) got %#lx, expected %#lx\n", j, view[j].access, info.Protect, view[j].prot);
            else
                ok(info.Protect == view[j].prot ||
                   broken(view[j].prot == PAGE_EXECUTE_READ && info.Protect == PAGE_READONLY) || /* win2k */
                   broken(view[j].prot == PAGE_EXECUTE_READWRITE && info.Protect == PAGE_READWRITE) || /* win2k */
                   broken(view[j].prot == PAGE_EXECUTE_WRITECOPY && info.Protect == PAGE_NOACCESS), /* XP */
                   "%ld: (%04lx) got %#lx, expected %#lx\n", j, view[j].access, info.Protect, view[j].prot);
            ok(info.AllocationBase == base, "%ld: (%04lx) got %p, expected %p\n", j, view[j].access, info.AllocationBase, base);
            if (sec_flags & SEC_IMAGE)
                ok(info.AllocationProtect == PAGE_EXECUTE_WRITECOPY, "%ld: (%04lx) got %#lx, expected %#lx\n",
                   j, view[j].access, info.AllocationProtect, info.Protect);
            else
                ok(info.AllocationProtect == info.Protect, "%ld: (%04lx) got %#lx, expected %#lx\n",
                   j, view[j].access, info.AllocationProtect, info.Protect);
            ok(info.State == MEM_COMMIT, "%ld: (%04lx) got %#lx, expected MEM_COMMIT\n", j, view[j].access, info.State);
            ok(info.Type == (sec_flags & SEC_IMAGE) ? SEC_IMAGE : MEM_MAPPED,
               "%ld: (%04lx) got %#lx, expected MEM_MAPPED\n", j, view[j].access, info.Type);
 
            if (nt_base && base)
            {
                ok(nt_info.RegionSize == info.RegionSize, "%ld: (%04lx) got %#Ix != expected %#Ix\n", j, view[j].access, nt_info.RegionSize, info.RegionSize);
                ok(nt_info.Protect == info.Protect /* Vista+ */ ||
                   broken(nt_info.AllocationProtect == PAGE_EXECUTE_WRITECOPY && info.Protect == PAGE_NOACCESS), /* XP */
                   "%ld: (%04lx) got %#lx, expected %#lx\n", j, view[j].access, nt_info.Protect, info.Protect);
                ok(nt_info.AllocationProtect == info.AllocationProtect /* Vista+ */ ||
                   broken(nt_info.AllocationProtect == PAGE_EXECUTE_WRITECOPY && info.Protect == PAGE_NOACCESS), /* XP */
                   "%ld: (%04lx) got %#lx, expected %#lx\n", j, view[j].access, nt_info.AllocationProtect, info.AllocationProtect);
                ok(nt_info.State == info.State, "%ld: (%04lx) got %#lx, expected %#lx\n", j, view[j].access, nt_info.State, info.State);
                ok(nt_info.Type == info.Type, "%ld: (%04lx) got %#lx, expected %#lx\n", j, view[j].access, nt_info.Type, info.Type);
            }
 
            prev_prot = info.Protect;
            alloc_prot = info.AllocationProtect;
 
            for (k = 0; k < ARRAY_SIZE(page_prot); k++)
            {
                /*trace("map %#x, view %#x, requested prot %#x\n", page_prot[i], view[j].prot, page_prot[k]);*/
                DWORD actual_prot = (sec_flags & SEC_IMAGE) ? map_prot_no_write(page_prot[k]) : page_prot[k];
                SetLastError(0xdeadbeef);
                old_prot = 0xdeadbeef;
                ret = VirtualProtect(base, si.dwPageSize, page_prot[k], &old_prot);
                if (is_compatible_protection(alloc_prot, actual_prot))
                {
                    /* win2k and XP don't support EXEC on file mappings */
                    if (!ret && (page_prot[k] == PAGE_EXECUTE || page_prot[k] == PAGE_EXECUTE_WRITECOPY || view[j].prot == PAGE_EXECUTE_WRITECOPY))
                    {
                        ok(broken(!ret), "VirtualProtect doesn't support PAGE_EXECUTE\n");
                        continue;
                    }
 
                    todo_wine_if(readonly && page_prot[k] == PAGE_WRITECOPY && view[j].prot != PAGE_WRITECOPY)
                    ok(ret, "VirtualProtect error %ld, map %#lx, view %#lx, requested prot %#lx\n", GetLastError(), page_prot[i], view[j].prot, page_prot[k]);
                    todo_wine_if(readonly && page_prot[k] == PAGE_WRITECOPY && view[j].prot != PAGE_WRITECOPY)
                    ok(old_prot == prev_prot, "got %#lx, expected %#lx\n", old_prot, prev_prot);
                    prev_prot = actual_prot;
 
                    ret = VirtualQuery(base, &info, sizeof(info));
                    ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
                    todo_wine_if(readonly && page_prot[k] == PAGE_WRITECOPY && view[j].prot != PAGE_WRITECOPY)
                    ok(info.Protect == actual_prot,
                       "VirtualProtect wrong prot, map %#lx, view %#lx, requested prot %#lx got %#lx\n",
                       page_prot[i], view[j].prot, page_prot[k], info.Protect );
                }
                else
                {
                    ok(!ret, "VirtualProtect should fail, map %#lx, view %#lx, requested prot %#lx\n", page_prot[i], view[j].prot, page_prot[k]);
                    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
                }
            }
 
            for (k = 0; k < ARRAY_SIZE(page_prot); k++)
            {
                /*trace("map %#x, view %#x, requested prot %#x\n", page_prot[i], view[j].prot, page_prot[k]);*/
                SetLastError(0xdeadbeef);
                ptr = VirtualAlloc(base, si.dwPageSize, MEM_COMMIT, page_prot[k]);
                if (anon_mapping)
                {
                    if (is_compatible_protection(view[j].prot, page_prot[k]))
                    {
                        ok(ptr != NULL, "VirtualAlloc error %lu, map %#lx, view %#lx, requested prot %#lx\n",
                           GetLastError(), page_prot[i], view[j].prot, page_prot[k]);
                    }
                    else
                    {
                        /* versions <= Vista accept all protections without checking */
                        ok(!ptr || broken(ptr != NULL),
                           "VirtualAlloc should fail, map %#lx, view %#lx, requested prot %#lx\n",
                           page_prot[i], view[j].prot, page_prot[k]);
                        if (!ptr) ok( GetLastError() == ERROR_INVALID_PARAMETER,
                                      "wrong error %lu\n", GetLastError());
                    }
                    if (ptr)
                    {
                        ret = VirtualQuery(base, &info, sizeof(info));
                        ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
                        ok(info.Protect == page_prot[k] ||
                           /* if the mapping doesn't have write access,
                            *  broken versions silently switch to WRITECOPY */
                           broken( info.Protect == map_prot_no_write(page_prot[k]) ),
                           "VirtualAlloc wrong prot, map %#lx, view %#lx, requested prot %#lx got %#lx\n",
                           page_prot[i], view[j].prot, page_prot[k], info.Protect );
                    }
                }
                else
                {
                    ok(!ptr, "VirtualAlloc(%02lx) should fail\n", page_prot[k]);
                    ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %ld\n", GetLastError());
                }
            }
 
            if (!anon_mapping && is_compatible_protection(alloc_prot, PAGE_WRITECOPY))
            {
                ret = VirtualProtect(base, sec_flags & SEC_IMAGE ? si.dwPageSize : 2*si.dwPageSize, PAGE_WRITECOPY, &old_prot);
                todo_wine_if(readonly && view[j].prot != PAGE_WRITECOPY)
                ok(ret, "VirtualProtect error %ld, map %#lx, view %#lx\n", GetLastError(), page_prot[i], view[j].prot);
                if (ret) *(DWORD*)base = 0xdeadbeef;
                ret = VirtualQuery(base, &info, sizeof(info));
                ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
                todo_wine
                ok(info.Protect == PAGE_READWRITE, "VirtualProtect wrong prot, map %#lx, view %#lx got %#lx\n",
                   page_prot[i], view[j].prot, info.Protect );
                todo_wine_if (!(sec_flags & SEC_IMAGE))
                ok(info.RegionSize == si.dwPageSize, "wrong region size %#Ix after write, map %#lx, view %#lx got %#lx\n",
                   info.RegionSize, page_prot[i], view[j].prot, info.Protect );
 
                prev_prot = info.Protect;
                alloc_prot = info.AllocationProtect;
 
                if (!(sec_flags & SEC_IMAGE))
                {
                    ret = VirtualQuery((char*)base + si.dwPageSize, &info, sizeof(info));
                    ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
                    todo_wine_if(readonly && view[j].prot != PAGE_WRITECOPY)
                    ok(info.Protect == PAGE_WRITECOPY, "wrong prot, map %#lx, view %#lx got %#lx\n",
                       page_prot[i], view[j].prot, info.Protect);
                }
 
                for (k = 0; k < ARRAY_SIZE(page_prot); k++)
                {
                    DWORD actual_prot = (sec_flags & SEC_IMAGE) ? map_prot_no_write(page_prot[k]) : page_prot[k];
                    SetLastError(0xdeadbeef);
                    old_prot = 0xdeadbeef;
                    ret = VirtualProtect(base, si.dwPageSize, page_prot[k], &old_prot);
                    if (is_compatible_protection(alloc_prot, actual_prot))
                    {
                        /* win2k and XP don't support EXEC on file mappings */
                        if (!ret && (page_prot[k] == PAGE_EXECUTE || page_prot[k] == PAGE_EXECUTE_WRITECOPY || view[j].prot == PAGE_EXECUTE_WRITECOPY))
                        {
                            ok(broken(!ret), "VirtualProtect doesn't support PAGE_EXECUTE\n");
                            continue;
                        }
 
                        todo_wine_if(readonly && page_prot[k] == PAGE_WRITECOPY && view[j].prot != PAGE_WRITECOPY)
                        ok(ret, "VirtualProtect error %ld, map %#lx, view %#lx, requested prot %#lx\n", GetLastError(), page_prot[i], view[j].prot, page_prot[k]);
                        todo_wine_if(readonly && page_prot[k] == PAGE_WRITECOPY && view[j].prot != PAGE_WRITECOPY)
                        ok(old_prot == prev_prot, "got %#lx, expected %#lx\n", old_prot, prev_prot);
 
                        ret = VirtualQuery(base, &info, sizeof(info));
                        ok(ret, "%ld: VirtualQuery failed %ld\n", j, GetLastError());
                        todo_wine_if( map_prot_written( page_prot[k] ) != actual_prot )
                        ok(info.Protect == map_prot_written( page_prot[k] ),
                           "VirtualProtect wrong prot, map %#lx, view %#lx, requested prot %#lx got %#lx\n",
                           page_prot[i], view[j].prot, page_prot[k], info.Protect );
                        prev_prot = info.Protect;
                    }
                    else
                    {
                        ok(!ret, "VirtualProtect should fail, map %#lx, view %#lx, requested prot %#lx\n", page_prot[i], view[j].prot, page_prot[k]);
                        ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
                    }
                }
            }
            UnmapViewOfFile(base);
        }
 
        CloseHandle(hmap);
    }
}

Referenced by test_mappings().

test_mappings()

static void test_mappings ( void  )

static

Definition at line 4252 of file virtual.c.

{
    char temp_path[MAX_PATH];
    char file_name[MAX_PATH];
    DWORD data, num_bytes;
    HANDLE hfile;
 
    GetTempPathA(MAX_PATH, temp_path);
    GetTempFileNameA(temp_path, "map", 0, file_name);
 
    hfile = CreateFileA(file_name, GENERIC_READ|GENERIC_WRITE|GENERIC_EXECUTE, 0, NULL, CREATE_ALWAYS, 0, 0);
    ok(hfile != INVALID_HANDLE_VALUE, "CreateFile(%s) error %ld\n", file_name, GetLastError());
    SetFilePointer(hfile, 2*si.dwPageSize, NULL, FILE_BEGIN);
    SetEndOfFile(hfile);
 
    test_mapping( hfile, SEC_COMMIT, FALSE );
 
    /* test that file was not modified */
    SetFilePointer(hfile, 0, NULL, FILE_BEGIN);
    ok(ReadFile(hfile, &data, sizeof(data), &num_bytes, NULL), "ReadFile failed\n");
    ok(num_bytes == sizeof(data), "num_bytes = %ld\n", num_bytes);
    todo_wine
    ok(!data, "data = %lx\n", data);
 
    CloseHandle( hfile );
 
    hfile = CreateFileA(file_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
    ok(hfile != INVALID_HANDLE_VALUE, "CreateFile(%s) error %ld\n", file_name, GetLastError());
 
    test_mapping( hfile, SEC_COMMIT, TRUE );
 
    CloseHandle( hfile );
    DeleteFileA( file_name );
 
    /* SEC_IMAGE mapping */
    GetSystemDirectoryA( file_name, MAX_PATH );
    strcat( file_name, "\\kernel32.dll" );
 
    hfile = CreateFileA( file_name, GENERIC_READ|GENERIC_EXECUTE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
    ok(hfile != INVALID_HANDLE_VALUE, "CreateFile(%s) error %ld\n", file_name, GetLastError());
 
    test_mapping( hfile, SEC_IMAGE, FALSE );
 
    CloseHandle( hfile );
 
    /* now anonymous mappings */
    test_mapping( INVALID_HANDLE_VALUE, SEC_COMMIT, FALSE );
}

Referenced by START_TEST().

test_MapViewOfFile()

static void test_MapViewOfFile ( void  )

static

Definition at line 564 of file virtual.c.

{
    static const char testfile[] = "testfile.xxx";
    const char *name;
    HANDLE file, mapping, map2;
    void *ptr, *ptr2, *addr;
    SECTION_BASIC_INFORMATION section_info;
    SECTION_IMAGE_INFORMATION image_info;
    MEMORY_BASIC_INFORMATION info;
    BOOL ret;
    SIZE_T size;
    NTSTATUS status;
    SIZE_T info_size;
    LARGE_INTEGER map_size;
 
    SetLastError(0xdeadbeef);
    file = CreateFileA( testfile, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
    SetFilePointer( file, 12288, NULL, FILE_BEGIN );
    SetEndOfFile( file );
 
    /* read/write mapping */
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_COPY error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile 0 error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_WRITE error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    ret = DuplicateHandle( GetCurrentProcess(), mapping, GetCurrentProcess(), &map2,
                           FILE_MAP_READ|FILE_MAP_WRITE, FALSE, 0 );
    ok( ret, "DuplicateHandle failed error %lu\n", GetLastError());
    ptr = MapViewOfFile( map2, FILE_MAP_WRITE, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_WRITE error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
    CloseHandle( map2 );
 
    ret = DuplicateHandle( GetCurrentProcess(), mapping, GetCurrentProcess(), &map2,
                           FILE_MAP_READ, FALSE, 0 );
    ok( ret, "DuplicateHandle failed error %lu\n", GetLastError());
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( map2, FILE_MAP_WRITE, 0, 0, 4096 );
    ok( !ptr, "MapViewOfFile succeeded\n" );
    ok( GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
    CloseHandle( map2 );
    ret = DuplicateHandle( GetCurrentProcess(), mapping, GetCurrentProcess(), &map2, 0, FALSE, 0 );
    ok( ret, "DuplicateHandle failed error %lu\n", GetLastError());
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( map2, 0, 0, 0, 4096 );
    ok( !ptr, "MapViewOfFile succeeded\n" );
    ok( GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
    CloseHandle( map2 );
    ret = DuplicateHandle( GetCurrentProcess(), mapping, GetCurrentProcess(), &map2,
                           FILE_MAP_READ, FALSE, 0 );
    ok( ret, "DuplicateHandle failed error %lu\n", GetLastError());
    ptr = MapViewOfFile( map2, 0, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile NO_ACCESS error %lu\n", GetLastError() );
 
    UnmapViewOfFile( ptr );
    CloseHandle( map2 );
    CloseHandle( mapping );
 
    /* read-only mapping */
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_COPY error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile 0 error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
    ok( !ptr, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
    CloseHandle( mapping );
 
    /* copy-on-write mapping */
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_WRITECOPY, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_COPY, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_COPY error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, 0, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile 0 error %lu\n", GetLastError() );
    UnmapViewOfFile( ptr );
 
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 4096 );
    ok( !ptr, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
    CloseHandle( mapping );
 
    /* no access mapping */
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_NOACCESS, 0, 4096, NULL );
    ok( !mapping, "CreateFileMappingA succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "Wrong error %ld\n", GetLastError() );
    CloseHandle( file );
 
    /* now try read-only file */
 
    SetLastError(0xdeadbeef);
    file = CreateFileA( testfile, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
    ok( !mapping, "CreateFileMapping PAGE_READWRITE succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_WRITECOPY, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping PAGE_WRITECOPY error %lu\n", GetLastError() );
    CloseHandle( mapping );
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping PAGE_READONLY error %lu\n", GetLastError() );
    CloseHandle( mapping );
    CloseHandle( file );
 
    /* now try no access file */
 
    SetLastError(0xdeadbeef);
    file = CreateFileA( testfile, 0, 0, NULL, OPEN_EXISTING, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
    ok( !mapping, "CreateFileMapping PAGE_READWRITE succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_WRITECOPY, 0, 4096, NULL );
    ok( !mapping, "CreateFileMapping PAGE_WRITECOPY succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
    ok( !mapping, "CreateFileMapping PAGE_READONLY succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
 
    CloseHandle( file );
    DeleteFileA( testfile );
 
    SetLastError(0xdeadbeef);
    name = "Local\\Foo";
    file = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4090, name );
    /* nt4 doesn't have Local\\ */
    if (!file && GetLastError() == ERROR_PATH_NOT_FOUND)
    {
        name = "Foo";
        file = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4090, name );
    }
    ok( file != 0, "CreateFileMapping PAGE_READWRITE error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    mapping = OpenFileMappingA( FILE_MAP_READ, FALSE, name );
    ok( mapping != 0, "OpenFileMapping FILE_MAP_READ error %lu\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
    ok( !ptr, "MapViewOfFile FILE_MAP_WRITE succeeded\n" );
    ok( GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    SetLastError(0xdeadbeef);
    size = VirtualQuery( ptr, &info, sizeof(info) );
    ok( size == sizeof(info),
        "VirtualQuery error %lu\n", GetLastError() );
    ok( info.BaseAddress == ptr, "%p != %p\n", info.BaseAddress, ptr );
    ok( info.AllocationBase == ptr, "%p != %p\n", info.AllocationBase, ptr );
    ok( info.AllocationProtect == PAGE_READONLY, "%lx != PAGE_READONLY\n", info.AllocationProtect );
    ok( info.RegionSize == 4096, "%Ix != 4096\n", info.RegionSize );
    ok( info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State );
    ok( info.Protect == PAGE_READONLY, "%lx != PAGE_READONLY\n", info.Protect );
    UnmapViewOfFile( ptr );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( status == STATUS_ACCESS_DENIED, "NtQuerySection failed err %lx\n", status );
    CloseHandle( mapping );
    mapping = OpenFileMappingA( FILE_MAP_READ | SECTION_QUERY, FALSE, name );
    ok( mapping != 0, "OpenFileMapping FILE_MAP_READ error %lu\n", GetLastError() );
    info_size = (SIZE_T)0xdeadbeef << 16;
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( info_size == sizeof(section_info), "NtQuerySection wrong size %Iu\n", info_size );
    ok( section_info.Attributes == SEC_COMMIT, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == info.RegionSize, "NtQuerySection wrong size %lx%08lx / %08Ix\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart, info.RegionSize );
    CloseHandle( mapping );
 
    SetLastError(0xdeadbeef);
    mapping = OpenFileMappingA( FILE_MAP_WRITE, FALSE, name );
    ok( mapping != 0, "OpenFileMapping FILE_MAP_WRITE error %lu\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
    ok( !ptr, "MapViewOfFile succeeded\n" );
    ok( GetLastError() == ERROR_ACCESS_DENIED, "Wrong error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_WRITE error %lu\n", GetLastError() );
    SetLastError(0xdeadbeef);
    size = VirtualQuery( ptr, &info, sizeof(info) );
    ok( size == sizeof(info),
        "VirtualQuery error %lu\n", GetLastError() );
    ok( info.BaseAddress == ptr, "%p != %p\n", info.BaseAddress, ptr );
    ok( info.AllocationBase == ptr, "%p != %p\n", info.AllocationBase, ptr );
    ok( info.AllocationProtect == PAGE_READWRITE, "%lx != PAGE_READWRITE\n", info.AllocationProtect );
    ok( info.RegionSize == 4096, "%Ix != 4096\n", info.RegionSize );
    ok( info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State );
    ok( info.Protect == PAGE_READWRITE, "%lx != PAGE_READWRITE\n", info.Protect );
    UnmapViewOfFile( ptr );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( status == STATUS_ACCESS_DENIED, "NtQuerySection failed err %lx\n", status );
    CloseHandle( mapping );
 
    mapping = OpenFileMappingA( FILE_MAP_WRITE | SECTION_QUERY, FALSE, name );
    ok( mapping != 0, "OpenFileMapping FILE_MAP_WRITE error %lu\n", GetLastError() );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( info_size == sizeof(section_info), "NtQuerySection wrong size %Iu\n", info_size );
    ok( section_info.Attributes == SEC_COMMIT, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == info.RegionSize, "NtQuerySection wrong size %lx%08lx / %08Ix\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart, info.RegionSize );
    CloseHandle( mapping );
 
    CloseHandle( file );
 
    /* read/write mapping with SEC_RESERVE */
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE | SEC_RESERVE, 0, MAPPING_SIZE, NULL);
    ok(mapping != 0, "CreateFileMappingA failed with error %ld\n", GetLastError());
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), NULL );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( section_info.Attributes == SEC_RESERVE, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == MAPPING_SIZE, "NtQuerySection wrong size %lx%08lx / %08x\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart, MAPPING_SIZE );
 
    ptr = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    ok(ptr != NULL, "MapViewOfFile failed with error %ld\n", GetLastError());
 
    ptr2 = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    ok( ptr2 != NULL, "MapViewOfFile failed with error %ld\n", GetLastError());
    ok( ptr != ptr2, "MapViewOfFile returned same pointer\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "BaseAddress should have been %p but was %p instead\n", ptr, info.BaseAddress);
    ok(info.AllocationBase == ptr, "AllocationBase should have been %p but was %p instead\n", ptr, info.AllocationBase);
    ok(info.RegionSize == MAPPING_SIZE, "RegionSize should have been 0x%x but was 0x%Ix\n", MAPPING_SIZE, info.RegionSize);
    ok(info.State == MEM_RESERVE, "State should have been MEM_RESERVE instead of 0x%lx\n", info.State);
    ok(info.AllocationProtect == PAGE_READWRITE,
       "AllocationProtect should have been PAGE_READWRITE but was 0x%lx\n", info.AllocationProtect);
    ok(info.Protect == 0, "Protect should have been 0 instead of 0x%lx\n", info.Protect);
    ok(info.Type == MEM_MAPPED, "Type should have been MEM_MAPPED instead of 0x%lx\n", info.Type);
 
    ret = VirtualQuery(ptr2, &info, sizeof(info));
    ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr2,
       "BaseAddress should have been %p but was %p instead\n", ptr2, info.BaseAddress);
    ok(info.AllocationBase == ptr2,
       "AllocationBase should have been %p but was %p instead\n", ptr2, info.AllocationBase);
    ok(info.AllocationProtect == PAGE_READWRITE,
       "AllocationProtect should have been PAGE_READWRITE but was 0x%lx\n", info.AllocationProtect);
    ok(info.RegionSize == MAPPING_SIZE,
       "RegionSize should have been 0x%x but was 0x%Ix\n", MAPPING_SIZE, info.RegionSize);
    ok(info.State == MEM_RESERVE, "State should have been MEM_RESERVE instead of 0x%lx\n", info.State);
    ok(info.Protect == 0, "Protect should have been 0 instead of 0x%lx\n", info.Protect);
    ok(info.Type == MEM_MAPPED, "Type should have been MEM_MAPPED instead of 0x%lx\n", info.Type);
 
    ptr = VirtualAlloc(ptr, 0x10000, MEM_COMMIT, PAGE_READONLY);
    ok(ptr != NULL, "VirtualAlloc failed with error %ld\n", GetLastError());
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "BaseAddress should have been %p but was %p instead\n", ptr, info.BaseAddress);
    ok(info.AllocationBase == ptr, "AllocationBase should have been %p but was %p instead\n", ptr, info.AllocationBase);
    ok(info.RegionSize == 0x10000, "RegionSize should have been 0x10000 but was 0x%Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "State should have been MEM_COMMIT instead of 0x%lx\n", info.State);
    ok(info.Protect == PAGE_READONLY, "Protect should have been PAGE_READONLY instead of 0x%lx\n", info.Protect);
    ok(info.AllocationProtect == PAGE_READWRITE,
       "AllocationProtect should have been PAGE_READWRITE but was 0x%lx\n", info.AllocationProtect);
    ok(info.Type == MEM_MAPPED, "Type should have been MEM_MAPPED instead of 0x%lx\n", info.Type);
 
    /* shows that the VirtualAlloc above affects the mapping, not just the
     * virtual memory in this process - it also affects all other processes
     * with a view of the mapping, but that isn't tested here */
    ret = VirtualQuery(ptr2, &info, sizeof(info));
    ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr2,
       "BaseAddress should have been %p but was %p instead\n", ptr2, info.BaseAddress);
    ok(info.AllocationBase == ptr2,
       "AllocationBase should have been %p but was %p instead\n", ptr2, info.AllocationBase);
    ok(info.AllocationProtect == PAGE_READWRITE,
       "AllocationProtect should have been PAGE_READWRITE but was 0x%lx\n", info.AllocationProtect);
    ok(info.RegionSize == 0x10000,
       "RegionSize should have been 0x10000 but was 0x%Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT,
       "State should have been MEM_COMMIT instead of 0x%lx\n", info.State);
    ok(info.Protect == PAGE_READWRITE,
       "Protect should have been PAGE_READWRITE instead of 0x%lx\n", info.Protect);
    ok(info.Type == MEM_MAPPED, "Type should have been MEM_MAPPED instead of 0x%lx\n", info.Type);
 
    addr = VirtualAlloc( ptr, MAPPING_SIZE, MEM_RESET, PAGE_READONLY );
    ok( addr == ptr, "VirtualAlloc failed with error %lu\n", GetLastError() );
 
    ret = VirtualFree( ptr, 0x10000, MEM_DECOMMIT );
    ok( !ret, "VirtualFree succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "VirtualFree failed with %lu\n", GetLastError() );
 
    ret = UnmapViewOfFile(ptr2);
    ok(ret, "UnmapViewOfFile failed with error %ld\n", GetLastError());
    ret = UnmapViewOfFile(ptr);
    ok(ret, "UnmapViewOfFile failed with error %ld\n", GetLastError());
    CloseHandle(mapping);
 
    /* same thing with SEC_COMMIT */
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE | SEC_COMMIT, 0, MAPPING_SIZE, NULL);
    ok(mapping != 0, "CreateFileMappingA failed with error %ld\n", GetLastError());
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), NULL );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( section_info.Attributes == SEC_COMMIT, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == MAPPING_SIZE, "NtQuerySection wrong size %lx%08lx / %08x\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart, MAPPING_SIZE );
 
    ptr = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    ok(ptr != NULL, "MapViewOfFile failed with error %ld\n", GetLastError());
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "wrong BaseAddress %p/%p\n", ptr, info.BaseAddress);
    ok(info.AllocationBase == ptr, "wrong AllocationBase %p/%p\n", ptr, info.AllocationBase);
    ok(info.RegionSize == MAPPING_SIZE, "wrong RegionSize 0x%Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State);
    ok(info.AllocationProtect == PAGE_READWRITE, "wrong AllocationProtect 0x%lx\n", info.AllocationProtect);
    ok(info.Protect == PAGE_READWRITE, "wrong Protect 0x%lx\n", info.Protect);
    ok(info.Type == MEM_MAPPED, "wrong Type 0x%lx\n", info.Type);
 
    ptr = VirtualAlloc(ptr, 0x10000, MEM_COMMIT, PAGE_READONLY);
    ok(ptr != NULL, "VirtualAlloc failed with error %ld\n", GetLastError());
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "wrong BaseAddress %p/%p\n", ptr, info.BaseAddress);
    ok(info.AllocationBase == ptr, "wrong AllocationBase %p/%p\n", ptr, info.AllocationBase);
    ok(info.RegionSize == 0x10000, "wrong RegionSize 0x%Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State);
    ok(info.AllocationProtect == PAGE_READWRITE, "wrong AllocationProtect 0x%lx\n", info.AllocationProtect);
    ok(info.Protect == PAGE_READONLY, "wrong Protect 0x%lx\n", info.Protect);
    ok(info.Type == MEM_MAPPED, "wrong Type 0x%lx\n", info.Type);
 
    addr = VirtualAlloc( ptr, MAPPING_SIZE, MEM_RESET, PAGE_READONLY );
    ok( addr == ptr, "VirtualAlloc failed with error %lu\n", GetLastError() );
 
    ret = VirtualFree( ptr, 0x10000, MEM_DECOMMIT );
    ok( !ret, "VirtualFree succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "VirtualFree failed with %lu\n", GetLastError() );
 
    ret = UnmapViewOfFile(ptr);
    ok(ret, "UnmapViewOfFile failed with error %ld\n", GetLastError());
    CloseHandle(mapping);
 
    /* same thing with SEC_NOCACHE (only supported on recent Windows versions) */
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE | SEC_COMMIT | SEC_NOCACHE,
                                 0, MAPPING_SIZE, NULL);
    ok(mapping != 0, "CreateFileMappingA failed with error %ld\n", GetLastError());
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), NULL );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( section_info.Attributes == (SEC_COMMIT | SEC_NOCACHE) ||
        broken(section_info.Attributes == SEC_COMMIT),
        "NtQuerySection wrong attr %08lx\n", section_info.Attributes );
    if (section_info.Attributes & SEC_NOCACHE)
    {
        ptr = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
        ok(ptr != NULL, "MapViewOfFile failed with error %ld\n", GetLastError());
 
        ret = VirtualQuery(ptr, &info, sizeof(info));
        ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
        ok(info.BaseAddress == ptr, "wrong BaseAddress %p/%p\n", ptr, info.BaseAddress);
        ok(info.AllocationBase == ptr, "wrong AllocationBase %p/%p\n", ptr, info.AllocationBase);
        ok(info.RegionSize == MAPPING_SIZE, "wrong RegionSize 0x%Ix\n", info.RegionSize);
        ok(info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State);
        ok(info.AllocationProtect == (PAGE_READWRITE | PAGE_NOCACHE),
           "wrong AllocationProtect 0x%lx\n", info.AllocationProtect);
        ok(info.Protect == (PAGE_READWRITE | PAGE_NOCACHE), "wrong Protect 0x%lx\n", info.Protect);
        ok(info.Type == MEM_MAPPED, "wrong Type 0x%lx\n", info.Type);
 
        ptr = VirtualAlloc(ptr, 0x10000, MEM_COMMIT, PAGE_READONLY);
        ok(ptr != NULL, "VirtualAlloc failed with error %ld\n", GetLastError());
 
        ret = VirtualQuery(ptr, &info, sizeof(info));
        ok(ret, "VirtualQuery failed with error %ld\n", GetLastError());
        ok(info.BaseAddress == ptr, "wrong BaseAddress %p/%p\n", ptr, info.BaseAddress);
        ok(info.AllocationBase == ptr, "wrong AllocationBase %p/%p\n", ptr, info.AllocationBase);
        ok(info.RegionSize == 0x10000, "wrong RegionSize 0x%Ix\n", info.RegionSize);
        ok(info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State);
        ok(info.AllocationProtect == (PAGE_READWRITE | PAGE_NOCACHE),
           "wrong AllocationProtect 0x%lx\n", info.AllocationProtect);
        ok(info.Protect == (PAGE_READONLY | PAGE_NOCACHE), "wrong Protect 0x%lx\n", info.Protect);
        ok(info.Type == MEM_MAPPED, "wrong Type 0x%lx\n", info.Type);
 
        ret = UnmapViewOfFile(ptr);
        ok(ret, "UnmapViewOfFile failed with error %ld\n", GetLastError());
    }
    CloseHandle(mapping);
 
    addr = VirtualAlloc(NULL, 0x10000, MEM_COMMIT, PAGE_READONLY );
    ok( addr != NULL, "VirtualAlloc failed with error %lu\n", GetLastError() );
 
    SetLastError(0xdeadbeef);
    ok( !UnmapViewOfFile(addr), "UnmapViewOfFile should fail on VirtualAlloc mem\n" );
    ok( GetLastError() == ERROR_INVALID_ADDRESS,
        "got %lu, expected ERROR_INVALID_ADDRESS\n", GetLastError());
    SetLastError(0xdeadbeef);
    ok( !UnmapViewOfFile((char *)addr + 0x3000), "UnmapViewOfFile should fail on VirtualAlloc mem\n" );
    ok( GetLastError() == ERROR_INVALID_ADDRESS,
        "got %lu, expected ERROR_INVALID_ADDRESS\n", GetLastError());
    SetLastError(0xdeadbeef);
    ok( !UnmapViewOfFile((void *)0xdeadbeef), "UnmapViewOfFile should fail on VirtualAlloc mem\n" );
    ok( GetLastError() == ERROR_INVALID_ADDRESS,
       "got %lu, expected ERROR_INVALID_ADDRESS\n", GetLastError());
 
    ok( VirtualFree(addr, 0, MEM_RELEASE), "VirtualFree failed\n" );
 
    /* close named mapping handle without unmapping */
    name = "Foo";
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, MAPPING_SIZE, name);
    ok( mapping != 0, "CreateFileMappingA failed with error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    ok( ptr != NULL, "MapViewOfFile failed with error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    map2 = OpenFileMappingA(FILE_MAP_READ, FALSE, name);
    ok( map2 != 0, "OpenFileMappingA failed with error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ret = CloseHandle(map2);
    ok(ret, "CloseHandle error %ld\n", GetLastError());
    SetLastError(0xdeadbeef);
    ret = CloseHandle(mapping);
    ok(ret, "CloseHandle error %ld\n", GetLastError());
 
    ret = IsBadReadPtr(ptr, MAPPING_SIZE);
    ok( !ret, "memory is not accessible\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "got %p != expected %p\n", info.BaseAddress, ptr);
    ok(info.RegionSize == MAPPING_SIZE, "got %#Ix != expected %#x\n", info.RegionSize, MAPPING_SIZE);
    ok(info.Protect == PAGE_READWRITE, "got %#lx != expected PAGE_READWRITE\n", info.Protect);
    ok(info.AllocationBase == ptr, "%p != %p\n", info.AllocationBase, ptr);
    ok(info.AllocationProtect == PAGE_READWRITE, "%#lx != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
    ok(info.Type == MEM_MAPPED, "%#lx != MEM_MAPPED\n", info.Type);
 
    SetLastError(0xdeadbeef);
    map2 = OpenFileMappingA(FILE_MAP_READ, FALSE, name);
    ok( map2 == 0, "OpenFileMappingA succeeded\n" );
    ok( GetLastError() == ERROR_FILE_NOT_FOUND, "OpenFileMappingA set error %ld\n", GetLastError() );
    if (map2) CloseHandle(map2); /* FIXME: remove once Wine is fixed */
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, MAPPING_SIZE, name);
    ok( mapping != 0, "CreateFileMappingA failed\n" );
    ok( GetLastError() == ERROR_SUCCESS, "CreateFileMappingA set error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ret = CloseHandle(mapping);
    ok(ret, "CloseHandle error %ld\n", GetLastError());
 
    ret = IsBadReadPtr(ptr, MAPPING_SIZE);
    ok( !ret, "memory is not accessible\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "got %p != expected %p\n", info.BaseAddress, ptr);
    ok(info.RegionSize == MAPPING_SIZE, "got %#Ix != expected %#x\n", info.RegionSize, MAPPING_SIZE);
    ok(info.Protect == PAGE_READWRITE, "got %#lx != expected PAGE_READWRITE\n", info.Protect);
    ok(info.AllocationBase == ptr, "%p != %p\n", info.AllocationBase, ptr);
    ok(info.AllocationProtect == PAGE_READWRITE, "%#lx != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
    ok(info.Type == MEM_MAPPED, "%#lx != MEM_MAPPED\n", info.Type);
 
    SetLastError(0xdeadbeef);
    ret = UnmapViewOfFile(ptr);
    ok( ret, "UnmapViewOfFile failed with error %ld\n", GetLastError() );
 
    ret = IsBadReadPtr(ptr, MAPPING_SIZE);
    ok( ret, "memory is accessible\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "got %p != expected %p\n", info.BaseAddress, ptr);
    ok(info.Protect == PAGE_NOACCESS, "got %#lx != expected PAGE_NOACCESS\n", info.Protect);
    ok(info.AllocationBase == NULL, "%p != NULL\n", info.AllocationBase);
    ok(info.AllocationProtect == 0, "%#lx != 0\n", info.AllocationProtect);
    ok(info.State == MEM_FREE, "%#lx != MEM_FREE\n", info.State);
    ok(info.Type == 0, "%#lx != 0\n", info.Type);
 
    SetLastError(0xdeadbeef);
    file = CreateFileA(testfile, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
    SetFilePointer(file, 4096, NULL, FILE_BEGIN);
    SetEndOfFile(file);
 
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA(file, NULL, PAGE_READWRITE, 0, MAPPING_SIZE, name);
    ok( mapping != 0, "CreateFileMappingA failed with error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ptr = MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0);
    ok( ptr != NULL, "MapViewOfFile failed with error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    map2 = OpenFileMappingA(FILE_MAP_READ, FALSE, name);
    ok( map2 != 0, "OpenFileMappingA failed with error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ret = CloseHandle(map2);
    ok(ret, "CloseHandle error %ld\n", GetLastError());
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( info_size == sizeof(section_info), "NtQuerySection wrong size %Iu\n", info_size );
    ok( section_info.Attributes == SEC_FILE, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == MAPPING_SIZE, "NtQuerySection wrong size %lx%08lx\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart );
    SetLastError(0xdeadbeef);
    ret = CloseHandle(mapping);
    ok(ret, "CloseHandle error %ld\n", GetLastError());
 
    ret = IsBadReadPtr(ptr, MAPPING_SIZE);
    ok( !ret, "memory is not accessible\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "got %p != expected %p\n", info.BaseAddress, ptr);
    ok(info.RegionSize == MAPPING_SIZE, "got %#Ix != expected %#x\n", info.RegionSize, MAPPING_SIZE);
    ok(info.Protect == PAGE_READWRITE, "got %#lx != expected PAGE_READWRITE\n", info.Protect);
    ok(info.AllocationBase == ptr, "%p != %p\n", info.AllocationBase, ptr);
    ok(info.AllocationProtect == PAGE_READWRITE, "%#lx != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
    ok(info.Type == MEM_MAPPED, "%#lx != MEM_MAPPED\n", info.Type);
 
    SetLastError(0xdeadbeef);
    map2 = OpenFileMappingA(FILE_MAP_READ, FALSE, name);
    ok( map2 == 0, "OpenFileMappingA succeeded\n" );
    ok( GetLastError() == ERROR_FILE_NOT_FOUND, "OpenFileMappingA set error %ld\n", GetLastError() );
    CloseHandle(map2);
    SetLastError(0xdeadbeef);
    mapping = CreateFileMappingA(file, NULL, PAGE_READWRITE, 0, MAPPING_SIZE, name);
    ok( mapping != 0, "CreateFileMappingA failed\n" );
    ok( GetLastError() == ERROR_SUCCESS, "CreateFileMappingA set error %ld\n", GetLastError() );
    SetLastError(0xdeadbeef);
    ret = CloseHandle(mapping);
    ok(ret, "CloseHandle error %ld\n", GetLastError());
 
    ret = IsBadReadPtr(ptr, MAPPING_SIZE);
    ok( !ret, "memory is not accessible\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "got %p != expected %p\n", info.BaseAddress, ptr);
    ok(info.RegionSize == MAPPING_SIZE, "got %#Ix != expected %#x\n", info.RegionSize, MAPPING_SIZE);
    ok(info.Protect == PAGE_READWRITE, "got %#lx != expected PAGE_READWRITE\n", info.Protect);
    ok(info.AllocationBase == ptr, "%p != %p\n", info.AllocationBase, ptr);
    ok(info.AllocationProtect == PAGE_READWRITE, "%#lx != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.State == MEM_COMMIT, "%#lx != MEM_COMMIT\n", info.State);
    ok(info.Type == MEM_MAPPED, "%#lx != MEM_MAPPED\n", info.Type);
 
    SetLastError(0xdeadbeef);
    ret = UnmapViewOfFile(ptr);
    ok( ret, "UnmapViewOfFile failed with error %ld\n", GetLastError() );
 
    ret = IsBadReadPtr(ptr, MAPPING_SIZE);
    ok( ret, "memory is accessible\n" );
 
    ret = VirtualQuery(ptr, &info, sizeof(info));
    ok(ret, "VirtualQuery error %ld\n", GetLastError());
    ok(info.BaseAddress == ptr, "got %p != expected %p\n", info.BaseAddress, ptr);
    ok(info.Protect == PAGE_NOACCESS, "got %#lx != expected PAGE_NOACCESS\n", info.Protect);
    ok(info.AllocationBase == NULL, "%p != NULL\n", info.AllocationBase);
    ok(info.AllocationProtect == 0, "%#lx != 0\n", info.AllocationProtect);
    ok(info.State == MEM_FREE, "%#lx != MEM_FREE\n", info.State);
    ok(info.Type == 0, "%#lx != 0\n", info.Type);
 
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 12288, NULL );
    ok( mapping != NULL, "CreateFileMappingA failed with error %lu\n", GetLastError() );
 
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 12288 );
    ok( ptr != NULL, "MapViewOfFile failed with error %lu\n", GetLastError() );
 
    ret = UnmapViewOfFile( (char *)ptr + 100 );
    ok( ret, "UnmapViewOfFile failed with error %lu\n", GetLastError() );
 
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 12288 );
    ok( ptr != NULL, "MapViewOfFile failed with error %lu\n", GetLastError() );
 
    ret = UnmapViewOfFile( (char *)ptr + 4096 );
    ok( ret, "UnmapViewOfFile failed with error %lu\n", GetLastError() );
 
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 12288 );
    ok( ptr != NULL, "MapViewOfFile failed with error %lu\n", GetLastError() );
 
    ret = UnmapViewOfFile( (char *)ptr + 4096 + 100 );
    ok( ret, "UnmapViewOfFile failed with error %lu\n", GetLastError() );
 
    CloseHandle(mapping);
 
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 36, NULL );
    ok( mapping != NULL, "CreateFileMappingA failed with error %lu\n", GetLastError() );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( info_size == sizeof(section_info), "NtQuerySection wrong size %Iu\n", info_size );
    ok( section_info.Attributes == SEC_FILE, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == 36, "NtQuerySection wrong size %lx%08lx\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart );
    CloseHandle(mapping);
 
    SetFilePointer(file, 0x3456, NULL, FILE_BEGIN);
    SetEndOfFile(file);
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 0, NULL );
    ok( mapping != NULL, "CreateFileMappingA failed with error %lu\n", GetLastError() );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info,
                              sizeof(section_info), &info_size );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( info_size == sizeof(section_info), "NtQuerySection wrong size %Iu\n", info_size );
    ok( section_info.Attributes == SEC_FILE, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == 0x3456, "NtQuerySection wrong size %lx%08lx\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart );
    CloseHandle(mapping);
 
    map_size.QuadPart = 0x3457;
    status = pNtCreateSection( &mapping, SECTION_QUERY | SECTION_MAP_READ, NULL,
                               &map_size, PAGE_READONLY, SEC_COMMIT, file );
    ok( status == STATUS_SECTION_TOO_BIG, "NtCreateSection failed %lx\n", status );
    status = pNtCreateSection( &mapping, SECTION_QUERY | SECTION_MAP_READ, NULL,
                               &map_size, PAGE_READONLY, SEC_IMAGE, file );
    ok( status == STATUS_INVALID_IMAGE_NOT_MZ, "NtCreateSection failed %lx\n", status );
    if (!status) CloseHandle( mapping );
    map_size.QuadPart = 0x3452;
    status = pNtCreateSection( &mapping, SECTION_QUERY | SECTION_MAP_READ, NULL,
                               &map_size, PAGE_READONLY, SEC_COMMIT, file );
    ok( !status, "NtCreateSection failed %lx\n", status );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info, sizeof(section_info), NULL );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( section_info.Attributes == SEC_FILE, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == 0x3452, "NtQuerySection wrong size %lx%08lx\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart );
    size = map_size.QuadPart;
    status = pNtMapViewOfSection( mapping, GetCurrentProcess(), &ptr, 0, 0, NULL,
                                  &size, ViewShare, 0, PAGE_READONLY );
    ok( !status, "NtMapViewOfSection failed err %lx\n", status );
    pNtUnmapViewOfSection( GetCurrentProcess(), ptr );
    size = map_size.QuadPart + 1;
    status = pNtMapViewOfSection( mapping, GetCurrentProcess(), &ptr, 0, 0, NULL,
                                  &size, ViewShare, 0, PAGE_READONLY );
    ok( status == STATUS_INVALID_VIEW_SIZE, "NtMapViewOfSection failed err %lx\n", status );
    CloseHandle(mapping);
 
    status = pNtCreateSection( &mapping, SECTION_QUERY | SECTION_MAP_READ, NULL,
                               &map_size, PAGE_READONLY, SEC_COMMIT, 0 );
    ok( !status, "NtCreateSection failed %lx\n", status );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info, sizeof(section_info), NULL );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    ok( section_info.Attributes == SEC_COMMIT, "NtQuerySection wrong attr %08lx\n",
        section_info.Attributes );
    ok( section_info.BaseAddress == NULL, "NtQuerySection wrong base %p\n", section_info.BaseAddress );
    ok( section_info.Size.QuadPart == 0x4000, "NtQuerySection wrong size %lx%08lx\n",
        section_info.Size.u.HighPart, section_info.Size.u.LowPart );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info, sizeof(section_info)-1, NULL );
    ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQuerySection failed err %lx\n", status );
    status = pNtQuerySection( mapping, SectionBasicInformation, &section_info, sizeof(section_info)+1, NULL );
    ok( !status, "NtQuerySection failed err %lx\n", status );
    status = pNtQuerySection( mapping, SectionImageInformation, &image_info, sizeof(image_info)-1, NULL );
    ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQuerySection failed err %lx\n", status );
    status = pNtQuerySection( mapping, SectionImageInformation, &image_info, sizeof(image_info), NULL );
    ok( status == STATUS_SECTION_NOT_IMAGE, "NtQuerySection failed err %lx\n", status );
    status = pNtQuerySection( mapping, SectionImageInformation, &image_info, sizeof(image_info)+1, NULL );
    ok( status == STATUS_SECTION_NOT_IMAGE, "NtQuerySection failed err %lx\n", status );
    if (sizeof(SIZE_T) > sizeof(int))
    {
        status = pNtQuerySection( mapping, SectionImageInformation, &image_info,
                                  sizeof(image_info) + ((SIZE_T)0x10000000 << 8), NULL );
        todo_wine
        ok( status == STATUS_ACCESS_VIOLATION, "NtQuerySection wrong err %lx\n", status );
    }
    CloseHandle(mapping);
 
    SetFilePointer(file, 0, NULL, FILE_BEGIN);
    SetEndOfFile(file);
    status = pNtCreateSection( &mapping, SECTION_QUERY | SECTION_MAP_READ, NULL,
                               NULL, PAGE_READONLY, SEC_COMMIT, file );
    ok( status == STATUS_MAPPED_FILE_SIZE_ZERO, "NtCreateSection failed %lx\n", status );
    status = pNtCreateSection( &mapping, SECTION_QUERY | SECTION_MAP_READ, NULL,
                               NULL, PAGE_READONLY, SEC_IMAGE, file );
    ok( status == STATUS_INVALID_FILE_FOR_SECTION, "NtCreateSection failed %lx\n", status );
 
    CloseHandle(file);
    DeleteFileA(testfile);
}

Referenced by START_TEST().

test_NtAreMappedFilesTheSame()

static void test_NtAreMappedFilesTheSame ( void  )

static

Definition at line 1334 of file virtual.c.

{
    static const char testfile[] = "testfile.xxx";
    HANDLE file, file2, mapping, map2;
    void *ptr, *ptr2;
    NTSTATUS status;
    char path[MAX_PATH];
 
    if (!pNtAreMappedFilesTheSame)
    {
        win_skip( "NtAreMappedFilesTheSame not available\n" );
        return;
    }
 
    file = CreateFileA( testfile, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
                        NULL, CREATE_ALWAYS, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
    SetFilePointer( file, 4096, NULL, FILE_BEGIN );
    SetEndOfFile( file );
 
    mapping = CreateFileMappingA( file, NULL, PAGE_READWRITE, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping error %lu\n", GetLastError() );
 
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
 
    file2 = CreateFileA( testfile, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
                         NULL, OPEN_EXISTING, 0, 0 );
    ok( file2 != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
 
    map2 = CreateFileMappingA( file2, NULL, PAGE_READONLY, 0, 4096, NULL );
    ok( map2 != 0, "CreateFileMapping error %lu\n", GetLastError() );
    ptr2 = MapViewOfFile( map2, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr2 != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, ptr2 );
    ok( status == STATUS_NOT_SAME_DEVICE, "NtAreMappedFilesTheSame returned %lx\n", status );
    UnmapViewOfFile( ptr2 );
 
    ptr2 = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr2 != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, ptr2 );
    ok( status == STATUS_NOT_SAME_DEVICE, "NtAreMappedFilesTheSame returned %lx\n", status );
    UnmapViewOfFile( ptr2 );
    CloseHandle( map2 );
 
    map2 = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
    ok( map2 != 0, "CreateFileMapping error %lu\n", GetLastError() );
    ptr2 = MapViewOfFile( map2, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr2 != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, ptr2 );
    ok( status == STATUS_NOT_SAME_DEVICE, "NtAreMappedFilesTheSame returned %lx\n", status );
    UnmapViewOfFile( ptr2 );
    CloseHandle( map2 );
    CloseHandle( file2 );
 
    status = pNtAreMappedFilesTheSame( ptr, ptr );
    ok( status == STATUS_SUCCESS || broken(status == STATUS_NOT_SAME_DEVICE),
        "NtAreMappedFilesTheSame returned %lx\n", status );
 
    status = pNtAreMappedFilesTheSame( ptr, (char *)ptr + 30 );
    ok( status == STATUS_SUCCESS || broken(status == STATUS_NOT_SAME_DEVICE),
        "NtAreMappedFilesTheSame returned %lx\n", status );
 
    status = pNtAreMappedFilesTheSame( ptr, GetModuleHandleA("kernel32.dll") );
    ok( status == STATUS_NOT_SAME_DEVICE, "NtAreMappedFilesTheSame returned %lx\n", status );
 
    status = pNtAreMappedFilesTheSame( ptr, (void *)0xdeadbeef );
    ok( status == STATUS_CONFLICTING_ADDRESSES || status == STATUS_INVALID_ADDRESS,
        "NtAreMappedFilesTheSame returned %lx\n", status );
 
    status = pNtAreMappedFilesTheSame( ptr, NULL );
    ok( status == STATUS_INVALID_ADDRESS, "NtAreMappedFilesTheSame returned %lx\n", status );
 
    status = pNtAreMappedFilesTheSame( ptr, (void *)GetProcessHeap() );
    ok( status == STATUS_CONFLICTING_ADDRESSES, "NtAreMappedFilesTheSame returned %lx\n", status );
 
    status = pNtAreMappedFilesTheSame( NULL, NULL );
    ok( status == STATUS_INVALID_ADDRESS, "NtAreMappedFilesTheSame returned %lx\n", status );
 
    ptr2 = VirtualAlloc( NULL, 0x10000, MEM_COMMIT, PAGE_READWRITE );
    ok( ptr2 != NULL, "VirtualAlloc error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, ptr2 );
    ok( status == STATUS_CONFLICTING_ADDRESSES, "NtAreMappedFilesTheSame returned %lx\n", status );
    VirtualFree( ptr2, 0, MEM_RELEASE );
 
    UnmapViewOfFile( ptr );
    CloseHandle( mapping );
    CloseHandle( file );
 
    status = pNtAreMappedFilesTheSame( GetModuleHandleA("ntdll.dll"),
                                       GetModuleHandleA("kernel32.dll") );
    ok( status == STATUS_NOT_SAME_DEVICE, "NtAreMappedFilesTheSame returned %lx\n", status );
    status = pNtAreMappedFilesTheSame( GetModuleHandleA("kernel32.dll"),
                                       GetModuleHandleA("kernel32.dll") );
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
    status = pNtAreMappedFilesTheSame( GetModuleHandleA("kernel32.dll"),
                                       (char *)GetModuleHandleA("kernel32.dll") + 4096 );
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
 
    GetSystemDirectoryA( path, MAX_PATH );
    strcat( path, "\\kernel32.dll" );
    file = CreateFileA( path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
 
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY, 0, 4096, NULL );
    ok( mapping != 0, "CreateFileMapping error %lu\n", GetLastError() );
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 4096 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, GetModuleHandleA("kernel32.dll") );
    ok( status == STATUS_NOT_SAME_DEVICE, "NtAreMappedFilesTheSame returned %lx\n", status );
    status = pNtAreMappedFilesTheSame( GetModuleHandleA("kernel32.dll"), ptr );
    todo_wine
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
    UnmapViewOfFile( ptr );
    CloseHandle( mapping );
 
    mapping = CreateFileMappingA( file, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, NULL );
    ok( mapping != 0, "CreateFileMapping error %lu\n", GetLastError() );
    ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
    ok( ptr != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, GetModuleHandleA("kernel32.dll") );
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
    status = pNtAreMappedFilesTheSame( GetModuleHandleA("kernel32.dll"), ptr );
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
 
    file2 = CreateFileA( path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
    ok( file2 != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
    map2 = CreateFileMappingA( file2, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, NULL );
    ok( map2 != 0, "CreateFileMapping error %lu\n", GetLastError() );
    ptr2 = MapViewOfFile( map2, FILE_MAP_READ, 0, 0, 0 );
    ok( ptr2 != NULL, "MapViewOfFile FILE_MAP_READ error %lu\n", GetLastError() );
    status = pNtAreMappedFilesTheSame( ptr, ptr2 );
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
    status = pNtAreMappedFilesTheSame( ptr2, ptr );
    ok( status == STATUS_SUCCESS, "NtAreMappedFilesTheSame returned %lx\n", status );
    UnmapViewOfFile( ptr2 );
    CloseHandle( map2 );
    CloseHandle( file2 );
 
    UnmapViewOfFile( ptr );
    CloseHandle( mapping );
 
    CloseHandle( file );
    DeleteFileA( testfile );
}

Referenced by START_TEST().

test_PrefetchVirtualMemory()

static void test_PrefetchVirtualMemory ( void  )

static

Definition at line 4388 of file virtual.c.

{
#ifdef __REACTOS__
    skip("Cannot build test_PrefetchVirtualMemory() until kernelbase is synced.\n");
#else
    WIN32_MEMORY_RANGE_ENTRY entries[2];
    char stackmem[] = "Test stack mem";
    static char testmem[] = "Test memory range data";
    unsigned int page_size = si.dwPageSize;
    BOOL ret;
 
    if (!pPrefetchVirtualMemory)
    {
        skip("no PrefetchVirtualMemory in kernelbase\n");
        return;
    }
 
    ok( !pPrefetchVirtualMemory( GetCurrentProcess(), 0, NULL, 0 ),
        "PrefetchVirtualMemory unexpected success on 0 entries\n" );
 
    entries[0].VirtualAddress = ULongToPtr(PtrToUlong(testmem) & -(ULONG_PTR)page_size);
    entries[0].NumberOfBytes = page_size;
    ret = pPrefetchVirtualMemory( GetCurrentProcess(), 1, entries, 0 );
    ok( ret || broken( is_wow64 && GetLastError() == ERROR_INVALID_PARAMETER ) /* win10 1507 */,
        "PrefetchVirtualMemory unexpected status on 1 page-aligned entry: %ld\n", GetLastError() );
 
    entries[0].VirtualAddress = testmem;
    entries[0].NumberOfBytes = sizeof(testmem);
    ret = pPrefetchVirtualMemory( GetCurrentProcess(), 1, entries, 0 );
    ok( ret || broken( is_wow64 && GetLastError() == ERROR_INVALID_PARAMETER ) /* win10 1507 */,
        "PrefetchVirtualMemory unexpected status on 1 entry: %ld\n", GetLastError() );
 
    entries[0].VirtualAddress = NULL;
    entries[0].NumberOfBytes = page_size;
    ret = pPrefetchVirtualMemory( GetCurrentProcess(), 1, entries, 0 );
    ok( ret ||broken( is_wow64 && GetLastError() == ERROR_INVALID_PARAMETER ) /* win10 1507 */,
        "PrefetchVirtualMemory unexpected status on 1 unmapped entry: %ld\n", GetLastError() );
 
    entries[0].VirtualAddress = ULongToPtr(PtrToUlong(testmem) & -(ULONG_PTR)page_size);
    entries[0].NumberOfBytes = page_size;
    entries[1].VirtualAddress = ULongToPtr(PtrToUlong(stackmem) & -(ULONG_PTR)page_size);
    entries[1].NumberOfBytes = page_size;
    ret = pPrefetchVirtualMemory( GetCurrentProcess(), 2, entries, 0 );
    ok( ret ||broken( is_wow64 && GetLastError() == ERROR_INVALID_PARAMETER ) /* win10 1507 */,
        "PrefetchVirtualMemory unexpected status on 2 page-aligned entries: %ld\n", GetLastError() );
#endif
}

Referenced by START_TEST().

test_ReadProcessMemory()

static void test_ReadProcessMemory ( void  )

static

Definition at line 4436 of file virtual.c.

{
    BYTE *buf;
    DWORD old_prot;
    SIZE_T copied;
    HANDLE hproc;
    void *ptr;
    BOOL ret;
 
    buf = malloc(2 * si.dwPageSize);
    ok(buf != NULL, "OOM\n");
    ret = DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(),
            &hproc, 0, FALSE, DUPLICATE_SAME_ACCESS);
    ok(ret, "DuplicateHandle failed %lu\n", GetLastError());
    ptr = VirtualAlloc(NULL, 2 * si.dwPageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    ok(ptr != NULL, "Virtual failed %lu\n", GetLastError());
    ret = VirtualProtect(((BYTE *)ptr) + si.dwPageSize, si.dwPageSize, PAGE_NOACCESS, &old_prot);
    ok(ret, "VirtualProtect failed %lu\n", GetLastError());
 
    copied = 1;
    ret = ReadProcessMemory(GetCurrentProcess(), ptr, buf, 2 * si.dwPageSize, &copied);
    ok(!ret, "ReadProcessMemory succeeded\n");
    ok(!copied, "copied = %Id\n", copied);
    ok(GetLastError() == ERROR_PARTIAL_COPY, "GetLastError() = %lu\n", GetLastError());
 
    ret = ReadProcessMemory(GetCurrentProcess(), ptr, buf, si.dwPageSize, &copied);
    ok(ret, "ReadProcessMemory failed %lu\n", GetLastError());
    ok(copied == si.dwPageSize, "copied = %Id\n", copied);
 
    ret = ReadProcessMemory(hproc, ptr, buf, 2 * si.dwPageSize, &copied);
    todo_wine ok(!ret, "ReadProcessMemory succeeded\n");
 
    ret = ReadProcessMemory(hproc, ptr, buf, si.dwPageSize, &copied);
    ok(ret, "ReadProcessMemory failed %lu\n", GetLastError());
    ok(copied == si.dwPageSize, "copied = %Id\n", copied);
 
    ret = VirtualFree(ptr, 0, MEM_RELEASE);
    ok(ret, "VirtualFree failed %lu\n", GetLastError());
    CloseHandle(hproc);
    free(buf);
}

Referenced by START_TEST().

test_shared_memory()

static void test_shared_memory ( BOOL  is_child )

static

Definition at line 4301 of file virtual.c.

{
    HANDLE mapping;
    LONG *p;
 
    SetLastError(0xdeadbef);
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_virtual.c");
    ok(mapping != 0, "CreateFileMapping error %ld\n", GetLastError());
    if (is_child)
        ok(GetLastError() == ERROR_ALREADY_EXISTS, "expected ERROR_ALREADY_EXISTS, got %ld\n", GetLastError());
 
    SetLastError(0xdeadbef);
    p = MapViewOfFile(mapping, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 4096);
    ok(p != NULL, "MapViewOfFile error %ld\n", GetLastError());
 
    if (is_child)
    {
        ok(*p == 0x1a2b3c4d, "expected 0x1a2b3c4d in child, got %#lx\n", *p);
    }
    else
    {
        char **argv;
        char cmdline[MAX_PATH];
        PROCESS_INFORMATION pi;
        STARTUPINFOA si = { sizeof(si) };
        DWORD ret;
 
        *p = 0x1a2b3c4d;
 
        winetest_get_mainargs(&argv);
        sprintf(cmdline, "\"%s\" virtual sharedmem", argv[0]);
        ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
        ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
        wait_child_process(pi.hProcess);
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
    }
 
    UnmapViewOfFile(p);
    CloseHandle(mapping);
}

Referenced by START_TEST().

test_shared_memory_ro()

static void test_shared_memory_ro ( BOOL  is_child, DWORD  child_access  )

static

Definition at line 4343 of file virtual.c.

{
    HANDLE mapping;
    LONG *p;
 
    SetLastError(0xdeadbef);
    mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 4096, "winetest_virtual.c_ro");
    ok(mapping != 0, "CreateFileMapping error %ld\n", GetLastError());
    if (is_child)
        ok(GetLastError() == ERROR_ALREADY_EXISTS, "expected ERROR_ALREADY_EXISTS, got %ld\n", GetLastError());
 
    SetLastError(0xdeadbef);
    p = MapViewOfFile(mapping, is_child ? child_access : FILE_MAP_READ, 0, 0, 4096);
    ok(p != NULL, "MapViewOfFile error %ld\n", GetLastError());
 
    if (is_child)
    {
        *p = 0xdeadbeef;
    }
    else
    {
        char **argv;
        char cmdline[MAX_PATH];
        PROCESS_INFORMATION pi;
        STARTUPINFOA si = { sizeof(si) };
        DWORD ret;
 
        winetest_get_mainargs(&argv);
        sprintf(cmdline, "\"%s\" virtual sharedmemro %lx", argv[0], child_access);
        ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
        ok(ret, "CreateProcess(%s) error %ld\n", cmdline, GetLastError());
        wait_child_process(pi.hProcess);
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
 
        if(child_access & FILE_MAP_WRITE)
            ok(*p == 0xdeadbeef, "*p = %lx, expected 0xdeadbeef\n", *p);
        else
            ok(!*p, "*p = %lx, expected 0\n", *p);
    }
 
    UnmapViewOfFile(p);
    CloseHandle(mapping);
}

Referenced by START_TEST().

test_VirtualAlloc()

static void test_VirtualAlloc ( void  )

static

Definition at line 342 of file virtual.c.

{
    void *addr1, *addr2;
    DWORD old_prot;
    MEMORY_BASIC_INFORMATION info;
 
    SetLastError(0xdeadbeef);
    addr1 = VirtualAlloc(0, 0, MEM_RESERVE, PAGE_NOACCESS);
    ok(addr1 == NULL, "VirtualAlloc should fail on zero-sized allocation\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
        "got %ld, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    addr1 = VirtualAlloc(0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
    ok(addr1 != NULL, "VirtualAlloc failed\n");
 
    /* test a not committed memory */
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.AllocationProtect);
    ok(info.RegionSize == 0x10000, "%Ix != 0x10000\n", info.RegionSize);
    ok(info.State == MEM_RESERVE, "%lx != MEM_RESERVE\n", info.State);
    ok(info.Protect == 0, "%lx != PAGE_NOACCESS\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%lx != MEM_PRIVATE\n", info.Type);
 
    SetLastError(0xdeadbeef);
    ok(!VirtualProtect(addr1, 0xFFFC, PAGE_READONLY, &old_prot),
       "VirtualProtect should fail on a not committed memory\n");
    ok( GetLastError() == ERROR_INVALID_ADDRESS,
        "got %ld, expected ERROR_INVALID_ADDRESS\n", GetLastError());
 
    addr2 = VirtualAlloc(addr1, 0x1000, MEM_COMMIT, PAGE_NOACCESS);
    ok(addr1 == addr2, "VirtualAlloc failed\n");
 
    /* test a committed memory */
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.AllocationProtect);
    ok(info.RegionSize == 0x1000, "%Ix != 0x1000\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
    /* this time NT reports PAGE_NOACCESS as well */
    ok(info.Protect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%lx != MEM_PRIVATE\n", info.Type);
 
    /* this should fail, since not the whole range is committed yet */
    SetLastError(0xdeadbeef);
    ok(!VirtualProtect(addr1, 0xFFFC, PAGE_READONLY, &old_prot),
        "VirtualProtect should fail on a not committed memory\n");
    ok( GetLastError() == ERROR_INVALID_ADDRESS,
        "got %ld, expected ERROR_INVALID_ADDRESS\n", GetLastError());
 
    ok(VirtualProtect(addr1, 0x1000, PAGE_READONLY, &old_prot), "VirtualProtect failed\n");
    ok(old_prot == PAGE_NOACCESS,
        "wrong old protection: got %04lx instead of PAGE_NOACCESS\n", old_prot);
 
    ok(VirtualProtect(addr1, 0x1000, PAGE_READWRITE, &old_prot), "VirtualProtect failed\n");
    ok(old_prot == PAGE_READONLY,
        "wrong old protection: got %04lx instead of PAGE_READONLY\n", old_prot);
 
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.RegionSize == 0x1000, "%Ix != 0x1000\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
    ok(info.Protect == PAGE_READWRITE, "%lx != PAGE_READWRITE\n", info.Protect);
    memset( addr1, 0x55, 20 );
    ok( *(DWORD *)addr1 == 0x55555555, "wrong data %lx\n", *(DWORD *)addr1 );
 
    addr2 = VirtualAlloc( addr1, 0x1000, MEM_RESET, PAGE_NOACCESS );
    ok( addr2 == addr1, "VirtualAlloc failed err %lu\n", GetLastError() );
    ok( *(DWORD *)addr1 == 0x55555555 || *(DWORD *)addr1 == 0, "wrong data %lx\n", *(DWORD *)addr1 );
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info),
       "VirtualQuery failed\n");
    ok(info.RegionSize == 0x1000, "%Ix != 0x1000\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
    ok(info.Protect == PAGE_READWRITE, "%lx != PAGE_READWRITE\n", info.Protect);
 
    addr2 = VirtualAlloc( (char *)addr1 + 0x1000, 0x1000, MEM_RESET, PAGE_NOACCESS );
    ok( (char *)addr2 == (char *)addr1 + 0x1000, "VirtualAlloc failed\n" );
 
    ok(VirtualQuery(addr2, &info, sizeof(info)) == sizeof(info),
       "VirtualQuery failed\n");
    ok(info.RegionSize == 0xf000, "%Ix != 0xf000\n", info.RegionSize);
    ok(info.State == MEM_RESERVE, "%lx != MEM_RESERVE\n", info.State);
    ok(info.Protect == 0, "%lx != 0\n", info.Protect);
 
    addr2 = VirtualAlloc( (char *)addr1 + 0xf000, 0x2000, MEM_RESET, PAGE_NOACCESS );
    ok( !addr2, "VirtualAlloc failed\n" );
    ok( GetLastError() == ERROR_INVALID_ADDRESS, "wrong error %lu\n", GetLastError() );
 
    /* invalid protection values */
    SetLastError(0xdeadbeef);
    addr2 = VirtualAlloc(NULL, 0x1000, MEM_RESERVE, 0);
    ok(!addr2, "VirtualAlloc succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    addr2 = VirtualAlloc(NULL, 0x1000, MEM_COMMIT, 0);
    ok(!addr2, "VirtualAlloc succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    addr2 = VirtualAlloc(addr1, 0x1000, MEM_COMMIT, PAGE_READONLY | PAGE_EXECUTE);
    ok(!addr2, "VirtualAlloc succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ok(!VirtualProtect(addr1, 0x1000, PAGE_READWRITE | PAGE_EXECUTE_WRITECOPY, &old_prot),
       "VirtualProtect succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ok(!VirtualProtect(addr1, 0x1000, 0, &old_prot), "VirtualProtect succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ok(!VirtualFree(addr1, 0x10000, 0), "VirtualFree should fail with type 0\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
        "got %ld, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ok(!VirtualFree(addr1, 0, MEM_FREE), "VirtualFree should fail with type MEM_FREE\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
        "got %ld, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    ok(VirtualFree(addr1, 0x10000, MEM_DECOMMIT), "VirtualFree failed\n");
 
    /* if the type is MEM_RELEASE, size must be 0 */
    ok(!VirtualFree(addr1, 1, MEM_RELEASE), "VirtualFree should fail\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
        "got %ld, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
 
    /* PAGE_NOCACHE cannot be set per page in recent Windows */
    addr1 = VirtualAlloc( NULL, 0x2000, MEM_COMMIT, PAGE_READWRITE | PAGE_NOCACHE );
    ok( addr1 != NULL, "VirtualAlloc failed\n");
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info), "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == (PAGE_READWRITE | PAGE_NOCACHE),
       "wrong protect %lx\n", info.AllocationProtect);
    ok(info.RegionSize == 0x2000, "wrong size %Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong state %lx\n", info.State);
    ok(info.Protect == (PAGE_READWRITE | PAGE_NOCACHE), "wrong protect %lx\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "wrong type %lx\n", info.Type);
 
    ok(VirtualProtect(addr1, 0x1000, PAGE_READWRITE, &old_prot), "VirtualProtect failed\n");
    ok( old_prot == (PAGE_READWRITE | PAGE_NOCACHE), "wrong protect %lx\n", old_prot );
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info), "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == (PAGE_READWRITE | PAGE_NOCACHE),
       "wrong protect %lx\n", info.AllocationProtect);
    ok(info.RegionSize == 0x2000 || broken(info.RegionSize == 0x1000),
       "wrong size %Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong state %lx\n", info.State);
    ok(info.Protect == (PAGE_READWRITE | PAGE_NOCACHE) || broken(info.Protect == PAGE_READWRITE),
       "wrong protect %lx\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "wrong type %lx\n", info.Type);
 
    ok(VirtualProtect(addr1, 0x1000, PAGE_READONLY, &old_prot), "VirtualProtect failed\n");
    ok( old_prot == (PAGE_READWRITE | PAGE_NOCACHE) || broken(old_prot == PAGE_READWRITE),
        "wrong protect %lx\n", old_prot );
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info), "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == (PAGE_READWRITE | PAGE_NOCACHE),
       "wrong protect %lx\n", info.AllocationProtect);
    ok(info.RegionSize == 0x1000, "wrong size %Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong state %lx\n", info.State);
    ok(info.Protect == (PAGE_READONLY | PAGE_NOCACHE) || broken(info.Protect == PAGE_READONLY),
       "wrong protect %lx\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "wrong type %lx\n", info.Type);
 
    ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
 
    addr1 = VirtualAlloc( NULL, 0x2000, MEM_COMMIT, PAGE_READWRITE );
    ok( addr1 != NULL, "VirtualAlloc failed\n");
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info), "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == PAGE_READWRITE,
       "wrong protect %lx\n", info.AllocationProtect);
    ok(info.RegionSize == 0x2000, "wrong size %Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong state %lx\n", info.State);
    ok(info.Protect == PAGE_READWRITE, "wrong protect %lx\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "wrong type %lx\n", info.Type);
 
    ok(VirtualProtect(addr1, 0x1000, PAGE_READONLY | PAGE_NOCACHE, &old_prot), "VirtualProtect failed\n");
    ok( old_prot == PAGE_READWRITE, "wrong protect %lx\n", old_prot );
    ok(VirtualQuery(addr1, &info, sizeof(info)) == sizeof(info), "VirtualQuery failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == PAGE_READWRITE, "wrong protect %lx\n", info.AllocationProtect);
    ok(info.RegionSize == 0x1000, "wrong size %Ix\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "wrong state %lx\n", info.State);
    ok(info.Protect == PAGE_READONLY || broken(info.Protect == (PAGE_READONLY | PAGE_NOCACHE)),
       "wrong protect %lx\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "wrong type %lx\n", info.Type);
 
    ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
 
    /* memory returned by VirtualAlloc should be aligned to 64k */
    addr1 = VirtualAlloc(0, 0x2000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    ok(addr1 != NULL, "VirtualAlloc failed\n");
    ok(!((ULONG_PTR)addr1 & 0xffff), "returned memory %p is not aligned to 64k\n", addr1);
    ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
    addr2 = VirtualAlloc(addr1, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    ok(addr2 == addr1, "VirtualAlloc returned %p, expected %p\n", addr2, addr1);
 
    /* AT_ROUND_TO_PAGE flag is not supported for VirtualAlloc */
    SetLastError(0xdeadbeef);
    addr2 = VirtualAlloc(addr1, 0x1000, MEM_RESERVE | MEM_COMMIT | AT_ROUND_TO_PAGE, PAGE_EXECUTE_READWRITE);
    ok(!addr2, "VirtualAlloc unexpectedly succeeded\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER, "got %ld, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    ok(VirtualFree(addr1, 0, MEM_RELEASE), "VirtualFree failed\n");
}

Referenced by START_TEST().

test_VirtualAlloc_protection()

static void test_VirtualAlloc_protection ( void  )

static

Definition at line 3461 of file virtual.c.

{
    static const struct test_data
    {
        DWORD prot;
        BOOL success;
    } td[] =
    {
        { 0, FALSE }, /* 0x00 */
        { PAGE_NOACCESS, TRUE }, /* 0x01 */
        { PAGE_READONLY, TRUE }, /* 0x02 */
        { PAGE_READONLY | PAGE_NOACCESS, FALSE }, /* 0x03 */
        { PAGE_READWRITE, TRUE }, /* 0x04 */
        { PAGE_READWRITE | PAGE_NOACCESS, FALSE }, /* 0x05 */
        { PAGE_READWRITE | PAGE_READONLY, FALSE }, /* 0x06 */
        { PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, FALSE }, /* 0x07 */
        { PAGE_WRITECOPY, FALSE }, /* 0x08 */
        { PAGE_WRITECOPY | PAGE_NOACCESS, FALSE }, /* 0x09 */
        { PAGE_WRITECOPY | PAGE_READONLY, FALSE }, /* 0x0a */
        { PAGE_WRITECOPY | PAGE_NOACCESS | PAGE_READONLY, FALSE }, /* 0x0b */
        { PAGE_WRITECOPY | PAGE_READWRITE, FALSE }, /* 0x0c */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_NOACCESS, FALSE }, /* 0x0d */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY, FALSE }, /* 0x0e */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, FALSE }, /* 0x0f */
 
        { PAGE_EXECUTE, TRUE }, /* 0x10 */
        { PAGE_EXECUTE_READ, TRUE }, /* 0x20 */
        { PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE }, /* 0x30 */
        { PAGE_EXECUTE_READWRITE, TRUE }, /* 0x40 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, FALSE }, /* 0x50 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, FALSE }, /* 0x60 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE }, /* 0x70 */
        { PAGE_EXECUTE_WRITECOPY, FALSE }, /* 0x80 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE, FALSE }, /* 0x90 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ, FALSE }, /* 0xa0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE }, /* 0xb0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE, FALSE }, /* 0xc0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, FALSE }, /* 0xd0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, FALSE }, /* 0xe0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, FALSE } /* 0xf0 */
    };
    char *base, *ptr;
    DWORD ret, i;
    MEMORY_BASIC_INFORMATION info;
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        SetLastError(0xdeadbeef);
        base = VirtualAlloc(0, si.dwPageSize, MEM_COMMIT, td[i].prot);
 
        if (td[i].success)
        {
            ok(base != NULL, "%ld: VirtualAlloc failed %ld\n", i, GetLastError());
 
            SetLastError(0xdeadbeef);
            ret = VirtualQuery(base, &info, sizeof(info));
            ok(ret, "VirtualQuery failed %ld\n", GetLastError());
            ok(info.BaseAddress == base, "%ld: got %p != expected %p\n", i, info.BaseAddress, base);
            ok(info.RegionSize == si.dwPageSize, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, si.dwPageSize);
            ok(info.Protect == td[i].prot, "%ld: got %#lx != expected %#lx\n", i, info.Protect, td[i].prot);
            ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
            ok(info.AllocationProtect == td[i].prot, "%ld: %#lx != %#lx\n", i, info.AllocationProtect, td[i].prot);
            ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
            ok(info.Type == MEM_PRIVATE, "%ld: %#lx != MEM_PRIVATE\n", i, info.Type);
 
            if (is_mem_writable(info.Protect))
            {
                base[0] = 0xfe;
 
                SetLastError(0xdeadbeef);
                ret = VirtualQuery(base, &info, sizeof(info));
                ok(ret, "VirtualQuery failed %ld\n", GetLastError());
                ok(info.Protect == td[i].prot, "%ld: got %#lx != expected %#lx\n", i, info.Protect, td[i].prot);
            }
 
            SetLastError(0xdeadbeef);
            ptr = VirtualAlloc(base, si.dwPageSize, MEM_COMMIT, td[i].prot);
            ok(ptr == base, "%ld: VirtualAlloc failed %ld\n", i, GetLastError());
 
            VirtualFree(base, 0, MEM_RELEASE);
        }
        else
        {
            ok(!base, "%ld: VirtualAlloc should fail\n", i);
            ok(GetLastError() == ERROR_INVALID_PARAMETER, "%ld: expected ERROR_INVALID_PARAMETER, got %ld\n", i, GetLastError());
        }
    }
}

Referenced by START_TEST().

test_VirtualAllocEx()

static void test_VirtualAllocEx ( void  )

static

Definition at line 80 of file virtual.c.

{
    const unsigned int alloc_size = 1<<15;
    char *src, *dst;
    SIZE_T bytes_written = 0, bytes_read = 0, i;
    void *addr1, *addr2;
    BOOL b, ret;
    DWORD old_prot;
    MEMORY_BASIC_INFORMATION info;
    HANDLE hProcess;
    NTSTATUS status;
 
    /* Same process */
    addr1 = VirtualAllocEx(GetCurrentProcess(), NULL, alloc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    ok(!!addr1, "Failed to allocated, error %lu.\n", GetLastError());
    ret = VirtualFreeEx(NULL, addr1, 0, MEM_RELEASE);
    ok(!ret && GetLastError() == ERROR_INVALID_HANDLE, "Unexpected value %d, error %lu.\n", ret, GetLastError());
    addr2 = VirtualAllocEx(NULL, NULL, alloc_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    ok(!addr2 && GetLastError() == ERROR_INVALID_HANDLE, "Unexpected value %p, error %lu.\n", addr2, GetLastError());
    ret = VirtualFreeEx(GetCurrentProcess(), addr1, 0, MEM_RELEASE);
    ok(ret, "Unexpected value %d, error %lu.\n", ret, GetLastError());
 
    hProcess = create_target_process("sleep");
    ok(hProcess != NULL, "Can't start process\n");
 
    SetLastError(0xdeadbeef);
    addr1 = VirtualAllocEx(hProcess, NULL, alloc_size, MEM_COMMIT,
                           PAGE_EXECUTE_READWRITE);
    ok(addr1 != NULL, "VirtualAllocEx error %lu\n", GetLastError());
 
    src = VirtualAlloc( NULL, alloc_size, MEM_COMMIT, PAGE_READWRITE );
    dst = VirtualAlloc( NULL, alloc_size, MEM_COMMIT, PAGE_READWRITE );
    for (i = 0; i < alloc_size; i++)
        src[i] = i & 0xff;
 
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    ok(b && (bytes_written == alloc_size), "%Iu bytes written\n",
       bytes_written);
    b = ReadProcessMemory(hProcess, addr1, dst, alloc_size, &bytes_read);
    ok(b && (bytes_read == alloc_size), "%Iu bytes read\n", bytes_read);
    ok(!memcmp(src, dst, alloc_size), "Data from remote process differs\n");
    bytes_written = 0xdeadbeef;
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    ok( status == STATUS_SUCCESS, "wrong status %lx\n", status );
    ok( bytes_written == alloc_size, "%Iu bytes written\n", bytes_written );
    bytes_read = 0xdeadbeef;
    memset( dst, 0, alloc_size );
    status = pNtReadVirtualMemory( hProcess, addr1, dst, alloc_size, &bytes_read );
    ok( status == STATUS_SUCCESS, "wrong status %lx\n", status );
    ok( bytes_read == alloc_size, "%Iu bytes read\n", bytes_read );
    ok(!memcmp(src, dst, alloc_size), "Data from remote process differs\n");
 
    /* test 0 length */
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, 0, &bytes_written);
    ok((b && !bytes_written) || broken(!b && GetLastError() == ERROR_INVALID_PARAMETER), "write failed: %lu\n", GetLastError());
    bytes_read = 0xdeadbeef;
    b = ReadProcessMemory(hProcess, addr1, src, 0, &bytes_read);
    ok(b && !bytes_read, "read failed: %lu\n", GetLastError());
    bytes_written = 0xdeadbeef;
    status = pNtWriteVirtualMemory( hProcess, addr1, src, 0, &bytes_written );
    ok( status == STATUS_SUCCESS, "wrong status %lx\n", status );
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
    bytes_read = 0xdeadbeef;
    status = pNtReadVirtualMemory( hProcess, addr1, src, 0, &bytes_read );
    ok( status == STATUS_SUCCESS, "wrong status %lx\n", status );
    ok( !bytes_read, "%Iu bytes read\n", bytes_read );
 
    /* test invalid source buffers */
 
    b = VirtualProtect( src + 0x2000, 0x2000, PAGE_NOACCESS, &old_prot );
    ok( b, "VirtualProtect failed error %lu\n", GetLastError() );
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    ok( !b, "WriteProcessMemory succeeded\n" );
    ok( GetLastError() == ERROR_NOACCESS ||
        GetLastError() == ERROR_PARTIAL_COPY, /* vista */
        "wrong error %lu\n", GetLastError() );
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
    bytes_read = 0xdeadbeef;
    b = ReadProcessMemory(hProcess, addr1, src, alloc_size, &bytes_read);
    ok( !b, "ReadProcessMemory succeeded\n" );
    ok( GetLastError() == ERROR_NOACCESS ||
        GetLastError() == ERROR_PARTIAL_COPY, /* win10 v1607+ */
        "wrong error %lu\n", GetLastError() );
    if (GetLastError() == ERROR_NOACCESS)
        ok( bytes_read == 0, "%Iu bytes read\n", bytes_read );
    else
        ok( bytes_read == 0x2000, "%Iu bytes read\n", bytes_read );
    bytes_written = 0xdeadbeef;
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    ok( status == STATUS_PARTIAL_COPY, "wrong status %lx\n", status );
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
    bytes_read = 0xdeadbeef;
    status = pNtReadVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_read );
    ok( status == STATUS_PARTIAL_COPY || status == STATUS_ACCESS_VIOLATION, "wrong status %lx\n", status );
    ok( bytes_read == (status == STATUS_PARTIAL_COPY ? 0x2000 : 0), "%Iu bytes read\n", bytes_read );
 
    b = VirtualProtect( src, 0x2000, PAGE_NOACCESS, &old_prot );
    ok( b, "VirtualProtect failed error %lu\n", GetLastError() );
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    ok( !b, "WriteProcessMemory succeeded\n" );
    ok( GetLastError() == ERROR_NOACCESS ||
        GetLastError() == ERROR_PARTIAL_COPY, /* vista */
        "wrong error %lu\n", GetLastError() );
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
    bytes_read = 0xdeadbeef;
    b = ReadProcessMemory(hProcess, addr1, src, alloc_size, &bytes_read);
    ok( !b, "ReadProcessMemory succeeded\n" );
    ok( GetLastError() == ERROR_NOACCESS ||
        GetLastError() == ERROR_PARTIAL_COPY, /* win10 v1607+ */
        "wrong error %lu\n", GetLastError() );
    ok( bytes_read == 0, "%Iu bytes read\n", bytes_read );
    bytes_written = 0xdeadbeef;
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    ok( status == STATUS_PARTIAL_COPY, "wrong status %lx\n", status );
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
    bytes_read = 0xdeadbeef;
    status = pNtReadVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_read );
    ok( status == STATUS_PARTIAL_COPY || status == STATUS_ACCESS_VIOLATION, "wrong status %lx\n", status );
    ok( bytes_read == 0, "%Iu bytes read\n", bytes_read );
    b = VirtualProtect( src, alloc_size, PAGE_READWRITE, &old_prot );
    ok( b, "VirtualProtect failed error %lu\n", GetLastError() );
 
    /* test readonly buffers */
 
    b = VirtualProtectEx( hProcess, addr1, alloc_size, PAGE_READONLY, &old_prot );
    ok( b, "VirtualProtectEx, error %lu\n", GetLastError() );
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    ok( !b, "WriteProcessMemory succeeded\n" );
    if (!b) ok( GetLastError() == ERROR_NOACCESS, "wrong error %lu\n", GetLastError() );
    ok( bytes_written == 0xdeadbeef, "%Iu bytes written\n", bytes_written );
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    todo_wine
    ok( status == STATUS_PARTIAL_COPY || broken(status == STATUS_ACCESS_VIOLATION),
        "wrong status %lx\n", status );
    todo_wine
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
 
    b = VirtualProtectEx( hProcess, addr1, alloc_size, PAGE_EXECUTE_READ, &old_prot );
    ok( b, "VirtualProtectEx, error %lu\n", GetLastError() );
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    ok( b, "WriteProcessMemory failed\n" );
    ok( bytes_written == alloc_size, "%Iu bytes written\n", bytes_written );
    bytes_written = 0xdeadbeef;
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    todo_wine
    ok( status == STATUS_PARTIAL_COPY || broken(status == STATUS_ACCESS_VIOLATION),
        "wrong status %lx\n", status );
    todo_wine
    ok( bytes_written == 0, "%Iu bytes written\n", bytes_written );
 
    b = VirtualProtectEx( hProcess, addr1, 0x2000, PAGE_EXECUTE_READWRITE, &old_prot );
    ok( b, "VirtualProtectEx, error %lu\n", GetLastError() );
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    todo_wine
    ok( !b || broken(b), /* <= win10 1507 */ "WriteProcessMemory succeeded\n" );
    bytes_written = 0xdeadbeef;
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    todo_wine
    ok( status == STATUS_PARTIAL_COPY || broken(status == STATUS_SUCCESS), /* <= win10 1507 */
        "wrong status %lx\n", status );
    ok( bytes_written == (status ? 0x2000 : alloc_size), "%Iu bytes written\n", bytes_written );
 
    b = VirtualProtectEx( hProcess, (char *)addr1 + 0x2000, alloc_size - 0x2000, PAGE_READONLY, &old_prot );
    ok( b, "VirtualProtectEx, error %lu\n", GetLastError() );
    bytes_written = 0xdeadbeef;
    b = WriteProcessMemory(hProcess, addr1, src, alloc_size, &bytes_written);
    todo_wine
    ok( !b || broken(b), /* <= win10 1507 */ "WriteProcessMemory succeeded\n" );
    status = pNtWriteVirtualMemory( hProcess, addr1, src, alloc_size, &bytes_written );
    todo_wine
    ok( status == STATUS_PARTIAL_COPY || broken(status == STATUS_SUCCESS), /* <= win10 1507 */
        "wrong status %lx\n", status );
    ok( bytes_written == (status ? 0x2000 : alloc_size), "%Iu bytes written\n", bytes_written );
 
    VirtualFree( src, 0, MEM_RELEASE );
    VirtualFree( dst, 0, MEM_RELEASE );
 
    /*
     * The following tests parallel those in test_VirtualAlloc()
     */
 
    SetLastError(0xdeadbeef);
    addr1 = VirtualAllocEx(hProcess, 0, 0, MEM_RESERVE, PAGE_NOACCESS);
    ok(addr1 == NULL, "VirtualAllocEx should fail on zero-sized allocation\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
       "got %lu, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    addr1 = VirtualAllocEx(hProcess, 0, 0xFFFC, MEM_RESERVE, PAGE_NOACCESS);
    ok(addr1 != NULL, "VirtualAllocEx failed\n");
 
    /* test a not committed memory */
    memset(&info, 'q', sizeof(info));
    ok(VirtualQueryEx(hProcess, addr1, &info, sizeof(info)) == sizeof(info), "VirtualQueryEx failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.AllocationProtect);
    ok(info.RegionSize == 0x10000, "%Ix != 0x10000\n", info.RegionSize);
    ok(info.State == MEM_RESERVE, "%lx != MEM_RESERVE\n", info.State);
    ok(info.Protect == 0, "%lx != PAGE_NOACCESS\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%lx != MEM_PRIVATE\n", info.Type);
 
    SetLastError(0xdeadbeef);
    ok(!VirtualProtectEx(hProcess, addr1, 0xFFFC, PAGE_READONLY, &old_prot),
       "VirtualProtectEx should fail on a not committed memory\n");
    ok(GetLastError() == ERROR_INVALID_ADDRESS,
        "got %lu, expected ERROR_INVALID_ADDRESS\n", GetLastError());
 
    addr2 = VirtualAllocEx(hProcess, addr1, 0x1000, MEM_COMMIT, PAGE_NOACCESS);
    ok(addr1 == addr2, "VirtualAllocEx failed\n");
 
    /* test a committed memory */
    ok(VirtualQueryEx(hProcess, addr1, &info, sizeof(info)) == sizeof(info),
        "VirtualQueryEx failed\n");
    ok(info.BaseAddress == addr1, "%p != %p\n", info.BaseAddress, addr1);
    ok(info.AllocationBase == addr1, "%p != %p\n", info.AllocationBase, addr1);
    ok(info.AllocationProtect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.AllocationProtect);
    ok(info.RegionSize == 0x1000, "%Ix != 0x1000\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "%lx != MEM_COMMIT\n", info.State);
    /* this time NT reports PAGE_NOACCESS as well */
    ok(info.Protect == PAGE_NOACCESS, "%lx != PAGE_NOACCESS\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%lx != MEM_PRIVATE\n", info.Type);
 
    /* this should fail, since not the whole range is committed yet */
    SetLastError(0xdeadbeef);
    ok(!VirtualProtectEx(hProcess, addr1, 0xFFFC, PAGE_READONLY, &old_prot),
        "VirtualProtectEx should fail on a not committed memory\n");
    ok(GetLastError() == ERROR_INVALID_ADDRESS,
       "got %lu, expected ERROR_INVALID_ADDRESS\n", GetLastError());
 
    old_prot = 0;
    ok(VirtualProtectEx(hProcess, addr1, 0x1000, PAGE_READONLY, &old_prot), "VirtualProtectEx failed\n");
    ok(old_prot == PAGE_NOACCESS, "wrong old protection: got %04lx instead of PAGE_NOACCESS\n", old_prot);
 
    old_prot = 0;
    ok(VirtualProtectEx(hProcess, addr1, 0x1000, PAGE_READWRITE, &old_prot), "VirtualProtectEx failed\n");
    ok(old_prot == PAGE_READONLY, "wrong old protection: got %04lx instead of PAGE_READONLY\n", old_prot);
 
    ok(!VirtualFreeEx(hProcess, addr1, 0x10000, 0),
       "VirtualFreeEx should fail with type 0\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
        "got %lu, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    ok(VirtualFreeEx(hProcess, addr1, 0x10000, MEM_DECOMMIT), "VirtualFreeEx failed\n");
 
    /* if the type is MEM_RELEASE, size must be 0 */
    ok(!VirtualFreeEx(hProcess, addr1, 1, MEM_RELEASE),
       "VirtualFreeEx should fail\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
        "got %lu, expected ERROR_INVALID_PARAMETER\n", GetLastError());
 
    ok(VirtualFreeEx(hProcess, addr1, 0, MEM_RELEASE), "VirtualFreeEx failed\n");
 
    TerminateProcess(hProcess, 0);
    CloseHandle(hProcess);
}

Referenced by START_TEST().

test_VirtualProtect()

static void test_VirtualProtect ( void  )

static

Definition at line 3269 of file virtual.c.

{
    static const struct test_data
    {
        DWORD prot_set, prot_get;
    } td[] =
    {
        { 0, 0 }, /* 0x00 */
        { PAGE_NOACCESS, PAGE_NOACCESS }, /* 0x01 */
        { PAGE_READONLY, PAGE_READONLY }, /* 0x02 */
        { PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x03 */
        { PAGE_READWRITE, PAGE_READWRITE }, /* 0x04 */
        { PAGE_READWRITE | PAGE_NOACCESS, 0 }, /* 0x05 */
        { PAGE_READWRITE | PAGE_READONLY, 0 }, /* 0x06 */
        { PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x07 */
        { PAGE_WRITECOPY, 0 }, /* 0x08 */
        { PAGE_WRITECOPY | PAGE_NOACCESS, 0 }, /* 0x09 */
        { PAGE_WRITECOPY | PAGE_READONLY, 0 }, /* 0x0a */
        { PAGE_WRITECOPY | PAGE_NOACCESS | PAGE_READONLY, 0 }, /* 0x0b */
        { PAGE_WRITECOPY | PAGE_READWRITE, 0 }, /* 0x0c */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_NOACCESS, 0 }, /* 0x0d */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY, 0 }, /* 0x0e */
        { PAGE_WRITECOPY | PAGE_READWRITE | PAGE_READONLY | PAGE_NOACCESS, 0 }, /* 0x0f */
 
        { PAGE_EXECUTE, PAGE_EXECUTE }, /* 0x10 */
        { PAGE_EXECUTE_READ, PAGE_EXECUTE_READ }, /* 0x20 */
        { PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0x30 */
        { PAGE_EXECUTE_READWRITE, PAGE_EXECUTE_READWRITE }, /* 0x40 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, 0 }, /* 0x50 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, 0 }, /* 0x60 */
        { PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0x70 */
        { PAGE_EXECUTE_WRITECOPY, 0 }, /* 0x80 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE, 0 }, /* 0x90 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ, 0 }, /* 0xa0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 }, /* 0xb0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE, 0 }, /* 0xc0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE, 0 }, /* 0xd0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ, 0 }, /* 0xe0 */
        { PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE, 0 } /* 0xf0 */
    };
    char *base, *ptr;
    DWORD ret, old_prot, rw_prot, exec_prot, i, j;
    MEMORY_BASIC_INFORMATION info;
    void *addr;
    SIZE_T size;
    NTSTATUS status;
 
    SetLastError(0xdeadbeef);
    base = VirtualAlloc(0, si.dwPageSize, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
    ok(base != NULL, "VirtualAlloc failed %ld\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    ret = VirtualProtect(base, si.dwPageSize, PAGE_READONLY, NULL);
    ok(!ret, "VirtualProtect should fail\n");
    ok(GetLastError() == ERROR_NOACCESS, "expected ERROR_NOACCESS, got %ld\n", GetLastError());
    old_prot = 0xdeadbeef;
    ret = VirtualProtect(base, si.dwPageSize, PAGE_NOACCESS, &old_prot);
    ok(ret, "VirtualProtect failed %ld\n", GetLastError());
    ok(old_prot == PAGE_NOACCESS, "got %#lx != expected PAGE_NOACCESS\n", old_prot);
 
    addr = base;
    size = si.dwPageSize;
    status = pNtProtectVirtualMemory(GetCurrentProcess(), &addr, &size, PAGE_READONLY, NULL);
    ok(status == STATUS_ACCESS_VIOLATION, "NtProtectVirtualMemory should fail, got %08lx\n", status);
    addr = base;
    size = si.dwPageSize;
    old_prot = 0xdeadbeef;
    status = pNtProtectVirtualMemory(GetCurrentProcess(), &addr, &size, PAGE_NOACCESS, &old_prot);
    ok(status == STATUS_SUCCESS, "NtProtectVirtualMemory should succeed, got %08lx\n", status);
    ok(old_prot == PAGE_NOACCESS, "got %#lx != expected PAGE_NOACCESS\n", old_prot);
 
    for (i = 0; i < ARRAY_SIZE(td); i++)
    {
        SetLastError(0xdeadbeef);
        ret = VirtualQuery(base, &info, sizeof(info));
        ok(ret, "VirtualQuery failed %ld\n", GetLastError());
        ok(info.BaseAddress == base, "%ld: got %p != expected %p\n", i, info.BaseAddress, base);
        ok(info.RegionSize == si.dwPageSize, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, si.dwPageSize);
        ok(info.Protect == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, info.Protect);
        ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
        ok(info.AllocationProtect == PAGE_NOACCESS, "%ld: %#lx != PAGE_NOACCESS\n", i, info.AllocationProtect);
        ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
        ok(info.Type == MEM_PRIVATE, "%ld: %#lx != MEM_PRIVATE\n", i, info.Type);
 
        old_prot = 0xdeadbeef;
        SetLastError(0xdeadbeef);
        ret = VirtualProtect(base, si.dwPageSize, td[i].prot_set, &old_prot);
        if (td[i].prot_get)
        {
            ok(ret, "%ld: VirtualProtect error %ld\n", i, GetLastError());
            ok(old_prot == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, old_prot);
 
            SetLastError(0xdeadbeef);
            ret = VirtualQuery(base, &info, sizeof(info));
            ok(ret, "VirtualQuery failed %ld\n", GetLastError());
            ok(info.BaseAddress == base, "%ld: got %p != expected %p\n", i, info.BaseAddress, base);
            ok(info.RegionSize == si.dwPageSize, "%ld: got %#Ix != expected %#lx\n", i, info.RegionSize, si.dwPageSize);
            ok(info.Protect == td[i].prot_get, "%ld: got %#lx != expected %#lx\n", i, info.Protect, td[i].prot_get);
            ok(info.AllocationBase == base, "%ld: %p != %p\n", i, info.AllocationBase, base);
            ok(info.AllocationProtect == PAGE_NOACCESS, "%ld: %#lx != PAGE_NOACCESS\n", i, info.AllocationProtect);
            ok(info.State == MEM_COMMIT, "%ld: %#lx != MEM_COMMIT\n", i, info.State);
            ok(info.Type == MEM_PRIVATE, "%ld: %#lx != MEM_PRIVATE\n", i, info.Type);
        }
        else
        {
            ok(!ret, "%ld: VirtualProtect should fail\n", i);
            ok(GetLastError() == ERROR_INVALID_PARAMETER, "%ld: expected ERROR_INVALID_PARAMETER, got %ld\n", i, GetLastError());
        }
 
        old_prot = 0xdeadbeef;
        SetLastError(0xdeadbeef);
        ret = VirtualProtect(base, si.dwPageSize, PAGE_NOACCESS, &old_prot);
        ok(ret, "%ld: VirtualProtect error %ld\n", i, GetLastError());
        if (td[i].prot_get)
            ok(old_prot == td[i].prot_get, "%ld: got %#lx != expected %#lx\n", i, old_prot, td[i].prot_get);
        else
            ok(old_prot == PAGE_NOACCESS, "%ld: got %#lx != expected PAGE_NOACCESS\n", i, old_prot);
    }
 
    exec_prot = 0;
 
    for (i = 0; i <= 4; i++)
    {
        rw_prot = 0;
 
        for (j = 0; j <= 4; j++)
        {
            DWORD prot = exec_prot | rw_prot;
 
            SetLastError(0xdeadbeef);
            ptr = VirtualAlloc(base, si.dwPageSize, MEM_COMMIT, prot);
            if ((rw_prot && exec_prot) || (!rw_prot && !exec_prot))
            {
                ok(!ptr, "VirtualAlloc(%02lx) should fail\n", prot);
                ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
            }
            else
            {
                if (prot & (PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY))
                {
                    ok(!ptr, "VirtualAlloc(%02lx) should fail\n", prot);
                    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
                }
                else
                {
                    ok(ptr != NULL, "VirtualAlloc(%02lx) error %ld\n", prot, GetLastError());
                    ok(ptr == base, "expected %p, got %p\n", base, ptr);
                }
            }
 
            SetLastError(0xdeadbeef);
            ret = VirtualProtect(base, si.dwPageSize, prot, &old_prot);
            if ((rw_prot && exec_prot) || (!rw_prot && !exec_prot))
            {
                ok(!ret, "VirtualProtect(%02lx) should fail\n", prot);
                ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
            }
            else
            {
                if (prot & (PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY))
                {
                    ok(!ret, "VirtualProtect(%02lx) should fail\n", prot);
                    ok(GetLastError() == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError());
                }
                else
                    ok(ret, "VirtualProtect(%02lx) error %ld\n", prot, GetLastError());
            }
 
            rw_prot = 1 << j;
        }
 
        exec_prot = 1 << (i + 4);
    }
 
    VirtualFree(base, 0, MEM_RELEASE);
}

Referenced by START_TEST(), and test_section_access().

test_write_watch()

static void test_write_watch ( void  )

static

Definition at line 1733 of file virtual.c.

{
    static const char pipename[] = "\\\\.\\pipe\\test_write_watch_pipe";
    DWORD ret, size, old_prot, num_bytes;
    MEMORY_BASIC_INFORMATION info;
    HANDLE readpipe, writepipe, file;
    OVERLAPPED overlapped, *overlapped2;
    void *results[64];
    ULONG_PTR count;
    ULONG i, pagesize;
    BOOL success;
    char path[MAX_PATH], filename[MAX_PATH], *base;
 
    if (!pGetWriteWatch || !pResetWriteWatch)
    {
        win_skip( "GetWriteWatch not supported\n" );
        return;
    }
 
    size = 0x10000;
    base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_COMMIT | MEM_WRITE_WATCH, PAGE_READWRITE );
    if (!base &&
        (GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == ERROR_NOT_SUPPORTED))
    {
        win_skip( "MEM_WRITE_WATCH not supported\n" );
        return;
    }
    ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
    ret = VirtualQuery( base, &info, sizeof(info) );
    ok(ret, "VirtualQuery failed %lu\n", GetLastError());
    ok( info.BaseAddress == base, "BaseAddress %p instead of %p\n", info.BaseAddress, base );
    ok( info.AllocationProtect == PAGE_READWRITE, "wrong AllocationProtect %lx\n", info.AllocationProtect );
    ok( info.RegionSize == size, "wrong RegionSize 0x%Ix\n", info.RegionSize );
    ok( info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State );
    ok( info.Protect == PAGE_READWRITE, "wrong Protect 0x%lx\n", info.Protect );
    ok( info.Type == MEM_PRIVATE, "wrong Type 0x%lx\n", info.Type );
 
    count = 64;
    SetLastError( 0xdeadbeef );
    ret = pGetWriteWatch( 0, NULL, size, results, &count, &pagesize );
    ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
    ok( GetLastError() == ERROR_INVALID_PARAMETER ||
        broken( GetLastError() == 0xdeadbeef ), /* win98 */
        "wrong error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = pGetWriteWatch( 0, GetModuleHandleW(NULL), size, results, &count, &pagesize );
    if (ret)
    {
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
    }
    else  /* win98 */
    {
        ok( count == 0, "wrong count %Iu\n", count );
    }
 
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 0, "wrong count %Iu\n", count );
 
    base[pagesize + 1] = 0x44;
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1, "wrong count %Iu\n", count );
    ok( results[0] == base + pagesize, "wrong result %p\n", results[0] );
 
    count = 64;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1, "wrong count %Iu\n", count );
    ok( results[0] == base + pagesize, "wrong result %p\n", results[0] );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 0, "wrong count %Iu\n", count );
 
    base[2*pagesize + 3] = 0x11;
    base[4*pagesize + 8] = 0x11;
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 2, "wrong count %Iu\n", count );
    ok( results[0] == base + 2*pagesize, "wrong result %p\n", results[0] );
    ok( results[1] == base + 4*pagesize, "wrong result %p\n", results[1] );
 
    count = 64;
    ret = pGetWriteWatch( 0, base + 3*pagesize, 2*pagesize, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1, "wrong count %Iu\n", count );
    ok( results[0] == base + 4*pagesize, "wrong result %p\n", results[0] );
 
    ret = pResetWriteWatch( base, 3*pagesize );
    ok( !ret, "pResetWriteWatch failed %lu\n", GetLastError() );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1, "wrong count %Iu\n", count );
    ok( results[0] == base + 4*pagesize, "wrong result %p\n", results[0] );
 
    *(DWORD *)(base + 2*pagesize - 2) = 0xdeadbeef;
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 3, "wrong count %Iu\n", count );
    ok( results[0] == base + pagesize, "wrong result %p\n", results[0] );
    ok( results[1] == base + 2*pagesize, "wrong result %p\n", results[1] );
    ok( results[2] == base + 4*pagesize, "wrong result %p\n", results[2] );
 
    count = 1;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1, "wrong count %Iu\n", count );
    ok( results[0] == base + pagesize, "wrong result %p\n", results[0] );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 2, "wrong count %Iu\n", count );
    ok( results[0] == base + 2*pagesize, "wrong result %p\n", results[0] );
    ok( results[1] == base + 4*pagesize, "wrong result %p\n", results[1] );
 
    /* changing protections doesn't affect watches */
 
    ret = VirtualProtect( base, 3*pagesize, PAGE_READONLY, &old_prot );
    ok( ret, "VirtualProtect failed error %lu\n", GetLastError() );
    ok( old_prot == PAGE_READWRITE, "wrong old prot %lx\n", old_prot );
 
    ret = VirtualQuery( base, &info, sizeof(info) );
    ok(ret, "VirtualQuery failed %lu\n", GetLastError());
    ok( info.BaseAddress == base, "BaseAddress %p instead of %p\n", info.BaseAddress, base );
    ok( info.RegionSize == 3*pagesize, "wrong RegionSize 0x%Ix\n", info.RegionSize );
    ok( info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State );
    ok( info.Protect == PAGE_READONLY, "wrong Protect 0x%lx\n", info.Protect );
 
    ret = VirtualProtect( base, 3*pagesize, PAGE_READWRITE, &old_prot );
    ok( ret, "VirtualProtect failed error %lu\n", GetLastError() );
    ok( old_prot == PAGE_READONLY, "wrong old prot %lx\n", old_prot );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 2, "wrong count %Iu\n", count );
    ok( results[0] == base + 2*pagesize, "wrong result %p\n", results[0] );
    ok( results[1] == base + 4*pagesize, "wrong result %p\n", results[1] );
 
    ret = VirtualQuery( base, &info, sizeof(info) );
    ok(ret, "VirtualQuery failed %lu\n", GetLastError());
    ok( info.BaseAddress == base, "BaseAddress %p instead of %p\n", info.BaseAddress, base );
    ok( info.RegionSize == size, "wrong RegionSize 0x%Ix\n", info.RegionSize );
    ok( info.State == MEM_COMMIT, "wrong State 0x%lx\n", info.State );
    ok( info.Protect == PAGE_READWRITE, "wrong Protect 0x%lx\n", info.Protect );
 
    /* ReadFile should trigger write watches */
 
    for (i = 0; i < 2; i++)
    {
        memset( &overlapped, 0, sizeof(overlapped) );
        overlapped.hEvent = CreateEventA( NULL, TRUE, FALSE, NULL );
 
        readpipe = CreateNamedPipeA( pipename, FILE_FLAG_OVERLAPPED | PIPE_ACCESS_INBOUND,
                                     (i ? PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE) | PIPE_WAIT, 1, 1024, 1024,
                                     NMPWAIT_USE_DEFAULT_WAIT, NULL );
        ok( readpipe != INVALID_HANDLE_VALUE, "CreateNamedPipeA failed %lu\n", GetLastError() );
 
        success = ConnectNamedPipe( readpipe, &overlapped );
        ok( !success, "%lu: ConnectNamedPipe unexpectedly succeeded\n", i );
        ok( GetLastError() == ERROR_IO_PENDING, "%lu: expected ERROR_IO_PENDING, got %lu\n",
            i, GetLastError() );
 
        writepipe = CreateFileA( pipename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL );
        ok( writepipe != INVALID_HANDLE_VALUE, "%lu: CreateFileA failed %lu\n", i, GetLastError() );
 
        ret = WaitForSingleObject( overlapped.hEvent, 1000 );
        ok( ret == WAIT_OBJECT_0, "%lu: expected WAIT_OBJECT_0, got %lu\n", i, ret );
 
        memset( base, 0, size );
 
        count = 64;
        ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
        ok( !ret, "%lu: GetWriteWatch failed %lu\n", i, GetLastError() );
        ok( count == 16, "%lu: wrong count %Iu\n", i, count );
 
        success = ReadFile( readpipe, base, size, NULL, &overlapped );
        ok( !success, "%lu: ReadFile unexpectedly succeeded\n", i );
        ok( GetLastError() == ERROR_IO_PENDING, "%lu: expected ERROR_IO_PENDING, got %lu\n",
            i, GetLastError() );
 
        count = 64;
        ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
        ok( !ret, "%lu: GetWriteWatch failed %lu\n", i, GetLastError() );
        ok( count == 16, "%lu: wrong count %Iu\n", i, count );
 
        num_bytes = 0;
        success = WriteFile( writepipe, testdata, sizeof(testdata), &num_bytes, NULL );
        ok( success, "%lu: WriteFile failed %lu\n", i, GetLastError() );
        ok( num_bytes == sizeof(testdata), "%lu: wrong number of bytes written %lu\n", i, num_bytes );
 
        num_bytes = 0;
        success = GetOverlappedResult( readpipe, &overlapped, &num_bytes, TRUE );
        ok( success, "%lu: GetOverlappedResult failed %lu\n", i, GetLastError() );
        ok( num_bytes == sizeof(testdata), "%lu: wrong number of bytes read %lu\n", i, num_bytes );
        ok( !memcmp( base, testdata, sizeof(testdata)), "%lu: didn't receive expected data\n", i );
 
        count = 64;
        memset( results, 0, sizeof(results) );
        ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
        ok( !ret, "%lu: GetWriteWatch failed %lu\n", i, GetLastError() );
        ok( count == 1, "%lu: wrong count %Iu\n", i, count );
        ok( results[0] == base, "%lu: wrong result %p\n", i, results[0] );
 
        CloseHandle( readpipe );
        CloseHandle( writepipe );
        CloseHandle( overlapped.hEvent );
    }
 
    for (i = 0; i < 2; i++)
    {
        struct read_pipe_args args;
        HANDLE thread;
 
        readpipe = CreateNamedPipeA( pipename, PIPE_ACCESS_INBOUND,
                                     (i ? PIPE_TYPE_MESSAGE : PIPE_TYPE_BYTE) | PIPE_WAIT, 1, 1024, 1024,
                                     NMPWAIT_USE_DEFAULT_WAIT, NULL );
        ok( readpipe != INVALID_HANDLE_VALUE, "CreateNamedPipeA failed %lu\n", GetLastError() );
 
        memset( base, 0, size );
 
        count = 64;
        ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
        ok( !ret, "%lu: GetWriteWatch failed %lu\n", i, GetLastError() );
        ok( count == 16, "%lu: wrong count %Iu\n", i, count );
 
        args.pipe = readpipe;
        args.index = i;
        args.base = base;
        args.size = size;
        thread = CreateThread( NULL, 0, read_pipe, &args, 0, NULL );
 
        writepipe = CreateFileA( pipename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL );
        ok( writepipe != INVALID_HANDLE_VALUE, "%lu: CreateFileA failed %lu\n", i, GetLastError() );
        Sleep( 200 );
 
        count = 64;
        ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
        ok( !ret, "%lu: GetWriteWatch failed %lu\n", i, GetLastError() );
        ok( count == 16, "%lu: wrong count %Iu\n", i, count );
 
        num_bytes = 0;
        success = WriteFile( writepipe, testdata, sizeof(testdata), &num_bytes, NULL );
        ok( success, "%lu: WriteFile failed %lu\n", i, GetLastError() );
        ok( num_bytes == sizeof(testdata), "%lu: wrong number of bytes written %lu\n", i, num_bytes );
        WaitForSingleObject( thread, 10000 );
 
        count = 64;
        memset( results, 0, sizeof(results) );
        ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
        ok( !ret, "%lu: GetWriteWatch failed %lu\n", i, GetLastError() );
        ok( count == 1, "%lu: wrong count %Iu\n", i, count );
        ok( results[0] == base, "%lu: wrong result %p\n", i, results[0] );
 
        CloseHandle( readpipe );
        CloseHandle( writepipe );
        CloseHandle( thread );
    }
 
    GetTempPathA( MAX_PATH, path );
    GetTempFileNameA( path, "map", 0, filename );
    file = CreateFileA( filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "CreateFile error %lu\n", GetLastError() );
    SetFilePointer( file, 2 * pagesize + 3, NULL, FILE_BEGIN );
    SetEndOfFile( file );
    SetFilePointer( file, 0, NULL, FILE_BEGIN );
 
    success = ReadFile( file, base, size, &num_bytes, NULL );
    ok( success, "ReadFile failed %lu\n", GetLastError() );
    ok( num_bytes == 2 * pagesize + 3, "wrong bytes %lu\n", num_bytes );
 
    count = 64;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 16, "wrong count %Iu\n", count );
 
    success = ReadFile( file, base, size, &num_bytes, NULL );
    ok( success, "ReadFile failed %lu\n", GetLastError() );
    ok( num_bytes == 0, "wrong bytes %lu\n", num_bytes );
 
    count = 64;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 16, "wrong count %Iu\n", count );
 
    CloseHandle( file );
    DeleteFileA( filename );
 
    success = ReadFile( (HANDLE)0xdead, base, size, &num_bytes, NULL );
    ok( !success, "ReadFile succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %lu\n", GetLastError() );
 
    count = 64;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 0, "wrong count %Iu\n", count );
 
    /* OVERLAPPED structure write watch */
    memset( &overlapped, 0, sizeof(overlapped) );
    overlapped.hEvent = CreateEventA( NULL, TRUE, FALSE, NULL );
 
    readpipe = CreateNamedPipeA( pipename, FILE_FLAG_OVERLAPPED | PIPE_ACCESS_INBOUND,
                                 PIPE_TYPE_MESSAGE | PIPE_WAIT, 1, 1024, 1024,
                                 NMPWAIT_USE_DEFAULT_WAIT, NULL );
    ok( readpipe != INVALID_HANDLE_VALUE, "CreateNamedPipeA failed %lu\n", GetLastError() );
 
    success = ConnectNamedPipe( readpipe, &overlapped );
    ok( !success, "ConnectNamedPipe unexpectedly succeeded\n" );
    ok( GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %lu\n", GetLastError() );
 
    writepipe = CreateFileA( pipename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL );
    ok( writepipe != INVALID_HANDLE_VALUE, "CreateFileA failed %lu\n", GetLastError() );
 
    ret = WaitForSingleObject( overlapped.hEvent, 1000 );
    ok( ret == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %lu\n", ret );
 
    memset( base, 0, size );
    overlapped2 = (OVERLAPPED*)(base + size - sizeof(*overlapped2));
    overlapped2->hEvent = CreateEventA( NULL, TRUE, FALSE, NULL );
 
    count = 64;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 16, "wrong count %Iu\n", count );
 
    success = ReadFile( readpipe, base, sizeof(testdata), NULL, overlapped2 );
    ok( !success, "ReadFile unexpectedly succeeded\n" );
    ok( GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %lu\n", GetLastError() );
    overlapped2->Internal = 0xdeadbeef;
 
    count = 64;
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 2, "wrong count %Iu\n", count );
 
    num_bytes = 0;
    success = WriteFile( writepipe, testdata, sizeof(testdata), &num_bytes, NULL );
    ok( success, "WriteFile failed %lu\n", GetLastError() );
    ok( num_bytes == sizeof(testdata), "wrong number of bytes written %lu\n", num_bytes );
 
    num_bytes = 0;
    success = GetOverlappedResult( readpipe, overlapped2, &num_bytes, TRUE );
    ok( success, "GetOverlappedResult failed %lu\n", GetLastError() );
    ok( num_bytes == sizeof(testdata), "wrong number of bytes read %lu\n", num_bytes );
    ok( !memcmp( base, testdata, sizeof(testdata)), "didn't receive expected data\n" );
 
    count = 64;
    memset( results, 0, sizeof(results) );
    ret = pGetWriteWatch( WRITE_WATCH_FLAG_RESET, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 2, "wrong count %Iu\n", count );
    ok( results[0] == base, "wrong result %p\n", results[0] );
 
    CloseHandle( readpipe );
    CloseHandle( writepipe );
    CloseHandle( overlapped.hEvent );
    CloseHandle( overlapped2->hEvent );
 
    /* some invalid parameter tests */
 
    SetLastError( 0xdeadbeef );
    count = 0;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    if (ret)
    {
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        ret = pGetWriteWatch( 0, base, size, results, NULL, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_NOACCESS, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0, base, size, results, &count, NULL );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_NOACCESS, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0, base, size, NULL, &count, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_NOACCESS, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 0;
        ret = pGetWriteWatch( 0, base, size, NULL, &count, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0xdeadbeef, base, size, results, &count, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0, base, 0, results, &count, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0, base, size * 2, results, &count, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0, base + size - pagesize, pagesize + 1, results, &count, &pagesize );
        ok( ret == ~0u, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        ret = pResetWriteWatch( base, 0 );
        ok( ret == ~0u, "ResetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        ret = pResetWriteWatch( GetModuleHandleW(NULL), size );
        ok( ret == ~0u, "ResetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
    }
    else  /* win98 is completely different */
    {
        SetLastError( 0xdeadbeef );
        count = 64;
        ret = pGetWriteWatch( 0, base, size, NULL, &count, &pagesize );
        ok( ret == ERROR_INVALID_PARAMETER, "GetWriteWatch succeeded %lu\n", ret );
        ok( GetLastError() == 0xdeadbeef, "wrong error %lu\n", GetLastError() );
 
        count = 0;
        ret = pGetWriteWatch( 0, base, size, NULL, &count, &pagesize );
        ok( !ret, "GetWriteWatch failed %lu\n", ret );
 
        count = 64;
        ret = pGetWriteWatch( 0xdeadbeef, base, size, results, &count, &pagesize );
        ok( !ret, "GetWriteWatch failed %lu\n", ret );
 
        count = 64;
        ret = pGetWriteWatch( 0, base, 0, results, &count, &pagesize );
        ok( !ret, "GetWriteWatch failed %lu\n", ret );
 
        ret = pResetWriteWatch( base, 0 );
        ok( !ret, "ResetWriteWatch failed %lu\n", ret );
 
        ret = pResetWriteWatch( GetModuleHandleW(NULL), size );
        ok( !ret, "ResetWriteWatch failed %lu\n", ret );
    }
 
    VirtualFree( base, 0, MEM_RELEASE );
 
    base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_WRITE_WATCH, PAGE_READWRITE );
    ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
    VirtualFree( base, 0, MEM_RELEASE );
 
    base = VirtualAlloc( 0, size, MEM_WRITE_WATCH, PAGE_READWRITE );
    ok( !base, "VirtualAlloc succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %lu\n", GetLastError() );
 
    /* initial protect doesn't matter */
 
    base = VirtualAlloc( 0, size, MEM_RESERVE | MEM_WRITE_WATCH, PAGE_NOACCESS );
    ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
    base = VirtualAlloc( base, size, MEM_COMMIT, PAGE_NOACCESS );
    ok( base != NULL, "VirtualAlloc failed %lu\n", GetLastError() );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 0, "wrong count %Iu\n", count );
 
    ret = VirtualProtect( base, 6*pagesize, PAGE_READWRITE, &old_prot );
    ok( ret, "VirtualProtect failed error %lu\n", GetLastError() );
    ok( old_prot == PAGE_NOACCESS, "wrong old prot %lx\n", old_prot );
 
    base[5*pagesize + 200] = 3;
 
    ret = VirtualProtect( base, 6*pagesize, PAGE_NOACCESS, &old_prot );
    ok( ret, "VirtualProtect failed error %lu\n", GetLastError() );
    ok( old_prot == PAGE_READWRITE, "wrong old prot %lx\n", old_prot );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1, "wrong count %Iu\n", count );
    ok( results[0] == base + 5*pagesize, "wrong result %p\n", results[0] );
 
    ret = VirtualFree( base, size, MEM_DECOMMIT );
    ok( ret, "VirtualFree failed %lu\n", GetLastError() );
 
    count = 64;
    ret = pGetWriteWatch( 0, base, size, results, &count, &pagesize );
    ok( !ret, "GetWriteWatch failed %lu\n", GetLastError() );
    ok( count == 1 || broken(count == 0), /* win98 */
        "wrong count %Iu\n", count );
    if (count) ok( results[0] == base + 5*pagesize, "wrong result %p\n", results[0] );
 
    VirtualFree( base, 0, MEM_RELEASE );
}

Referenced by START_TEST().

UINT()

static UINT ( WINAPI *  pGetWriteWatch )

static

ULONG()

static ULONG ( WINAPI *  pRtlRemoveVectoredExceptionHandler )

static

Variable Documentation

ACCESS_MASK

ACCESS_MASK

Definition at line 44 of file virtual.c.

HANDLE

HANDLE

Definition at line 45 of file virtual.c.

hkernel32

HINSTANCE hkernel32

static

Definition at line 38 of file virtual.c.

Referenced by START_TEST().

hkernelbase

HINSTANCE hkernelbase

static

Definition at line 38 of file virtual.c.

Referenced by START_TEST().

hntdll

HINSTANCE hntdll

static

Definition at line 38 of file virtual.c.

Referenced by START_TEST().

is_wow64

BOOL is_wow64

static

Definition at line 40 of file virtual.c.

Referenced by START_TEST(), and test_PrefetchVirtualMemory().

LPDWORD

LPDWORD

Definition at line 51 of file virtual.c.

LPVOID

LPVOID

Definition at line 41 of file virtual.c.

PBOOL

PBOOL

Definition at line 51 of file virtual.c.

PVECTORED_EXCEPTION_HANDLER

void SIZE_T *static PVECTORED_EXCEPTION_HANDLER

Definition at line 49 of file virtual.c.

PVOID

PVOID

Definition at line 43 of file virtual.c.

Referenced by MiCheckVadsForLockOperation(), MiDecommitPages(), MiDoMappedCopy(), MiDoPoolCopy(), MiProtectVirtualMemory(), MiQueryAddressState(), MiQueryMemoryBasicInformation(), NtAllocateVirtualMemory(), NtFreeVirtualMemory(), NtGetWriteWatch(), and NtResetWriteWatch().

PWIN32_MEMORY_RANGE_ENTRY

PVOID SIZE_T ULONG *static const void void SIZE_T *static void const void SIZE_T *static PWIN32_MEMORY_RANGE_ENTRY

Definition at line 57 of file virtual.c.

SECTION_INFORMATION_CLASS

SECTION_INFORMATION_CLASS

Definition at line 48 of file virtual.c.

si

SYSTEM_INFO si

static

Definition at line 39 of file virtual.c.

Referenced by __rpc_nconf2fd(), __rpcgettp(), _create_process(), _resetstkoflw(), _tWinMain(), _wpopen(), adns_errabbrev(), adns_strerror(), apply_patch_package(), AssocQ(), AttachConsole(), AudioDlgProc(), buffer_check_attribute(), buffer_find_decl(), calc_thumb_dimensions(), CallUninstall(), check_child_console_bits(), check_range(), check_run_child(), check_transform_applicable(), CheckX64System(), clnt_dg_create(), clnt_tli_create(), clnt_vc_create(), cmd_available(), copy_symbolW(), create_check_id_process(), create_debug_port(), create_name(), create_proc(), create_process(), create_pseudo_console(), create_suminfo(), create_target_process(), create_writepipe_process(), CreateClientProcess(), CreateHiddenConsoleProcess(), custom_start_server(), debug_and_exit(), debug_and_wait(), Display_OnPaint(), Display_OnSize(), Display_OnVScroll(), Display_SetTypeFace(), doChildren(), DosCreateProcess(), DoTestEntry(), draw_primitive_arrays(), draw_primitive_immediate_mode(), EDIT_UpdateScrollInfo(), elf_search_auxv(), enum_types_AtoW(), execute_command(), fill_pinfo_side(), fill_system_info(), find_ps_compile_args(), FontWndProc(), fork_helper(), FormatIPv4Address(), FullPathExec(), gen_ffp_frag_op(), get_estimated_size(), get_prop(), get_resource_sizes(), getclnthandle(), ATL::CRegKey::GetKeySecurity(), GetNativeSystemInfo(), GetSystemInfo(), CConfiguration::GetSystemInformation(), CShellDispatch::GetSystemInformation(), HEXEDIT_IndexFromPoint(), HEXEDIT_MoveCaret(), HEXEDIT_Update(), HEXEDIT_WM_MOUSEWHEEL(), HEXEDIT_WM_PAINT(), HEXEDIT_WM_VSCROLL(), hit_test(), HotkeyThread(), IDirectInputAImpl_RunControlPanel(), III_get_side_info(), ILGetSize(), install_wine_gecko(), ISecurityObjectTypeInfo_fnGetInheritSource(), ITERATE_RemoveExistingProducts(), jpeg_make_c_derived_tbl(), jpeg_make_d_derived_tbl(), CNetConnectionPropertyUi::LANPropertiesUIDlg(), launch_exe(), LaunchProcess(), load_summary_info(), load_tex_coords(), load_vertex_data(), main(), MainWndProc(), makefd_xprt(), msi_add_suminfo(), MSI_ApplicablePatchW(), msi_apply_registered_patch(), msi_check_patch_applicable(), MSI_CloseSummaryInfo(), msi_export_suminfo(), msi_get_db_suminfo(), msi_get_package_code(), msi_get_suminfo(), msi_get_suminfo_product(), msi_load_suminfo_properties(), MSI_OpenPackageW(), msi_suminfo_dup_string(), msi_suminfo_get_int32(), MsiGetSummaryInformationW(), MsiSummaryInfoGetPropertyA(), MsiSummaryInfoGetPropertyCount(), MsiSummaryInfoGetPropertyW(), MsiSummaryInfoPersist(), MsiSummaryInfoSetPropertyA(), MsiSummaryInfoSetPropertyW(), msvcrt_init_io(), msvcrt_spawn(), NDdeGetShareSecurityA(), NDdeGetShareSecurityW(), NDdeSetShareSecurityA(), NDdeSetShareSecurityW(), CNewMenu::NewItemByCommand(), CCanvasWindow::OnHVScroll(), OnScroll(), CAutoComplete::OnVScroll(), paint_scrollbar(), parse_patch_summary(), parse_suminfo(), PrepAndLaunchRedirectedChild(), preview_proc(), ProcessPage_OnDebug(), ProcessPageShowContextMenu(), read_reg_output_(), RealDefWindowProcA(), RealDefWindowProcW(), redraw_part(), register_dll(), rendezvous_request(), restart_as_admin_elevated(), rpc_broadcast_exp(), rpc_reg(), run_child_process(), run_child_process_two_dll(), run_child_wait(), run_cmd(), run_ex(), run_rapps(), run_reg_exe_(), run_regedit_exe_(), run_script_file(), run_winemenubuilder(), runcmd(), runCmd(), runscriptfile(), RunShell(), save_prop(), save_summary_info(), ScreenSaverConfig(), ScreenSaverPreview(), SCROLL_HandleScrollEvent(), scrollbar_test_default(), server_thread(), set_prop(), ATL::CRegKey::SetKeySecurity(), SetScreenSaverPreviewBox(), si_compar(), software_vertex_blending(), SpawnProcess(), start_server(), START_TEST(), StartApplication(), StartProcess(), StdMemAllocator_Alloc(), suminfo_persist(), suminfo_set_prop(), svc_dg_create(), svc_tli_create(), svc_vc_create(), sym_enumW(), SymFromAddrW(), SymGetSymFromAddr(), SymGetSymFromAddr64(), SymGetSymFromName(), SymGetSymFromName64(), taddr2uaddr(), TaskManager_OnFileNew(), test_affinity(), test_alloc_shared(), test_AllocConsole(), test_AllocConsole_child(), test_apc_deadlock(), test_appsearch_reglocator(), test_AttachConsole(), test_bitmap_font_metrics(), test_BreakawayOk(), test_child_env(), Test_CommandLine(), test_CompareStringW(), test_CreateFileMapping_protection(), test_CtrlHandlerSubsystem(), test_debug_children(), test_debug_loop(), test_debug_loop_wow64(), test_debugger(), test_dpa(), test_EM_SETTEXTEX(), test_EnumProcessModules(), test_exit_process_async(), test_ExitProcess(), test_file_inherit_child(), test_fls_exit_deadlock(), test_GetConsoleOriginalTitle(), test_GetDatabaseInformationEmpty(), test_GetNumaProcessorNode(), test_GetProcessVersion(), test_GetSystemCpuSetInformation(), test_handle_list_attribute(), test_http_connection(), test_hv_scroll_2(), test_installprops(), test_internet_features(), test_IsWow64Process(), test_IsWow64Process2(), test_job_list_attribute(), test_mapping(), test_mappings(), test_mdi(), test_nested_jobs(), test_NtGetCurrentProcessorNumber(), test_parent_process_attribute(), test_pe_os_version(), test_PrefetchVirtualMemory(), test_query_logicalproc(), test_query_process_debug_flags(), test_query_process_debug_object_handle(), test_query_process_debug_port(), test_query_processor_power_info(), test_ReadProcessMemory(), test_scroll(), test_scroll_messages(), test_scrollbar_visibility(), test_SetScrollInfo(), test_shared_memory(), test_shared_memory_ro(), test_Startup(), test_SystemInfo(), test_TerminateProcess(), test_VirtualAlloc_protection(), test_VirtualProtect(), test_WriteFileGather(), TestStaticDestruct(), ThemeDrawScrollBarEx(), ToolsPageWndProc(), TREEVIEW_UpdateScrollBars(), uaddr2taddr(), CAutoComplete::UpdateScrollBar(), CCanvasWindow::updateScrollRange(), UpdateWindowScrollState(), use_indexed_vertex_blending(), VirtualTest(), wined3d_ffp_get_vs_settings(), wmain(), write_resources(), WshExec_create(), xdr_stateid4(), ZoomWnd_OnHVScroll(), and ZoomWnd_UpdateScroll().

SIZE_T

PVOID SIZE_T ULONG *static const void void SIZE_T *static void const void SIZE_T

Definition at line 41 of file virtual.c.

Referenced by test_MapViewOfFile().

testdata

const char testdata[] = "Hello World"

static

Definition at line 1715 of file virtual.c.

ULONG

PVOID SIZE_T ULONG *static const void void SIZE_T *static void const void SIZE_T *static ULONG

Definition at line 45 of file virtual.c.

Referenced by NtAllocateVirtualMemory().

ULONG_PTR

PVOID SIZE_T ULONG *static const void void SIZE_T *static void const void SIZE_T *static ULONG_PTR

Definition at line 46 of file virtual.c.

Referenced by MiDeleteVirtualAddresses(), MiDoMappedCopy(), MiDoPoolCopy(), MiProtectVirtualMemory(), MiQueryMemoryBasicInformation(), NtAllocateVirtualMemory(), and NtFreeVirtualMemory().