heap.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winternl.h"
#include "wine/test.h"

Include dependency graph for heap.c:

Go to the source code of this file.

Classes
struct	heap
struct	rtl_heap_entry
struct	heap_thread_params
struct	mem_entry

Macros
#define	HEAP_ADD_USER_INFO   0x00000100
#define	HEAP_PRIVATE   0x00001000
#define	HEAP_PAGE_ALLOCS   0x01000000
#define	HEAP_VALIDATE   0x10000000
#define	HEAP_VALIDATE_ALL   0x20000000
#define	HEAP_VALIDATE_PARAMS   0x40000000
#define	BLOCK_ALIGN   (2 * sizeof(void *) - 1)
#define	ALIGN_BLOCK_SIZE(x)   (((x) + BLOCK_ALIGN) & ~BLOCK_ALIGN)
#define	LOAD_FUNC(m, f)   p ## f = (void *)GetProcAddress( m, #f );
#define	RTL_HEAP_ENTRY_BUSY   0x0001
#define	RTL_HEAP_ENTRY_REGION   0x0002
#define	RTL_HEAP_ENTRY_BLOCK   0x0010
#define	RTL_HEAP_ENTRY_UNCOMMITTED   0x1000
#define	RTL_HEAP_ENTRY_COMMITTED   0x4000
#define	RTL_HEAP_ENTRY_LFH   0x8000
#define	IS_WITHIN_RANGE(a, b)   (((a) - (b) + (256 * basic_info.PageSize)) <= (512 * basic_info.PageSize))

Functions
static	LPVOID (WINAPI *pHeapAlloc)(HANDLE
static	BOOL (WINAPI *pHeapFree)(HANDLE
static	BOOLEAN (WINAPI *pRtlGetUserInfoHeap)(HANDLE
static	HGLOBAL (WINAPI *pGlobalAlloc)(UINT
static	UINT (WINAPI *pGlobalFlags)(HGLOBAL)
static	ULONG (WINAPI *pRtlGetNtGlobalFlags)(void)
static void	load_functions (void)
DWORD WINAPI	heap_thread_proc (void *arg)
static void	test_HeapCreate (void)
static struct mem_entry *	mem_entry_from_HANDLE (HLOCAL handle)
static BOOL	is_mem_entry (HLOCAL handle)
static void	test_GlobalAlloc (void)
static void	test_LocalAlloc (void)
static void	test_block_layout (HANDLE heap, DWORD global_flags, DWORD heap_flags, DWORD alloc_flags)
static void	test_heap_checks (DWORD flags)
static void	test_debug_heap (const char *argv0, DWORD flags)
static DWORD	heap_flags_from_global_flag (DWORD flag)
static void	test_heap_layout (HANDLE handle, DWORD global_flag, DWORD heap_flags)
static void	test_child_heap (const char *arg)
static void	test_GetPhysicallyInstalledSystemMemory (void)
static void	test_GlobalMemoryStatus (void)
static void	get_valloc_info (void *mem, char **base, SIZE_T *alloc_size)
static void	test_heap_size (SIZE_T initial_size)
static void	test_heap_sizes (void)
	START_TEST (heap)

Variables
static	DWORD
static	SIZE_T
static	LPVOID
static	ULONG
static	HEAP_INFORMATION_CLASS

Macro Definition Documentation

ALIGN_BLOCK_SIZE

#define ALIGN_BLOCK_SIZE

(

x

)

(((x) + BLOCK_ALIGN) & ~BLOCK_ALIGN)

Definition at line 42 of file heap.c.

BLOCK_ALIGN

#define BLOCK_ALIGN   (2 * sizeof(void *) - 1)

Definition at line 41 of file heap.c.

HEAP_ADD_USER_INFO

#define HEAP_ADD_USER_INFO   0x00000100

Definition at line 34 of file heap.c.

HEAP_PAGE_ALLOCS

#define HEAP_PAGE_ALLOCS   0x01000000

Definition at line 36 of file heap.c.

HEAP_PRIVATE

#define HEAP_PRIVATE   0x00001000

Definition at line 35 of file heap.c.

HEAP_VALIDATE

#define HEAP_VALIDATE   0x10000000

Definition at line 37 of file heap.c.

HEAP_VALIDATE_ALL

#define HEAP_VALIDATE_ALL   0x20000000

Definition at line 38 of file heap.c.

HEAP_VALIDATE_PARAMS

#define HEAP_VALIDATE_PARAMS   0x40000000

Definition at line 39 of file heap.c.

IS_WITHIN_RANGE

#define IS_WITHIN_RANGE	(		a,
			b
	)		(((a) - (b) + (256 * basic_info.PageSize)) <= (512 * basic_info.PageSize))

LOAD_FUNC

#define LOAD_FUNC	(		m,
			f
	)		p ## f = (void *)GetProcAddress( m, #f );

RTL_HEAP_ENTRY_BLOCK

#define RTL_HEAP_ENTRY_BLOCK   0x0010

Definition at line 125 of file heap.c.

RTL_HEAP_ENTRY_BUSY

#define RTL_HEAP_ENTRY_BUSY   0x0001

Definition at line 123 of file heap.c.

RTL_HEAP_ENTRY_COMMITTED

#define RTL_HEAP_ENTRY_COMMITTED   0x4000

Definition at line 127 of file heap.c.

RTL_HEAP_ENTRY_LFH

#define RTL_HEAP_ENTRY_LFH   0x8000

Definition at line 128 of file heap.c.

RTL_HEAP_ENTRY_REGION

#define RTL_HEAP_ENTRY_REGION   0x0002

Definition at line 124 of file heap.c.

RTL_HEAP_ENTRY_UNCOMMITTED

#define RTL_HEAP_ENTRY_UNCOMMITTED   0x1000

Definition at line 126 of file heap.c.

Function Documentation

BOOL()

static BOOL ( WINAPI *  pHeapFree )

static

BOOLEAN()

static BOOLEAN ( WINAPI *  pRtlGetUserInfoHeap )

static

get_valloc_info()

static void get_valloc_info ( void *  mem, char **  base, SIZE_T *  alloc_size  )

static

Definition at line 3952 of file heap.c.

{
    MEMORY_BASIC_INFORMATION info, info2;
    SIZE_T size;
    char *p;
 
    size = VirtualQuery( mem, &info, sizeof(info) );
    ok( size == sizeof(info), "got %Iu.\n", size );
 
    info2 = info;
    p = info.AllocationBase;
    while (1)
    {
        size = VirtualQuery( p, &info2, sizeof(info2) );
        ok( size == sizeof(info), "got %Iu.\n", size );
        if (info2.AllocationBase != info.AllocationBase)
            break;
        ok( info2.State == MEM_RESERVE || info2.State == MEM_COMMIT, "got %#lx.\n", info2.State );
        p += info2.RegionSize;
    }
 
    *base = info.AllocationBase;
    *alloc_size = p - *base;
}

Referenced by test_heap_size(), and test_heap_sizes().

heap_flags_from_global_flag()

static DWORD heap_flags_from_global_flag ( DWORD  flag )

static

Definition at line 3699 of file heap.c.

{
    DWORD ret = 0;
 
    if (flag & FLG_HEAP_ENABLE_TAIL_CHECK)
        ret |= HEAP_TAIL_CHECKING_ENABLED;
    if (flag & FLG_HEAP_ENABLE_FREE_CHECK)
        ret |= HEAP_FREE_CHECKING_ENABLED;
    if (flag & FLG_HEAP_VALIDATE_PARAMETERS)
        ret |= HEAP_VALIDATE_PARAMS | HEAP_TAIL_CHECKING_ENABLED | HEAP_FREE_CHECKING_ENABLED;
    if (flag & FLG_HEAP_VALIDATE_ALL)
        ret |= HEAP_VALIDATE_ALL | HEAP_TAIL_CHECKING_ENABLED | HEAP_FREE_CHECKING_ENABLED;
    if (flag & FLG_HEAP_DISABLE_COALESCING)
        ret |= HEAP_DISABLE_COALESCE_ON_FREE;
    if (flag & FLG_HEAP_PAGE_ALLOCS)
        ret |= HEAP_PAGE_ALLOCS;
    return ret;
}

Referenced by test_child_heap().

heap_thread_proc()

DWORD WINAPI heap_thread_proc

(

void *

arg

)

Definition at line 142 of file heap.c.

{
    struct heap_thread_params *params = arg;
    void *ptr;
    DWORD res;
    BOOL ret;
 
    SetEvent( params->ready_event );
 
    while (!(res = WaitForSingleObject( params->start_event, INFINITE )) && !params->done)
    {
        if (params->lock)
        {
            ret = HeapLock( params->heap );
            ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
        }
 
        ptr = HeapAlloc( params->heap, params->flags, 0 );
        ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
        ret = HeapFree( params->heap, params->flags, ptr );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
        if (params->lock)
        {
            ret = HeapUnlock( params->heap );
            ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
        }
 
        SetEvent( params->ready_event );
    }
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
 
    return 0;
}

Referenced by test_HeapCreate().

HGLOBAL()

static HGLOBAL ( WINAPI *  pGlobalAlloc )

static

is_mem_entry()

static BOOL is_mem_entry ( HLOCAL  handle )

static

Definition at line 1434 of file heap.c.

{
    return ((UINT_PTR)handle & ((sizeof(void *) << 1) - 1)) == sizeof(void *);
}

Referenced by test_GlobalAlloc(), and test_LocalAlloc().

load_functions()

static void load_functions ( void  )

static

Definition at line 61 of file heap.c.

{
    HMODULE kernel32 = GetModuleHandleW( L"kernel32.dll" );
    HMODULE ntdll = GetModuleHandleW( L"ntdll.dll" );
 
#define LOAD_FUNC(m, f) p ## f = (void *)GetProcAddress( m, #f );
    LOAD_FUNC( kernel32, HeapAlloc );
    LOAD_FUNC( kernel32, HeapReAlloc );
    LOAD_FUNC( kernel32, HeapFree );
    LOAD_FUNC( kernel32, HeapQueryInformation );
    LOAD_FUNC( kernel32, HeapSetInformation );
    LOAD_FUNC( kernel32, GetPhysicallyInstalledSystemMemory );
    LOAD_FUNC( kernel32, GlobalAlloc );
    LOAD_FUNC( kernel32, GlobalFlags );
    LOAD_FUNC( kernel32, GlobalFree );
    LOAD_FUNC( kernel32, LocalAlloc );
    LOAD_FUNC( kernel32, LocalFree );
    LOAD_FUNC( ntdll, RtlGetNtGlobalFlags );
    LOAD_FUNC( ntdll, RtlGetUserInfoHeap );
    LOAD_FUNC( ntdll, RtlSetUserValueHeap );
    LOAD_FUNC( ntdll, RtlSetUserFlagsHeap );
#undef LOAD_FUNC
}

Referenced by START_TEST().

LPVOID()

static LPVOID ( WINAPI *  pHeapAlloc )

static

mem_entry_from_HANDLE()

static struct mem_entry * mem_entry_from_HANDLE ( HLOCAL  handle )

static

Definition at line 1429 of file heap.c.

{
    return CONTAINING_RECORD( handle, struct mem_entry, ptr );
}

Referenced by test_GlobalAlloc(), and test_LocalAlloc().

START_TEST()

START_TEST

(

heap

)

Definition at line 4053 of file heap.c.

{
    int argc;
    char **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
    load_functions();
 
    argc = winetest_get_mainargs( &argv );
    if (argc >= 3)
    {
        test_child_heap( argv[2] );
        return;
    }
 
    test_HeapCreate();
    test_GlobalAlloc();
    test_LocalAlloc();
 
    test_GetPhysicallyInstalledSystemMemory();
    test_GlobalMemoryStatus();
 
    if (pRtlGetNtGlobalFlags)
    {
        test_debug_heap( argv[0], 0 );
        test_debug_heap( argv[0], FLG_HEAP_ENABLE_TAIL_CHECK );
        test_debug_heap( argv[0], FLG_HEAP_ENABLE_FREE_CHECK );
        test_debug_heap( argv[0], FLG_HEAP_VALIDATE_PARAMETERS );
        test_debug_heap( argv[0], FLG_HEAP_VALIDATE_ALL );
        test_debug_heap( argv[0], FLG_POOL_ENABLE_TAGGING );
        test_debug_heap( argv[0], FLG_HEAP_ENABLE_TAGGING );
        test_debug_heap( argv[0], FLG_HEAP_ENABLE_TAG_BY_DLL );
        test_debug_heap( argv[0], FLG_HEAP_DISABLE_COALESCING );
        test_debug_heap( argv[0], FLG_HEAP_PAGE_ALLOCS );
        test_debug_heap( argv[0], 0xdeadbeef );
    }
    else win_skip( "RtlGetNtGlobalFlags not found, skipping heap debug tests\n" );
    test_heap_sizes();
}

test_block_layout()

static void test_block_layout ( HANDLE  heap, DWORD  global_flags, DWORD  heap_flags, DWORD  alloc_flags  )

static

Definition at line 3243 of file heap.c.

{
    DWORD padd_flags = HEAP_VALIDATE | HEAP_VALIDATE_ALL | HEAP_VALIDATE_PARAMS;
    SIZE_T expect_size, diff, alloc_size, extra_size, tail_size = 0;
    unsigned char *ptr0, *ptr1, *ptr2, tail;
    char tail_buf[64], padd_buf[64];
    void *tmp_ptr, **user_ptr;
    ULONG tmp_flags;
    UINT_PTR align;
    BOOL ret;
 
    if (global_flags & (FLG_HEAP_DISABLE_COALESCING|FLG_HEAP_PAGE_ALLOCS|FLG_POOL_ENABLE_TAGGING|
                        FLG_HEAP_ENABLE_TAGGING|FLG_HEAP_ENABLE_TAG_BY_DLL))
    {
        skip( "skipping block tests\n" );
        return;
    }
 
    if (!global_flags && !alloc_flags) extra_size = 8;
    else extra_size = 2 * sizeof(void *);
    if (heap_flags & HEAP_TAIL_CHECKING_ENABLED) extra_size += 2 * sizeof(void *);
    if (heap_flags & padd_flags) extra_size += 2 * sizeof(void *);
 
    if ((heap_flags & HEAP_TAIL_CHECKING_ENABLED)) tail_size = 2 * sizeof(void *);
    memset( tail_buf, 0xab, sizeof(tail_buf) );
    memset( padd_buf, 0, sizeof(padd_buf) );
 
    for (alloc_size = 0x20000 * sizeof(void *) - 0x3000; alloc_size > 0; alloc_size >>= 1)
    {
        winetest_push_context( "size %#Ix", alloc_size );
 
        ptr0 = pHeapAlloc( heap, alloc_flags|HEAP_ZERO_MEMORY, alloc_size );
        ok( !!ptr0, "HeapAlloc failed, error %lu\n", GetLastError() );
        ptr1 = pHeapAlloc( heap, alloc_flags|HEAP_ZERO_MEMORY, alloc_size );
        ok( !!ptr1, "HeapAlloc failed, error %lu\n", GetLastError() );
        ptr2 = pHeapAlloc( heap, alloc_flags|HEAP_ZERO_MEMORY, alloc_size );
        ok( !!ptr2, "HeapAlloc failed, error %lu\n", GetLastError() );
 
        align = (UINT_PTR)ptr0 | (UINT_PTR)ptr1 | (UINT_PTR)ptr2;
        ok( !(align & (2 * sizeof(void *) - 1)), "wrong align\n" );
 
        expect_size = max( alloc_size, 2 * sizeof(void *) );
        expect_size = ALIGN_BLOCK_SIZE( expect_size + extra_size );
        diff = min( llabs( ptr2 - ptr1 ), llabs( ptr1 - ptr0 ) );
        todo_wine_if( (!global_flags && alloc_size < 2 * sizeof(void *)) ||
                      ((heap_flags & HEAP_FREE_CHECKING_ENABLED) && diff >= 0x100000) )
#ifdef __REACTOS__
        if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
        ok( diff == expect_size, "got diff %#Ix exp %#Ix\n", diff, expect_size );
        ok( !memcmp( ptr0 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
        ok( !memcmp( ptr1 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
        ok( !memcmp( ptr2 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
 
        ret = HeapFree( heap, 0, ptr2 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        ret = HeapFree( heap, 0, ptr1 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        ret = HeapFree( heap, 0, ptr0 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
        winetest_pop_context();
 
        if (diff != expect_size)
        {
            todo_wine
            win_skip("skipping sizes\n");
            break;
        }
    }
 
 
    /* between the two thresholds, tail may still be set but block position is inconsistent */
 
    alloc_size = 0x20000 * sizeof(void *) - 0x2000;
    winetest_push_context( "size %#Ix", alloc_size );
 
    ptr0 = pHeapAlloc( heap, alloc_flags|HEAP_ZERO_MEMORY, alloc_size );
    ok( !!ptr0, "HeapAlloc failed, error %lu\n", GetLastError() );
    ok( !((UINT_PTR)ptr0 & (2 * sizeof(void *) - 1)), "got unexpected ptr align\n" );
 
    ok( !memcmp( ptr0 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
 
    ret = HeapFree( heap, 0, ptr0 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    winetest_pop_context();
 
 
    for (alloc_size = 0x20000 * sizeof(void *) - 0x1000; alloc_size < 0x800000; alloc_size <<= 1)
    {
        winetest_push_context( "size %#Ix", alloc_size );
 
        ptr0 = pHeapAlloc( heap, alloc_flags|HEAP_ZERO_MEMORY, alloc_size );
        ok( !!ptr0, "HeapAlloc failed, error %lu\n", GetLastError() );
        ptr1 = pHeapAlloc( heap, alloc_flags, alloc_size );
        ok( !!ptr1, "HeapAlloc failed, error %lu\n", GetLastError() );
        ptr2 = pHeapAlloc( heap, alloc_flags, alloc_size );
        ok( !!ptr2, "HeapAlloc failed, error %lu\n", GetLastError() );
 
        align = (UINT_PTR)ptr0 | (UINT_PTR)ptr1 | (UINT_PTR)ptr2;
        ok( !(align & (8 * sizeof(void *) - 1)), "wrong align\n" );
 
        expect_size = max( alloc_size, 2 * sizeof(void *) );
        expect_size = ALIGN_BLOCK_SIZE( expect_size + extra_size );
        diff = min( llabs( ptr2 - ptr1 ), llabs( ptr1 - ptr0 ) );
        todo_wine_if( alloc_size == 0x7efe9 )
        ok( diff > expect_size, "got diff %#Ix\n", diff );
 
        tail = ptr0[alloc_size] | ptr1[alloc_size] | ptr2[alloc_size];
        ok( !tail, "got tail\n" );
 
        ret = HeapFree( heap, 0, ptr2 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        ret = HeapFree( heap, 0, ptr1 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        ret = HeapFree( heap, 0, ptr0 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        winetest_pop_context();
 
        if (diff == expect_size || (align & (8 * sizeof(void *) - 1)) || tail)
        {
            todo_wine
            win_skip("skipping sizes\n");
            break;
        }
    }
 
    /* Undocumented HEAP_ADD_USER_INFO flag can be used to force an additional padding
     * on small block sizes. Small block use it to store user info, larger blocks
     * store them in their block header instead.
     *
     * RtlGetUserInfoHeap also requires the flag to work consistently, and otherwise
     * causes crashes when heap flags are used, or on 32-bit.
     */
    if (!(heap_flags & padd_flags))
    {
        alloc_size = 0x1000;
        winetest_push_context( "size %#Ix", alloc_size );
        ptr0 = pHeapAlloc( heap, 0xc00|HEAP_ADD_USER_INFO, alloc_size );
        ok( !!ptr0, "HeapAlloc failed, error %lu\n", GetLastError() );
        ptr1 = HeapAlloc( heap, 0x200|HEAP_ADD_USER_INFO, alloc_size );
        ok( !!ptr1, "HeapAlloc failed, error %lu\n", GetLastError() );
        ptr2 = HeapAlloc( heap, HEAP_ADD_USER_INFO, alloc_size );
        ok( !!ptr2, "HeapAlloc failed, error %lu\n", GetLastError() );
 
        expect_size = max( alloc_size, 2 * sizeof(void *) );
        expect_size = ALIGN_BLOCK_SIZE( expect_size + extra_size + 2 * sizeof(void *) );
        diff = min( llabs( ptr2 - ptr1 ), llabs( ptr1 - ptr0 ) );
        ok( diff == expect_size, "got diff %#Ix\n", diff );
 
        ok( !memcmp( ptr0 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
        ok( !memcmp( ptr1 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
        ok( !memcmp( ptr2 + alloc_size, tail_buf, tail_size ), "missing block tail\n" );
 
        ok( !memcmp( ptr0 + alloc_size + tail_size, padd_buf, 2 * sizeof(void *) ), "unexpected padding\n" );
 
        tmp_ptr = (void *)0xdeadbeef;
        tmp_flags = 0xdeadbeef;
        ret = pRtlGetUserInfoHeap( heap, 0, ptr0, (void **)&tmp_ptr, &tmp_flags );
        ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
        ok( tmp_ptr == NULL, "got ptr %p\n", tmp_ptr );
        ok( tmp_flags == 0xc00, "got flags %#lx\n", tmp_flags );
 
        tmp_ptr = (void *)0xdeadbeef;
        tmp_flags = 0xdeadbeef;
        ret = pRtlGetUserInfoHeap( heap, 0, ptr1, (void **)&tmp_ptr, &tmp_flags );
        ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
        ok( tmp_ptr == NULL, "got ptr %p\n", tmp_ptr );
        ok( tmp_flags == 0x200, "got flags %#lx\n", tmp_flags );
 
        ret = pRtlSetUserValueHeap( heap, 0, ptr0, (void *)0xdeadbeef );
        ok( ret, "RtlSetUserValueHeap failed, error %lu\n", GetLastError() );
        SetLastError( 0xdeadbeef );
        ret = pRtlSetUserFlagsHeap( heap, 0, ptr0, 0, 0x1000 );
#ifdef __REACTOS__
        if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
        ok( !ret, "RtlSetUserFlagsHeap succeeded\n" );
#ifdef __REACTOS__
        ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef) /* WS03 */, "got error %lu\n", GetLastError() );
#else
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "got error %lu\n", GetLastError() );
#endif
        SetLastError( 0xdeadbeef );
        ret = pRtlSetUserFlagsHeap( heap, 0, ptr0, 0x100, 0 );
#ifdef __REACTOS__
        if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
        ok( !ret, "RtlSetUserFlagsHeap succeeded\n" );
#ifdef __REACTOS__
        ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == 0xdeadbeef) /* WS03 */, "got error %lu\n", GetLastError() );
#else
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "got error %lu\n", GetLastError() );
#endif
        ret = pRtlSetUserFlagsHeap( heap, 0, ptr0, 0x400, 0x200 );
        ok( ret, "RtlSetUserFlagsHeap failed, error %lu\n", GetLastError() );
 
        tmp_ptr = NULL;
        tmp_flags = 0;
        ret = pRtlGetUserInfoHeap( heap, 0, ptr0, (void **)&tmp_ptr, &tmp_flags );
        ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
        ok( tmp_ptr == (void *)0xdeadbeef, "got ptr %p\n", tmp_ptr );
        ok( tmp_flags == 0xa00 || broken(tmp_flags == 0xc00) /* w1064v1507 */,
            "got flags %#lx\n", tmp_flags );
 
        user_ptr = (void **)(ptr0 + alloc_size + tail_size);
        ok( user_ptr[1] == (void *)0xdeadbeef, "unexpected user value\n" );
        user_ptr[0] = (void *)0xdeadbeef;
        user_ptr[1] = (void *)0xdeadbee0;
 
        tmp_ptr = NULL;
        tmp_flags = 0;
        ret = pRtlGetUserInfoHeap( heap, 0, ptr0, (void **)&tmp_ptr, &tmp_flags );
        ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
        ok( tmp_ptr == (void *)0xdeadbee0, "got ptr %p\n", tmp_ptr );
        ok( tmp_flags == 0xa00 || broken(tmp_flags == 0xc00) /* w1064v1507 */,
            "got flags %#lx\n", tmp_flags );
 
        ret = HeapFree( heap, 0, ptr2 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        ret = HeapFree( heap, 0, ptr1 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        ret = HeapFree( heap, 0, ptr0 );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
        winetest_pop_context();
    }
}

Referenced by test_child_heap().

test_child_heap()

static void test_child_heap ( const char *  arg )

static

Definition at line 3752 of file heap.c.

{
    char buffer[32];
    DWORD global_flags = strtoul( arg, 0, 16 ), type, size = sizeof(buffer);
    DWORD heap_flags;
    HANDLE heap;
    HKEY hkey;
    BOOL ret;
 
    if (global_flags == 0xdeadbeef)  /* global_flags value comes from Session Manager global flags */
    {
        ret = RegOpenKeyA( HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Session Manager", &hkey );
        if (!ret)
        {
            skip( "Session Manager flags not set\n" );
            return;
        }
 
        ret = RegQueryValueExA( hkey, "GlobalFlag", 0, &type, (BYTE *)buffer, &size );
        ok( ret, "RegQueryValueExA failed, error %lu\n", GetLastError() );
 
        if (type == REG_DWORD) global_flags = *(DWORD *)buffer;
        else if (type == REG_SZ) global_flags = strtoul( buffer, 0, 16 );
 
        ret = RegCloseKey( hkey );
        ok( ret, "RegCloseKey failed, error %lu\n", GetLastError() );
    }
    if (global_flags && !pRtlGetNtGlobalFlags())  /* not working on NT4 */
    {
        win_skip( "global flags not set\n" );
        return;
    }
 
    heap_flags = heap_flags_from_global_flag( global_flags );
    trace( "testing global flags %#lx, heap flags %08lx\n", global_flags, heap_flags );
 
    ok( pRtlGetNtGlobalFlags() == global_flags, "got global flags %#lx\n", pRtlGetNtGlobalFlags() );
 
    test_heap_layout( GetProcessHeap(), global_flags, heap_flags|HEAP_GROWABLE );
 
    heap = HeapCreate( 0, 0, 0 );
    ok( heap != GetProcessHeap(), "got unexpected heap\n" );
    test_heap_layout( heap, global_flags, heap_flags|HEAP_GROWABLE|HEAP_PRIVATE );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
    heap = HeapCreate( HEAP_NO_SERIALIZE, 0, 0 );
    ok( heap != GetProcessHeap(), "got unexpected heap\n" );
    test_heap_layout( heap, global_flags, heap_flags|HEAP_NO_SERIALIZE|HEAP_GROWABLE|HEAP_PRIVATE );
    test_block_layout( heap, global_flags, heap_flags|HEAP_NO_SERIALIZE|HEAP_GROWABLE|HEAP_PRIVATE, 0 );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
    heap = HeapCreate( HEAP_TAIL_CHECKING_ENABLED|HEAP_FREE_CHECKING_ENABLED|HEAP_NO_SERIALIZE, 0, 0 );
    ok( heap != GetProcessHeap(), "got unexpected heap\n" );
    test_heap_layout( heap, global_flags, heap_flags|HEAP_NO_SERIALIZE|HEAP_GROWABLE|HEAP_PRIVATE );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
    heap = HeapCreate( HEAP_NO_SERIALIZE, 0, 0 );
    ok( heap != GetProcessHeap(), "got unexpected heap\n" );
    test_block_layout( heap, global_flags, heap_flags|HEAP_NO_SERIALIZE|HEAP_GROWABLE|HEAP_PRIVATE,
                       HEAP_TAIL_CHECKING_ENABLED|HEAP_FREE_CHECKING_ENABLED );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
    heap = HeapCreate( 0, 0x1000, 0x10000 );
    ok( heap != GetProcessHeap(), "got unexpected heap\n" );
    test_heap_layout( heap, global_flags, heap_flags|HEAP_PRIVATE );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
    heap = HeapCreate( HEAP_SHARED, 0, 0 );
    ok( heap != GetProcessHeap(), "got unexpected heap\n" );
    test_heap_layout( heap, global_flags, heap_flags|HEAP_GROWABLE|HEAP_PRIVATE );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
    test_heap_checks( heap_flags );
}

Referenced by START_TEST().

test_debug_heap()

static void test_debug_heap ( const char *  argv0, DWORD  flags  )

static

Definition at line 3650 of file heap.c.

{
    char keyname[MAX_PATH];
    char buffer[MAX_PATH];
    PROCESS_INFORMATION info;
    STARTUPINFOA startup;
    BOOL ret;
    DWORD err;
    HKEY hkey;
    const char *basename;
 
    if ((basename = strrchr( argv0, '\\' ))) basename++;
    else basename = argv0;
 
    sprintf( keyname, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
             basename );
    if (!strcmp( keyname + strlen(keyname) - 3, ".so" )) keyname[strlen(keyname) - 3] = 0;
 
    err = RegCreateKeyA( HKEY_LOCAL_MACHINE, keyname, &hkey );
    if (err == ERROR_ACCESS_DENIED)
    {
        skip("Not authorized to change the image file execution options\n");
        return;
    }
    ok( !err, "failed to create '%s' error %lu\n", keyname, err );
    if (err) return;
 
    if (flags == 0xdeadbeef)  /* magic value for unsetting it */
        RegDeleteValueA( hkey, "GlobalFlag" );
    else
        RegSetValueExA( hkey, "GlobalFlag", 0, REG_DWORD, (BYTE *)&flags, sizeof(flags) );
 
    memset( &startup, 0, sizeof(startup) );
    startup.cb = sizeof(startup);
 
    sprintf( buffer, "%s heap.c 0x%lx", argv0, flags );
    ret = CreateProcessA( NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info );
    ok( ret, "failed to create child process error %lu\n", GetLastError() );
    if (ret)
    {
        wait_child_process( info.hProcess );
        CloseHandle( info.hThread );
        CloseHandle( info.hProcess );
    }
    RegDeleteValueA( hkey, "GlobalFlag" );
    RegCloseKey( hkey );
    RegDeleteKeyA( HKEY_LOCAL_MACHINE, keyname );
}

Referenced by START_TEST().

test_GetPhysicallyInstalledSystemMemory()

static void test_GetPhysicallyInstalledSystemMemory ( void  )

static

Definition at line 3833 of file heap.c.

{
    MEMORYSTATUSEX memstatus;
    ULONGLONG total_memory;
    BOOL ret;
 
    if (!pGetPhysicallyInstalledSystemMemory)
    {
        win_skip("GetPhysicallyInstalledSystemMemory is not available\n");
        return;
    }
 
    SetLastError(0xdeadbeef);
    ret = pGetPhysicallyInstalledSystemMemory(NULL);
    ok(!ret, "GetPhysicallyInstalledSystemMemory should fail\n");
    ok(GetLastError() == ERROR_INVALID_PARAMETER,
       "expected ERROR_INVALID_PARAMETER, got %lu\n", GetLastError());
 
    total_memory = 0;
    ret = pGetPhysicallyInstalledSystemMemory(&total_memory);
#ifdef __REACTOS__
    ok(ret || broken(GetLastError() == ERROR_INVALID_FUNCTION) /* Vista x64 ROS testbot */, "GetPhysicallyInstalledSystemMemory unexpectedly failed (%lu)\n", GetLastError());
    if (ret)
        ok(total_memory != 0, "expected total_memory != 0\n");
#else
    ok(ret, "GetPhysicallyInstalledSystemMemory unexpectedly failed (%lu)\n", GetLastError());
    ok(total_memory != 0, "expected total_memory != 0\n");
#endif
 
    memstatus.dwLength = sizeof(memstatus);
    ret = GlobalMemoryStatusEx(&memstatus);
    ok(ret, "GlobalMemoryStatusEx unexpectedly failed\n");
#ifdef __REACTOS__
    ok(total_memory >= memstatus.ullTotalPhys / 1024 || broken(total_memory == 0) /* Vista x64 ROS testbot */,
       "expected total_memory >= memstatus.ullTotalPhys / 1024\n");
#else
    ok(total_memory >= memstatus.ullTotalPhys / 1024,
       "expected total_memory >= memstatus.ullTotalPhys / 1024\n");
#endif
}

Referenced by START_TEST().

test_GlobalAlloc()

static void test_GlobalAlloc ( void  )

static

Definition at line 1439 of file heap.c.

{
    static const UINT flags_tests[] =
    {
        GMEM_FIXED | GMEM_NOTIFY,
        GMEM_FIXED | GMEM_DISCARDABLE,
        GMEM_MOVEABLE | GMEM_NOTIFY,
        GMEM_MOVEABLE | GMEM_DDESHARE,
        GMEM_MOVEABLE | GMEM_NOT_BANKED,
        GMEM_MOVEABLE | GMEM_NODISCARD,
        GMEM_MOVEABLE | GMEM_DISCARDABLE,
        GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_DISCARDABLE | GMEM_LOWER | GMEM_NOCOMPACT | GMEM_NODISCARD | GMEM_NOT_BANKED | GMEM_NOTIFY,
    };
    static const UINT realloc_flags_tests[] =
    {
        GMEM_FIXED,
        GMEM_FIXED | GMEM_MODIFY,
        GMEM_MOVEABLE,
        GMEM_MOVEABLE | GMEM_MODIFY,
        GMEM_MOVEABLE | GMEM_DISCARDABLE,
        GMEM_MOVEABLE | GMEM_MODIFY | GMEM_DISCARDABLE,
        GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_DISCARDABLE | GMEM_LOWER | GMEM_NOCOMPACT | GMEM_NODISCARD | GMEM_NOT_BANKED | GMEM_NOTIFY,
        GMEM_MOVEABLE | GMEM_MODIFY | GMEM_DDESHARE | GMEM_DISCARDABLE | GMEM_LOWER | GMEM_NOCOMPACT | GMEM_NODISCARD | GMEM_NOT_BANKED | GMEM_NOTIFY,
    };
    static const char zero_buffer[100000] = {0};
    static const SIZE_T buffer_size = ARRAY_SIZE(zero_buffer);
    const HGLOBAL invalid_mem = LongToHandle( 0xdeadbee0 + sizeof(void *) );
    SIZE_T size, alloc_size, small_size = 12, nolfh_size = 0x20000;
    void *const invalid_ptr = LongToHandle( 0xdeadbee0 );
    HANDLE heap = GetProcessHeap();
    PROCESS_HEAP_ENTRY walk_entry;
    struct mem_entry *entry;
    HGLOBAL globals[0x10000];
    HGLOBAL mem, tmp_mem;
    BYTE *ptr, *tmp_ptr;
    ULONG tmp_flags;
    UINT i, flags;
    BOOL ret;
 
    mem = GlobalFree( 0 );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
    mem = GlobalReAlloc( 0, 10, GMEM_MOVEABLE );
    ok( !mem, "GlobalReAlloc succeeded\n" );
 
    for (i = 0; i < ARRAY_SIZE(globals); ++i)
    {
        mem = GlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, 0 );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        globals[i] = mem;
    }
 
    memset( &walk_entry, 0xcd, sizeof(walk_entry) );
    walk_entry.lpData = NULL;
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    while ((ret = HeapWalk( heap, &walk_entry )))
    {
        ok( !(walk_entry.wFlags & PROCESS_HEAP_ENTRY_MOVEABLE), "got PROCESS_HEAP_ENTRY_MOVEABLE\n" );
        ok( !(walk_entry.wFlags & PROCESS_HEAP_ENTRY_DDESHARE), "got PROCESS_HEAP_ENTRY_DDESHARE\n" );
    }
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    mem = GlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, 0 );
    ok( !mem, "GlobalAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    mem = LocalAlloc( LMEM_MOVEABLE | LMEM_DISCARDABLE, 0 );
    ok( !mem, "LocalAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
 
    mem = GlobalAlloc( GMEM_DISCARDABLE, 0 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    for (i = 0; i < ARRAY_SIZE(globals); ++i)
    {
        mem = GlobalFree( globals[i] );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
    }
 
    /* make sure LFH is enabled for some small block size */
    for (i = 0; i < 0x12; i++) globals[i] = pGlobalAlloc( GMEM_FIXED, small_size );
    for (i = 0; i < 0x12; i++) pGlobalFree( globals[i] );
 
    mem = GlobalAlloc( GMEM_MOVEABLE, 0 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    mem = GlobalReAlloc( mem, 10, GMEM_MOVEABLE );
    ok( !!mem, "GlobalReAlloc failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size >= 10 && size <= 16, "GlobalSize returned %Iu\n", size );
    mem = GlobalReAlloc( mem, 0, GMEM_MOVEABLE );
    ok( !!mem, "GlobalReAlloc failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size == 0, "GlobalSize returned %Iu\n", size );
    mem = GlobalReAlloc( mem, 10, GMEM_MOVEABLE );
    ok( !!mem, "GlobalReAlloc failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size >= 10 && size <= 16, "GlobalSize returned %Iu\n", size );
    tmp_mem = pGlobalFree( mem );
    ok( !tmp_mem, "GlobalFree failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size == 0, "GlobalSize returned %Iu\n", size );
 
    mem = pGlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, 0 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    entry = mem_entry_from_HANDLE( mem );
    size = GlobalSize( mem );
    ok( size == 0, "GlobalSize returned %Iu\n", size );
    ret = HeapValidate( GetProcessHeap(), 0, entry );
    ok( !ret, "HeapValidate succeeded\n" );
    ok( entry->flags == 0xf, "got unexpected flags %#Ix\n", entry->flags );
    ok( !entry->ptr, "got unexpected ptr %p\n", entry->ptr );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    mem = pGlobalAlloc( GMEM_MOVEABLE, 0 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    entry = mem_entry_from_HANDLE( mem );
    size = GlobalSize( mem );
    ok( size == 0, "GlobalSize returned %Iu\n", size );
    ret = HeapValidate( GetProcessHeap(), 0, entry );
    ok( !ret, "HeapValidate succeeded\n" );
    ok( entry->flags == 0xb, "got unexpected flags %#Ix\n", entry->flags );
    ok( !entry->ptr, "got unexpected ptr %p\n", entry->ptr );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    for (alloc_size = 1; alloc_size < 0x10000000; alloc_size <<= 5)
    {
        winetest_push_context( "size %#Ix", alloc_size );
 
        mem = GlobalAlloc( GMEM_FIXED, alloc_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !((UINT_PTR)mem & sizeof(void *)), "got unexpected ptr align\n" );
        ok( !((UINT_PTR)mem & (sizeof(void *) - 1)), "got unexpected ptr align\n" );
        ret = HeapValidate( GetProcessHeap(), 0, mem );
        ok( ret, "HeapValidate failed, error %lu\n", GetLastError() );
        tmp_mem = GlobalFree( mem );
        ok( !tmp_mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, alloc_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( ((UINT_PTR)mem & sizeof(void *)), "got unexpected entry align\n" );
        ok( !((UINT_PTR)mem & (sizeof(void *) - 1)), "got unexpected entry align\n" );
 
        entry = mem_entry_from_HANDLE( mem );
        ret = HeapValidate( GetProcessHeap(), 0, entry );
        ok( !ret, "HeapValidate succeeded\n" );
        ret = HeapValidate( GetProcessHeap(), 0, entry->ptr );
        ok( ret, "HeapValidate failed, error %lu\n", GetLastError() );
        size = HeapSize( GetProcessHeap(), 0, entry->ptr );
        ok( size == alloc_size, "HeapSize returned %Iu\n", size );
 
        tmp_mem = invalid_mem;
        tmp_flags = 0xdeadbeef;
        ret = pRtlGetUserInfoHeap( GetProcessHeap(), 0, entry->ptr, (void **)&tmp_mem, &tmp_flags );
        ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
        ok( tmp_mem == mem, "got user ptr %p\n", tmp_mem );
        ok( tmp_flags == 0x200, "got user flags %#lx\n", tmp_flags );
 
        ret = pRtlSetUserValueHeap( GetProcessHeap(), 0, entry->ptr, invalid_mem );
        ok( ret, "RtlSetUserValueHeap failed, error %lu\n", GetLastError() );
        tmp_mem = GlobalHandle( entry->ptr );
        ok( tmp_mem == invalid_mem, "GlobalHandle returned unexpected handle\n" );
        ret = pRtlSetUserValueHeap( GetProcessHeap(), 0, entry->ptr, mem );
        ok( ret, "RtlSetUserValueHeap failed, error %lu\n", GetLastError() );
 
        ptr = GlobalLock( mem );
        ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
        ok( ptr != mem, "got unexpected ptr %p\n", ptr );
        ok( ptr == entry->ptr, "got unexpected ptr %p\n", ptr );
        ok( !((UINT_PTR)ptr & sizeof(void *)), "got unexpected ptr align\n" );
        ok( !((UINT_PTR)ptr & (sizeof(void *) - 1)), "got unexpected ptr align\n" );
        for (i = 1; i < 0xff; ++i)
        {
            ok( entry->flags == ((i<<16)|3), "got unexpected flags %#Ix\n", entry->flags );
            ptr = GlobalLock( mem );
            ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
        }
        ptr = GlobalLock( mem );
        ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
        ok( entry->flags == 0xff0003, "got unexpected flags %#Ix\n", entry->flags );
        for (i = 1; i < 0xff; ++i)
        {
            ret = GlobalUnlock( mem );
            ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
        }
        ret = GlobalUnlock( mem );
        ok( !ret, "GlobalUnlock succeeded, error %lu\n", GetLastError() );
        ok( entry->flags == 0x3, "got unexpected flags %#Ix\n", entry->flags );
 
        tmp_mem = pGlobalFree( mem );
        ok( !tmp_mem, "GlobalFree failed, error %lu\n", GetLastError() );
        ok( !!entry->flags, "got unexpected flags %#Ix\n", entry->flags );
        ok( !((UINT_PTR)entry->flags & sizeof(void *)), "got unexpected ptr align\n" );
        ok( !((UINT_PTR)entry->flags & (sizeof(void *) - 1)), "got unexpected ptr align\n" );
        ok( !entry->ptr, "got unexpected ptr %p\n", entry->ptr );
 
        mem = pGlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, 0 );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        entry = mem_entry_from_HANDLE( mem );
        ok( entry->flags == 0xf, "got unexpected flags %#Ix\n", entry->flags );
        ok( !entry->ptr, "got unexpected ptr %p\n", entry->ptr );
        flags = GlobalFlags( mem );
        ok( flags == (GMEM_DISCARDED | GMEM_DISCARDABLE), "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
        mem = pGlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, 1 );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        entry = mem_entry_from_HANDLE( mem );
        ok( entry->flags == 0x7, "got unexpected flags %#Ix\n", entry->flags );
        ok( !!entry->ptr, "got unexpected ptr %p\n", entry->ptr );
        flags = GlobalFlags( mem );
        ok( flags == GMEM_DISCARDABLE, "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
        mem = pGlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE | GMEM_DDESHARE, 1 );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        entry = mem_entry_from_HANDLE( mem );
        ok( entry->flags == 0x8007, "got unexpected flags %#Ix\n", entry->flags );
        ok( !!entry->ptr, "got unexpected ptr %p\n", entry->ptr );
        flags = GlobalFlags( mem );
        ok( flags == (GMEM_DISCARDABLE | GMEM_DDESHARE), "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
        winetest_pop_context();
    }
 
    mem = GlobalAlloc( GMEM_MOVEABLE, 256 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    ptr = GlobalLock( mem );
    ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
    ok( ptr != mem, "got unexpected ptr %p\n", ptr );
    tmp_mem = GlobalHandle( ptr );
    ok( tmp_mem == mem, "GlobalHandle returned unexpected handle\n" );
    flags = GlobalFlags( mem );
    ok( flags == 1, "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
    tmp_ptr = GlobalLock( mem );
    ok( !!tmp_ptr, "GlobalLock failed, error %lu\n", GetLastError() );
    ok( tmp_ptr == ptr, "got ptr %p, expected %p\n", tmp_ptr, ptr );
    flags = GlobalFlags( mem );
    ok( flags == 2, "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
    ret = GlobalUnlock( mem );
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
    flags = GlobalFlags( mem );
    ok( flags == 1, "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = GlobalUnlock( mem );
    ok( !ret, "GlobalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_SUCCESS, "got error %lu\n", GetLastError() );
    flags = GlobalFlags( mem );
    ok( !flags, "GlobalFlags returned %#x, error %lu\n", flags, GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = GlobalUnlock( mem );
    ok( !ret, "GlobalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_NOT_LOCKED, "got error %lu\n", GetLastError() );
    tmp_mem = GlobalFree( mem );
    ok( !tmp_mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    mem = GlobalAlloc( GMEM_DDESHARE, 100 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = pGlobalFree( mem );
    ok( !tmp_mem, "GlobalFree failed, error %lu\n", GetLastError() );
    if (sizeof(void *) != 8) /* crashes on 64-bit */
    {
        SetLastError( 0xdeadbeef );
        tmp_mem = pGlobalFree( mem );
        ok( tmp_mem == mem, "GlobalFree succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
 
        SetLastError( 0xdeadbeef );
        size = GlobalSize( (HGLOBAL)0xc042 );
        ok( size == 0, "GlobalSize succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    }
 
    /* freed handles are caught */
    mem = GlobalAlloc( GMEM_MOVEABLE, 256 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = pGlobalFree( mem );
    ok( !tmp_mem, "GlobalFree failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = pGlobalFree( mem );
    ok( tmp_mem == mem, "GlobalFree succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    flags = GlobalFlags( mem );
    ok( flags == GMEM_INVALID_HANDLE, "GlobalFlags succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    size = GlobalSize( mem );
    ok( size == 0, "GlobalSize succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = GlobalLock( mem );
    ok( !ptr, "GlobalLock succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = GlobalUnlock( mem );
    todo_wine
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = GlobalReAlloc( mem, 0, GMEM_MOVEABLE );
    ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    if (sizeof(void *) != 8 && GetNTVersion() >= _WIN32_WINNT_VISTA) /* crashes on 64-bit, invalid on WS03 */
#else
    if (sizeof(void *) != 8) /* crashes on 64-bit */
#endif
    {
        SetLastError( 0xdeadbeef );
        tmp_mem = GlobalHandle( mem );
        ok( !tmp_mem, "GlobalHandle succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    }
 
#ifdef __REACTOS__
    if (is_reactos()) {
        ok(FALSE, "FIXME: invalid handle and invalid pointer tests crash on ReactOS!\n");
    } else {
#endif
    /* invalid handles are caught */
    SetLastError( 0xdeadbeef );
    tmp_mem = pGlobalFree( invalid_mem );
    ok( tmp_mem == invalid_mem, "GlobalFree succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    flags = GlobalFlags( invalid_mem );
    ok( flags == GMEM_INVALID_HANDLE, "GlobalFlags succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    size = GlobalSize( invalid_mem );
    ok( size == 0, "GlobalSize succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = GlobalLock( invalid_mem );
    ok( !ptr, "GlobalLock succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = GlobalUnlock( invalid_mem );
    todo_wine
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = GlobalReAlloc( invalid_mem, 0, GMEM_MOVEABLE );
    ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    if (sizeof(void *) != 8) /* crashes on 64-bit */
    {
        SetLastError( 0xdeadbeef );
        tmp_mem = GlobalHandle( invalid_mem );
        ok( !tmp_mem, "GlobalHandle succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
        SetLastError( 0xdeadbeef );
        ret = pRtlGetUserInfoHeap( GetProcessHeap(), 0, invalid_mem, (void **)&tmp_ptr, &tmp_flags );
        ok( !ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
        ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == ERROR_NOACCESS) /* WS03 */, "got error %lu\n", GetLastError() );
#else
        ok( GetLastError() == ERROR_INVALID_PARAMETER, "got error %lu\n", GetLastError() );
#endif
    }
 
    /* invalid pointers are caught */
    SetLastError( 0xdeadbeef );
    tmp_mem = pGlobalFree( invalid_ptr );
    ok( tmp_mem == invalid_ptr, "GlobalFree succeeded\n" );
    todo_wine
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOACCESS || broken(GetLastError() == ERROR_INVALID_HANDLE) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
#endif
    SetLastError( 0xdeadbeef );
    flags = GlobalFlags( invalid_ptr );
    todo_wine
    ok( flags == GMEM_INVALID_HANDLE, "GlobalFlags succeeded\n" );
    todo_wine
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    size = GlobalSize( invalid_ptr );
    ok( size == 0, "GlobalSize succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = GlobalLock( invalid_ptr );
    ok( !ptr, "GlobalLock succeeded\n" );
    todo_wine
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = GlobalUnlock( invalid_ptr );
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
    ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = GlobalReAlloc( invalid_ptr, 0, GMEM_MOVEABLE );
    ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
    todo_wine
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = GlobalHandle( invalid_ptr );
    ok( !tmp_mem, "GlobalHandle succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    if (0) /* crashes */
    {
        SetLastError( 0xdeadbeef );
        ret = pRtlGetUserInfoHeap( GetProcessHeap(), 0, invalid_ptr, (void **)&tmp_ptr, &tmp_flags );
        ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    }
#ifdef __REACTOS__
    }
#endif
 
    /* GMEM_FIXED block doesn't allow resize, though it succeeds with GMEM_MODIFY */
    mem = GlobalAlloc( GMEM_FIXED, small_size );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = GlobalReAlloc( mem, small_size - 1, GMEM_MODIFY );
    ok( !!tmp_mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    ok( tmp_mem == mem, "got ptr %p, expected %p\n", tmp_mem, mem );
    size = GlobalSize( mem );
    ok( size == small_size, "GlobalSize returned %Iu\n", size );
    SetLastError( 0xdeadbeef );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    tmp_mem = GlobalReAlloc( mem, small_size, 0 );
    ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    }
#endif
    if (tmp_mem) mem = tmp_mem;
    tmp_mem = GlobalReAlloc( mem, 1024 * 1024, GMEM_MODIFY );
    ok( !!tmp_mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    ok( tmp_mem == mem, "got ptr %p, expected %p\n", tmp_mem, mem );
    size = GlobalSize( mem );
    ok( size == small_size, "GlobalSize returned %Iu\n", size );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    /* GMEM_FIXED block can be relocated with GMEM_MOVEABLE */
    mem = GlobalAlloc( GMEM_FIXED, small_size );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = GlobalReAlloc( mem, small_size + 1, GMEM_MOVEABLE );
    ok( !!tmp_mem, "GlobalReAlloc failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok( tmp_mem != mem, "GlobalReAlloc didn't relocate memory\n" );
    ptr = GlobalLock( tmp_mem );
    ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
    ok( ptr == tmp_mem, "got ptr %p, expected %p\n", ptr, tmp_mem );
    mem = GlobalFree( tmp_mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    /* test GlobalReAlloc flags / GlobalLock combinations */
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA) { skip("realloc_flags_tests invalid for WS03.\n"); }
    else {
#endif
    for (i = 0; i < ARRAY_SIZE(realloc_flags_tests); i++)
    {
        struct mem_entry expect_entry, entry;
        BOOL expect_convert;
 
        flags = realloc_flags_tests[i];
        expect_convert = (flags & (GMEM_MOVEABLE | GMEM_MODIFY)) == (GMEM_MOVEABLE | GMEM_MODIFY);
 
        winetest_push_context( "flags %#x", flags );
 
        mem = pGlobalAlloc( GMEM_FIXED, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = GlobalReAlloc( mem, 512, flags );
        if (!expect_convert)
        {
            ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            if (flags == GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
            else if (flags != GMEM_MOVEABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
            else ok( tmp_mem != mem, "GlobalReAlloc returned %p\n", tmp_mem );
        }
        else
        {
            ok( is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            entry = *mem_entry_from_HANDLE( tmp_mem );
            todo_wine ok( entry.ptr != mem, "got ptr %p was %p\n", entry.ptr, mem );
            if (flags & GMEM_DISCARDABLE) ok( (entry.flags & 0x7fff) == 0x7, "got flags %#Ix\n", entry.flags );
            else ok( (entry.flags & 0x7fff) == 0x3, "got flags %#Ix\n", entry.flags );
        }
        if (tmp_mem) mem = tmp_mem;
 
        size = GlobalSize( mem );
        if (flags == GMEM_MOVEABLE) ok( size == 512, "GlobalSize returned %Iu\n", size );
        else ok( size == small_size, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_FIXED, nolfh_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = GlobalReAlloc( mem, nolfh_size + 512, flags );
        if (!expect_convert)
        {
            ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
            else ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
        }
        else
        {
            ok( is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            entry = *mem_entry_from_HANDLE( tmp_mem );
            todo_wine ok( entry.ptr != mem, "got ptr %p was %p\n", entry.ptr, mem );
            if (flags & GMEM_DISCARDABLE) ok( (entry.flags & 0x7fff) == 0x7, "got flags %#Ix\n", entry.flags );
            else ok( (entry.flags & 0x7fff) == 0x3, "got flags %#Ix\n", entry.flags );
        }
        if (tmp_mem) mem = tmp_mem;
 
        size = GlobalSize( mem );
        if (flags & (GMEM_MODIFY | GMEM_DISCARDABLE)) ok( size == nolfh_size, "GlobalSize returned %Iu\n", size );
        else ok( size == nolfh_size + 512, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_FIXED, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = GlobalReAlloc( mem, 10, flags );
        if (!expect_convert)
        {
            ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            if (flags == GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
            else if (flags != GMEM_MOVEABLE) todo_wine_if(!flags) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
            else todo_wine ok( tmp_mem != mem, "GlobalReAlloc returned %p\n", tmp_mem );
        }
        else
        {
            ok( is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            entry = *mem_entry_from_HANDLE( tmp_mem );
            ok( entry.ptr == ptr, "got ptr %p was %p\n", entry.ptr, ptr );
            if (flags & GMEM_DISCARDABLE) ok( (entry.flags & 0x7fff) == 0x7, "got flags %#Ix\n", entry.flags );
            else ok( (entry.flags & 0x7fff) == 0x3, "got flags %#Ix\n", entry.flags );
        }
        if (tmp_mem) mem = tmp_mem;
 
        size = GlobalSize( mem );
        if (flags == GMEM_MOVEABLE) ok( size == 10, "GlobalSize returned %Iu\n", size );
        else todo_wine_if(!flags) ok( size == small_size, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_FIXED, nolfh_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = GlobalReAlloc( mem, 10, flags );
        if (!expect_convert)
        {
            ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
            else ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
        }
        else
        {
            ok( is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            entry = *mem_entry_from_HANDLE( tmp_mem );
            ok( entry.ptr != ptr, "got ptr %p was %p\n", entry.ptr, ptr );
            if (flags & GMEM_DISCARDABLE) ok( (entry.flags & 0x7fff) == 0x7, "got flags %#Ix\n", entry.flags );
            else ok( (entry.flags & 0x7fff) == 0x3, "got flags %#Ix\n", entry.flags );
        }
        if (tmp_mem) mem = tmp_mem;
 
        size = GlobalSize( mem );
        if (flags & (GMEM_MODIFY | GMEM_DISCARDABLE)) ok( size == nolfh_size, "GlobalSize returned %Iu\n", size );
        else ok( size == 10, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_FIXED, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = GlobalReAlloc( mem, 0, flags );
        if (!expect_convert)
        {
            ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            if (flags == GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
            else if (flags != GMEM_MOVEABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
            else ok( tmp_mem != mem, "GlobalReAlloc returned %p\n", tmp_mem );
        }
        else
        {
            ok( is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            entry = *mem_entry_from_HANDLE( tmp_mem );
            ok( entry.ptr == ptr, "got ptr %p was %p\n", entry.ptr, ptr );
            if (flags & GMEM_DISCARDABLE) ok( (entry.flags & 0x7fff) == 0x7, "got flags %#Ix\n", entry.flags );
            else ok( (entry.flags & 0x7fff) == 0x3, "got flags %#Ix\n", entry.flags );
        }
        if (tmp_mem) mem = tmp_mem;
 
        size = GlobalSize( mem );
        if (flags == GMEM_MOVEABLE) ok( size == 0 || broken( size == 1 ) /* w7 */, "GlobalSize returned %Iu\n", size );
        else ok( size == small_size, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_FIXED, nolfh_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = GlobalReAlloc( mem, 0, flags );
        if (!expect_convert)
        {
            ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
            else ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
        }
        else
        {
            ok( is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
            entry = *mem_entry_from_HANDLE( tmp_mem );
            ok( entry.ptr != ptr, "got ptr %p was %p\n", entry.ptr, ptr );
            if (flags & GMEM_DISCARDABLE) ok( (entry.flags & 0x7fff) == 0x7, "got flags %#Ix\n", entry.flags );
            else ok( (entry.flags & 0x7fff) == 0x3, "got flags %#Ix\n", entry.flags );
        }
        if (tmp_mem) mem = tmp_mem;
 
        size = GlobalSize( mem );
        if (flags & (GMEM_MODIFY | GMEM_DISCARDABLE)) ok( size == nolfh_size, "GlobalSize returned %Iu\n", size );
        else ok( size == 0 || broken( size == 1 ) /* w7 */, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = GlobalLock( mem );
        ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = GlobalReAlloc( mem, 512, flags );
        if (flags & GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p\n", tmp_mem );
        else if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        else if (flags & GMEM_MOVEABLE) ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
#ifdef __REACTOS__
        else ok( !tmp_mem || broken(GetNTVersion() == _WIN32_WINNT_VISTA), "GlobalReAlloc succeeded\n" );
#else
        else ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
#endif
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
#ifdef __REACTOS__
        if (flags == GMEM_MOVEABLE) ok( entry.ptr != expect_entry.ptr || broken(GetNTVersion() == _WIN32_WINNT_VISTA), "got unexpected ptr %p\n", entry.ptr );
#else
        if (flags == GMEM_MOVEABLE) ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
#endif
        else ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = GlobalSize( mem );
        if (flags == GMEM_MOVEABLE) ok( size == 512, "GlobalSize returned %Iu\n", size );
#ifdef __REACTOS__
        else ok( size == small_size || broken(size == 512) /* Vista */, "GlobalSize returned %Iu\n", size );
#else
        else ok( size == small_size, "GlobalSize returned %Iu\n", size );
#endif
 
        ret = GlobalUnlock( mem );
        ok( !ret, "GlobalUnlock succeeded\n" );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = GlobalLock( mem );
        ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = GlobalReAlloc( mem, 10, flags );
        if (flags & GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = GlobalSize( mem );
        if (flags & (GMEM_DISCARDABLE | GMEM_MODIFY)) ok( size == small_size, "GlobalSize returned %Iu\n", size );
        else ok( size == 10, "GlobalSize returned %Iu\n", size );
 
        ret = GlobalUnlock( mem );
        ok( !ret, "GlobalUnlock succeeded\n" );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = GlobalLock( mem );
        ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = GlobalReAlloc( mem, 0, flags );
        if (flags & GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = GlobalSize( mem );
        ok( size == small_size, "GlobalSize returned %Iu\n", size );
 
        ret = GlobalUnlock( mem );
        ok( !ret, "GlobalUnlock succeeded\n" );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = GlobalReAlloc( mem, 512, flags );
        if (flags & GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
        if (flags & (GMEM_DISCARDABLE | GMEM_MODIFY)) ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
#ifdef __REACTOS__
        else ok( entry.ptr != expect_entry.ptr || broken(GetNTVersion() == _WIN32_WINNT_VISTA), "got unexpected ptr %p\n", entry.ptr );
#else
        else ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
#endif
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = GlobalSize( mem );
        if (flags & (GMEM_DISCARDABLE | GMEM_MODIFY)) ok( size == small_size, "GlobalSize returned %Iu\n", size );
        else ok( size == 512, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = GlobalReAlloc( mem, 10, flags );
        if (flags & GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = GlobalSize( mem );
        if (flags & (GMEM_DISCARDABLE | GMEM_MODIFY)) ok( size == small_size, "GlobalSize returned %Iu\n", size );
        else ok( size == 10, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pGlobalAlloc( GMEM_MOVEABLE, small_size );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = GlobalReAlloc( mem, 0, flags );
        if (flags & GMEM_MODIFY) ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags == GMEM_FIXED) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        else if (flags & GMEM_DISCARDABLE) ok( !tmp_mem, "GlobalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "GlobalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if (flags == GMEM_MOVEABLE)
        {
            expect_entry.flags |= 8;
            expect_entry.ptr = NULL;
        }
        else if ((flags & GMEM_DISCARDABLE) && (flags & GMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = GlobalSize( mem );
        if (flags == GMEM_MOVEABLE) ok( size == 0, "GlobalSize returned %Iu\n", size );
        else ok( size == small_size, "GlobalSize returned %Iu\n", size );
 
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
        winetest_pop_context();
    }
#ifdef __REACTOS__
    }
#endif
 
    mem = GlobalAlloc( GMEM_DDESHARE, 100 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    ret = GlobalUnlock( mem );
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
    ret = GlobalUnlock( mem );
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
 
    memset( &walk_entry, 0xcd, sizeof(walk_entry) );
    walk_entry.lpData = NULL;
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    while ((ret = HeapWalk( heap, &walk_entry )))
    {
        ok( !(walk_entry.wFlags & PROCESS_HEAP_ENTRY_MOVEABLE), "got PROCESS_HEAP_ENTRY_MOVEABLE\n" );
        ok( !(walk_entry.wFlags & PROCESS_HEAP_ENTRY_DDESHARE), "got PROCESS_HEAP_ENTRY_DDESHARE\n" );
    }
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
 
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    mem = GlobalAlloc( GMEM_FIXED, 100 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    ret = GlobalUnlock( mem );
    ok( ret, "GlobalUnlock failed, error %lu\n", GetLastError() );
    tmp_mem = GlobalHandle( mem );
    ok( tmp_mem == mem, "GlobalHandle returned unexpected handle\n" );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    mem = GlobalAlloc( GMEM_FIXED, 0 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size == 1, "GlobalSize returned %Iu\n", size );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    /* trying to lock empty memory should give an error */
    mem = GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, 0 );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = GlobalLock( mem );
    ok( !ptr, "GlobalLock succeeded\n" );
    ok( GetLastError() == ERROR_DISCARDED, "got error %lu\n", GetLastError() );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    mem = GlobalAlloc( 0, buffer_size );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size >= buffer_size, "GlobalSize returned %Iu, error %lu\n", size, GetLastError() );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    mem = GlobalAlloc( GMEM_ZEROINIT, buffer_size );
    ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
    size = GlobalSize( mem );
    ok( size >= buffer_size, "GlobalSize returned %Iu, error %lu\n", size, GetLastError() );
    ptr = GlobalLock( mem );
    ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
    ok( ptr == mem, "got ptr %p, expected %p\n", ptr, mem );
    ok( !memcmp( ptr, zero_buffer, buffer_size ), "GlobalAlloc didn't clear memory\n" );
 
    /* Check that we can change GMEM_FIXED to GMEM_MOVEABLE */
    mem = GlobalReAlloc( mem, 0, GMEM_MODIFY | GMEM_MOVEABLE );
    ok( !!mem, "GlobalReAlloc failed, error %lu\n", GetLastError() );
    ok( mem != ptr, "GlobalReAlloc returned unexpected handle\n" );
    size = GlobalSize( mem );
    ok( size == buffer_size, "GlobalSize returned %Iu, error %lu\n", size, GetLastError() );
 
    ptr = GlobalLock( mem );
    ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
    ok( ptr != mem, "got unexpected ptr %p\n", ptr );
    ret = GlobalUnlock( mem );
    ok( !ret, "GlobalUnlock succeeded, error %lu\n", GetLastError() );
    ok( GetLastError() == NO_ERROR, "got error %lu\n", GetLastError() );
 
    tmp_mem = GlobalReAlloc( mem, 2 * buffer_size, GMEM_MOVEABLE | GMEM_ZEROINIT );
    ok( !!tmp_mem, "GlobalReAlloc failed\n" );
    ok( tmp_mem == mem || broken( tmp_mem != mem ) /* happens sometimes?? */,
        "GlobalReAlloc returned unexpected handle\n" );
    mem = tmp_mem;
 
    size = GlobalSize( mem );
    ok( size >= 2 * buffer_size, "GlobalSize returned %Iu, error %lu\n", size, GetLastError() );
    ptr = GlobalLock( mem );
    ok( !!ptr, "GlobalLock failed, error %lu\n", GetLastError() );
    ok( ptr != mem, "got unexpected ptr %p\n", ptr );
    ok( !memcmp( ptr, zero_buffer, buffer_size ), "GlobalReAlloc didn't clear memory\n" );
    ok( !memcmp( ptr + buffer_size, zero_buffer, buffer_size ),
        "GlobalReAlloc didn't clear memory\n" );
 
    tmp_mem = GlobalHandle( ptr );
    ok( tmp_mem == mem, "GlobalHandle returned unexpected handle\n" );
    /* Check that we can't discard locked memory */
    SetLastError( 0xdeadbeef );
    tmp_mem = GlobalDiscard( mem );
    ok( !tmp_mem, "GlobalDiscard succeeded\n" );
    ret = GlobalUnlock( mem );
    ok( !ret, "GlobalUnlock succeeded, error %lu\n", GetLastError() );
    ok( GetLastError() == NO_ERROR, "got error %lu\n", GetLastError() );
 
    tmp_mem = GlobalDiscard( mem );
    ok( tmp_mem == mem, "GlobalDiscard failed, error %lu\n", GetLastError() );
    mem = GlobalFree( mem );
    ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
 
    for (i = 0; i < ARRAY_SIZE(flags_tests); i++)
    {
        mem = GlobalAlloc( flags_tests[i], 4 );
        ok( !!mem, "GlobalAlloc failed, error %lu\n", GetLastError() );
        flags = GlobalFlags( mem );
        ok( !(flags & ~(GMEM_DDESHARE | GMEM_DISCARDABLE)), "got flags %#x, error %lu\n", flags, GetLastError() );
        mem = GlobalFree( mem );
        ok( !mem, "GlobalFree failed, error %lu\n", GetLastError() );
    }
 
    ptr = HeapAlloc( GetProcessHeap(), 0, 16 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = GlobalHandle( ptr );
    ok( !!tmp_mem, "GlobalHandle failed, error %lu\n", GetLastError() );
    ok( tmp_mem == ptr, "GlobalHandle returned unexpected handle\n" );
    tmp_ptr = (void *)0xdeadbeef;
    tmp_flags = 0xdeadbeef;
    ret = pRtlGetUserInfoHeap( GetProcessHeap(), 0, ptr, (void **)&tmp_ptr, &tmp_flags );
    ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
    ok( tmp_ptr == (void *)0xdeadbeef, "got user value %p\n", tmp_ptr );
    ok( tmp_flags == 0, "got user flags %#lx\n", tmp_flags );
    ret = HeapFree( GetProcessHeap(), 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
}

Referenced by START_TEST().

test_GlobalMemoryStatus()

static void test_GlobalMemoryStatus ( void  )

static

Definition at line 3874 of file heap.c.

{
    char buffer[sizeof(SYSTEM_PERFORMANCE_INFORMATION) + 16]; /* some Win 7 versions need a larger info */
    SYSTEM_PERFORMANCE_INFORMATION *perf_info = (void *)buffer;
    SYSTEM_BASIC_INFORMATION basic_info;
    MEMORYSTATUSEX memex = {0}, expect;
    MEMORYSTATUS mem = {0};
    VM_COUNTERS_EX vmc;
    NTSTATUS status;
    BOOL ret;
 
    SetLastError( 0xdeadbeef );
    ret = GlobalMemoryStatusEx( &memex );
    ok( !ret, "GlobalMemoryStatusEx succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    GlobalMemoryStatus( &mem );
    ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
 
    status = NtQuerySystemInformation( SystemBasicInformation, &basic_info, sizeof(basic_info), NULL );
    ok( !status, "NtQuerySystemInformation returned %#lx\n", status );
    status = NtQuerySystemInformation( SystemPerformanceInformation, perf_info, sizeof(buffer), NULL );
    ok( !status, "NtQuerySystemInformation returned %#lx\n", status );
    status = NtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters, &vmc, sizeof(vmc), NULL );
    ok( !status, "NtQueryInformationProcess returned %#lx\n", status );
    mem.dwLength = sizeof(MEMORYSTATUS);
    GlobalMemoryStatus( &mem );
    memex.dwLength = sizeof(MEMORYSTATUSEX);
    ret = GlobalMemoryStatusEx( &memex );
    ok( ret, "GlobalMemoryStatusEx succeeded\n" );
 
    ok( basic_info.PageSize, "got 0 PageSize\n" );
    ok( basic_info.MmNumberOfPhysicalPages, "got 0 MmNumberOfPhysicalPages\n" );
    ok( !!basic_info.HighestUserAddress, "got 0 HighestUserAddress\n" );
    ok( !!basic_info.LowestUserAddress, "got 0 LowestUserAddress\n" );
    ok( perf_info->TotalCommittedPages, "got 0 TotalCommittedPages\n" );
    ok( perf_info->TotalCommitLimit, "got 0 TotalCommitLimit\n" );
    ok( perf_info->AvailablePages, "got 0 AvailablePages\n" );
 
    expect.dwMemoryLoad = (memex.ullTotalPhys - memex.ullAvailPhys) / (memex.ullTotalPhys / 100);
    expect.ullTotalPhys = (ULONGLONG)basic_info.MmNumberOfPhysicalPages * basic_info.PageSize;
    expect.ullAvailPhys = (ULONGLONG)perf_info->AvailablePages * basic_info.PageSize;
    expect.ullTotalPageFile = (ULONGLONG)perf_info->TotalCommitLimit * basic_info.PageSize;
    expect.ullAvailPageFile = (ULONGLONG)(perf_info->TotalCommitLimit - perf_info->TotalCommittedPages) * basic_info.PageSize;
    expect.ullTotalVirtual = (ULONG_PTR)basic_info.HighestUserAddress - (ULONG_PTR)basic_info.LowestUserAddress + 1;
    expect.ullAvailVirtual = expect.ullTotalVirtual - (ULONGLONG)vmc.WorkingSetSize /* approximate */;
    expect.ullAvailExtendedVirtual = 0;
 
/* allow some variability, info sources are not always in sync */
#define IS_WITHIN_RANGE(a, b) (((a) - (b) + (256 * basic_info.PageSize)) <= (512 * basic_info.PageSize))
 
    ok( memex.dwMemoryLoad == expect.dwMemoryLoad, "got dwMemoryLoad %lu\n", memex.dwMemoryLoad );
    ok( memex.ullTotalPhys == expect.ullTotalPhys, "got ullTotalPhys %#I64x\n", memex.ullTotalPhys );
    ok( IS_WITHIN_RANGE( memex.ullAvailPhys, expect.ullAvailPhys ), "got ullAvailPhys %#I64x\n", memex.ullAvailPhys );
    ok( memex.ullTotalPageFile == expect.ullTotalPageFile, "got ullTotalPageFile %#I64x\n", memex.ullTotalPageFile );
    ok( IS_WITHIN_RANGE( memex.ullAvailPageFile, expect.ullAvailPageFile ), "got ullAvailPageFile %#I64x\n", memex.ullAvailPageFile );
    ok( memex.ullTotalVirtual == expect.ullTotalVirtual, "got ullTotalVirtual %#I64x\n", memex.ullTotalVirtual );
    ok( memex.ullAvailVirtual <= expect.ullAvailVirtual, "got ullAvailVirtual %#I64x\n", memex.ullAvailVirtual );
    ok( memex.ullAvailExtendedVirtual == 0, "got ullAvailExtendedVirtual %#I64x\n", memex.ullAvailExtendedVirtual );
 
    ok( mem.dwMemoryLoad == memex.dwMemoryLoad, "got dwMemoryLoad %lu\n", mem.dwMemoryLoad );
    ok( mem.dwTotalPhys == min( ~(SIZE_T)0 >> 1, memex.ullTotalPhys ) ||
        broken( mem.dwTotalPhys == ~(SIZE_T)0 ) /* Win <= 8.1 with RAM size > 4GB */,
        "got dwTotalPhys %#Ix\n", mem.dwTotalPhys );
    ok( IS_WITHIN_RANGE( mem.dwAvailPhys, min( ~(SIZE_T)0 >> 1, memex.ullAvailPhys ) ) ||
        broken( mem.dwAvailPhys == ~(SIZE_T)0 ) /* Win <= 8.1 with RAM size > 4GB */,
        "got dwAvailPhys %#Ix\n", mem.dwAvailPhys );
#ifndef _WIN64
    todo_wine_if(memex.ullTotalPageFile > 0xfff7ffff)
#endif
    ok( mem.dwTotalPageFile == min( ~(SIZE_T)0, memex.ullTotalPageFile ), "got dwTotalPageFile %#Ix\n", mem.dwTotalPageFile );
    ok( IS_WITHIN_RANGE( mem.dwAvailPageFile, min( ~(SIZE_T)0, memex.ullAvailPageFile ) ), "got dwAvailPageFile %#Ix\n", mem.dwAvailPageFile );
    ok( mem.dwTotalVirtual == memex.ullTotalVirtual, "got dwTotalVirtual %#Ix\n", mem.dwTotalVirtual );
    ok( mem.dwAvailVirtual == memex.ullAvailVirtual, "got dwAvailVirtual %#Ix\n", mem.dwAvailVirtual );
 
#undef IS_WITHIN_RANGE
}

Referenced by START_TEST().

test_heap_checks()

static void test_heap_checks ( DWORD  flags )

static

Definition at line 3472 of file heap.c.

{
    BYTE old, *p, *p2;
    BOOL ret;
    SIZE_T i, size, large_size = 3000 * 1024 + 37;
 
    if (flags & HEAP_PAGE_ALLOCS) return;  /* no tests for that case yet */
 
    p = pHeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 17 );
    ok( p != NULL, "HeapAlloc failed\n" );
 
    ret = HeapValidate( GetProcessHeap(), 0, p );
    ok( ret, "HeapValidate failed\n" );
 
    size = HeapSize( GetProcessHeap(), 0, p );
    ok( size == 17, "Wrong size %Iu\n", size );
 
    ok( p[14] == 0, "wrong data %x\n", p[14] );
    ok( p[15] == 0, "wrong data %x\n", p[15] );
    ok( p[16] == 0, "wrong data %x\n", p[16] );
 
    if (flags & HEAP_TAIL_CHECKING_ENABLED)
    {
        ok( p[17] == 0xab, "wrong padding %x\n", p[17] );
        ok( p[18] == 0xab, "wrong padding %x\n", p[18] );
        ok( p[19] == 0xab, "wrong padding %x\n", p[19] );
    }
 
    p2 = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, p, 14 );
    if (p2 == p)
    {
        if (flags & HEAP_TAIL_CHECKING_ENABLED)
        {
            ok( p[14] == 0xab, "wrong padding %x\n", p[14] );
            ok( p[15] == 0xab, "wrong padding %x\n", p[15] );
            ok( p[16] == 0xab, "wrong padding %x\n", p[16] );
        }
        else
        {
            ok( p[14] == 0, "wrong padding %x\n", p[14] );
            ok( p[15] == 0, "wrong padding %x\n", p[15] );
        }
    }
    else skip( "realloc in place failed\n");
 
    ret = HeapFree( GetProcessHeap(), 0, p );
    ok( ret, "HeapFree failed\n" );
 
    p = pHeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 17 );
    ok( p != NULL, "HeapAlloc failed\n" );
    old = p[17];
    p[17] = 0xcc;
 
    if (flags & HEAP_TAIL_CHECKING_ENABLED)
    {
        ret = HeapValidate( GetProcessHeap(), 0, p );
        ok( !ret, "HeapValidate succeeded\n" );
 
        /* other calls only check when HEAP_VALIDATE is set */
        if (flags & HEAP_VALIDATE)
        {
            size = HeapSize( GetProcessHeap(), 0, p );
            ok( size == ~(SIZE_T)0 || broken(size == ~0u), "Wrong size %Iu\n", size );
 
            p2 = HeapReAlloc( GetProcessHeap(), 0, p, 14 );
            ok( p2 == NULL, "HeapReAlloc succeeded\n" );
 
            ret = HeapFree( GetProcessHeap(), 0, p );
            ok( !ret || broken(sizeof(void*) == 8), /* not caught on xp64 */
                "HeapFree succeeded\n" );
        }
 
        p[17] = old;
        size = HeapSize( GetProcessHeap(), 0, p );
        ok( size == 17, "Wrong size %Iu\n", size );
 
        p2 = HeapReAlloc( GetProcessHeap(), 0, p, 14 );
        ok( p2 != NULL, "HeapReAlloc failed\n" );
        p = p2;
    }
 
    ret = HeapFree( GetProcessHeap(), 0, p );
    ok( ret, "HeapFree failed\n" );
 
    if (flags & HEAP_FREE_CHECKING_ENABLED)
    {
        UINT *p32, tmp = 0;
 
        size = 4 + 3;
        p = pHeapAlloc( GetProcessHeap(), 0, size );
        ok( !!p, "HeapAlloc failed\n" );
        p32 = (UINT *)p;
 
        ok( p32[0] == 0xbaadf00d, "got %#x\n", p32[0] );
        memcpy( &tmp, p + size - 3, 3 );
        ok( tmp != 0xadf00d, "got %#x\n", tmp );
        memset( p, 0xcc, size );
 
        size += 2 * 4;
        p = pHeapReAlloc( GetProcessHeap(), 0, p, size );
        ok( !!p, "HeapReAlloc failed\n" );
        p32 = (UINT *)p;
 
        ok( p32[0] == 0xcccccccc, "got %#x\n", p32[0] );
        ok( p32[1] << 8 == 0xcccccc00, "got %#x\n", p32[1] );
        ok( p32[2] == 0xbaadf00d, "got %#x\n", p32[2] );
        memcpy( &tmp, p + size - 3, 3 );
        ok( tmp != 0xadf00d, "got %#x\n", tmp );
 
        ret = pHeapFree( GetProcessHeap(), 0, p );
        ok( ret, "failed.\n" );
    }
 
    p = HeapAlloc( GetProcessHeap(), 0, 37 );
    ok( p != NULL, "HeapAlloc failed\n" );
    memset( p, 0xcc, 37 );
 
    ret = pHeapFree( GetProcessHeap(), 0, p );
    ok( ret, "HeapFree failed\n" );
 
    if (flags & HEAP_FREE_CHECKING_ENABLED)
    {
        ok( p[16] == 0xee, "wrong data %x\n", p[16] );
        ok( p[17] == 0xfe, "wrong data %x\n", p[17] );
        ok( p[18] == 0xee, "wrong data %x\n", p[18] );
        ok( p[19] == 0xfe, "wrong data %x\n", p[19] );
 
        ret = HeapValidate( GetProcessHeap(), 0, NULL );
        ok( ret, "HeapValidate failed\n" );
 
        old = p[16];
        p[16] = 0xcc;
        ret = HeapValidate( GetProcessHeap(), 0, NULL );
        ok( !ret, "HeapValidate succeeded\n" );
 
        p[16] = old;
        ret = HeapValidate( GetProcessHeap(), 0, NULL );
        ok( ret, "HeapValidate failed\n" );
    }
 
    /* now test large blocks */
 
    p = pHeapAlloc( GetProcessHeap(), 0, large_size );
    ok( p != NULL, "HeapAlloc failed\n" );
 
    ret = HeapValidate( GetProcessHeap(), 0, p );
    ok( ret, "HeapValidate failed\n" );
 
    size = HeapSize( GetProcessHeap(), 0, p );
    ok( size == large_size, "Wrong size %Iu\n", size );
 
    ok( p[large_size - 2] == 0, "wrong data %x\n", p[large_size - 2] );
    ok( p[large_size - 1] == 0, "wrong data %x\n", p[large_size - 1] );
 
    if (flags & HEAP_TAIL_CHECKING_ENABLED)
    {
        /* Windows doesn't do tail checking on large blocks */
        ok( p[large_size] == 0, "wrong data %x\n", p[large_size] );
        ok( p[large_size + 1] == 0, "wrong data %x\n", p[large_size + 1] );
        ok( p[large_size + 2] == 0, "wrong data %x\n", p[large_size + 2] );
    }
 
    ret = HeapFree( GetProcessHeap(), 0, p );
    ok( ret, "HeapFree failed\n" );
 
    /* test block sizes when tail checking */
    if (flags & HEAP_TAIL_CHECKING_ENABLED)
    {
        for (size = 0; size < 64; size++)
        {
            p = HeapAlloc( GetProcessHeap(), 0, size );
            for (i = 0; i < 32; i++) if (p[size + i] != 0xab) break;
            ok( i >= 8, "only %Iu tail bytes for size %Iu\n", i, size );
            HeapFree( GetProcessHeap(), 0, p );
        }
    }
}

Referenced by test_child_heap().

test_heap_layout()

static void test_heap_layout ( HANDLE  handle, DWORD  global_flag, DWORD  heap_flags  )

static

Definition at line 3718 of file heap.c.

{
    DWORD force_flags = heap_flags & ~(HEAP_SHARED|HEAP_DISABLE_COALESCE_ON_FREE);
    struct heap *heap = handle;
 
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA) {
        skip("test_heap_layout() is invalid on WS03.\n");
        return;
    }
#endif
    if (global_flag & FLG_HEAP_ENABLE_TAGGING) heap_flags |= HEAP_SHARED;
    if (!(global_flag & FLG_HEAP_PAGE_ALLOCS)) force_flags &= ~(HEAP_GROWABLE|HEAP_PRIVATE);
 
    ok( heap->force_flags == force_flags, "got force_flags %#x\n", heap->force_flags );
    ok( heap->flags == heap_flags, "got flags %#x\n", heap->flags );
 
    if (heap->flags & HEAP_PAGE_ALLOCS)
    {
        struct heap expect_heap;
        memset( &expect_heap, 0xee, sizeof(expect_heap) );
        expect_heap.force_flags = heap->force_flags;
        expect_heap.flags = heap->flags;
        todo_wine
        ok( !memcmp( heap, &expect_heap, sizeof(expect_heap) ), "got unexpected data\n" );
    }
    else
    {
        ok( heap->ffeeffee == 0xffeeffee, "got ffeeffee %#x\n", heap->ffeeffee );
        ok( heap->auto_flags == (heap_flags & HEAP_GROWABLE) || !heap->auto_flags,
            "got auto_flags %#x\n", heap->auto_flags );
    }
}

Referenced by test_child_heap().

test_heap_size()

static void test_heap_size ( SIZE_T  initial_size )

static

Definition at line 3977 of file heap.c.

{
    static const SIZE_T default_heap_size = 0x10000, init_grow_size = 0x100000, max_grow_size = 0xfd0000;
 
    BOOL initial_subheap = TRUE, max_size_reached = FALSE;
    SIZE_T alloc_size, current_subheap_size;
    char *base, *current_base;
    unsigned int i;
    HANDLE heap;
    void *p;
 
    winetest_push_context( "init size %#Ix", initial_size );
    heap = HeapCreate( HEAP_NO_SERIALIZE, initial_size, 0 );
    get_valloc_info( heap, &current_base, &alloc_size );
 
    ok( alloc_size == initial_size + default_heap_size || broken( (initial_size && alloc_size == initial_size)
        || (!initial_size && (alloc_size == default_heap_size * sizeof(void*))) ) /* Win7 */,
        "got %#Ix.\n", alloc_size );
 
    current_subheap_size = alloc_size;
    for (i = 0; i < 100; ++i)
    {
        winetest_push_context( "i %u, current_subheap_size %#Ix", i, current_subheap_size );
        p = HeapAlloc( heap, 0, 0x60000 );
        get_valloc_info( p, &base, &alloc_size );
        if (base != current_base)
        {
            current_base = base;
            if (initial_subheap)
            {
                current_subheap_size = init_grow_size;
                initial_subheap = FALSE;
            }
            else
            {
                current_subheap_size = min( current_subheap_size * 2, max_grow_size );
                if (current_subheap_size == max_grow_size)
                    max_size_reached = TRUE;
            }
        }
        ok( alloc_size == current_subheap_size, "got %#Ix.\n", alloc_size );
        winetest_pop_context();
    }
    ok( max_size_reached, "Did not reach maximum subheap size.\n" );
 
    HeapDestroy( heap );
    winetest_pop_context();
}

Referenced by test_heap_sizes().

test_heap_sizes()

static void test_heap_sizes ( void  )

static

Definition at line 4026 of file heap.c.

{
    unsigned int i;
    SIZE_T size, round_size = 0x400 * sizeof(void*);
    char *base;
 
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA) {
        skip("test_heap_sizes() is invalid for WS03.\n");
        return;
    }
#endif
    test_heap_size( 0 );
    test_heap_size( 0x80000 );
    test_heap_size( 0x150000 );
 
    for (i = 1; i < 0x100; i++)
    {
        HANDLE heap = HeapCreate( 0, i * 0x100, i * 0x100 );
        ok( heap != NULL, "%x: creation failed\n", i * 0x100 );
        get_valloc_info( heap, &base, &size );
        ok( size == ((i * 0x100 + round_size - 1) & ~(round_size - 1)),
            "%x: wrong size %Ix\n", i * 0x100, size );
        HeapDestroy( heap );
    }
}

Referenced by START_TEST().

test_HeapCreate()

static void test_HeapCreate ( void  )

static

Definition at line 178 of file heap.c.

{
    static const BYTE buffer[512] = {0};
    SIZE_T alloc_size = 0x8000 * sizeof(void *), size, i;
    struct rtl_heap_entry rtl_entry, rtl_entries[256];
    struct heap_thread_params thread_params = {0};
    PROCESS_HEAP_ENTRY entry, entries[256];
    HANDLE heap, heap1, heaps[8], thread;
    BYTE *ptr, *ptr1, *ptrs[128];
    DWORD heap_count, count;
    ULONG compat_info;
    UINT_PTR align;
    DWORD res;
    BOOL ret;
 
    thread_params.ready_event = CreateEventW( NULL, FALSE, FALSE, NULL );
    ok( !!thread_params.ready_event, "CreateEventW failed, error %lu\n", GetLastError() );
    thread_params.start_event = CreateEventW( NULL, FALSE, FALSE, NULL );
    ok( !!thread_params.start_event, "CreateEventW failed, error %lu\n", GetLastError() );
    thread = CreateThread( NULL, 0, heap_thread_proc, &thread_params, 0, NULL );
    ok( !!thread, "CreateThread failed, error %lu\n", GetLastError() );
    res = WaitForSingleObject( thread_params.ready_event, INFINITE );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
 
    heap_count = GetProcessHeaps( 0, NULL );
    ok( heap_count <= 6, "GetProcessHeaps returned %lu\n", heap_count );
 
    /* check heap alignment */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
    count = GetProcessHeaps( 0, NULL );
    ok( count == heap_count + 1, "GetProcessHeaps returned %lu\n", count );
    heap1 = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap1 & 0xffff), "wrong heap alignment\n" );
    count = GetProcessHeaps( 0, NULL );
    ok( count == heap_count + 2, "GetProcessHeaps returned %lu\n", count );
    count = GetProcessHeaps( ARRAY_SIZE(heaps), heaps );
    ok( count == heap_count + 2, "GetProcessHeaps returned %lu\n", count );
    ok( heaps[0] == GetProcessHeap(), "got wrong heap\n" );
    ok( heaps[heap_count + 0] == heap, "got wrong heap\n" );
    todo_wine
    ok( heaps[heap_count + 1] == heap1, "got wrong heap\n" );
    ret = HeapDestroy( heap1 );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
    count = GetProcessHeaps( 0, NULL );
    ok( count == heap_count, "GetProcessHeaps returned %lu\n", count );
 
    /* growable heap */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    /* test some border cases */
 
    ret = HeapFree( NULL, 0, NULL );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, NULL );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    if (0) /* crashes */
    {
        SetLastError( 0xdeadbeef );
        ret = HeapFree( heap, 0, (void *)0xdeadbe00 );
        ok( !ret, "HeapFree succeeded\n" );
        ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
        SetLastError( 0xdeadbeef );
        ptr = (BYTE *)((UINT_PTR)buffer & ~63) + 64;
        ret = HeapFree( heap, 0, ptr );
        ok( !ret, "HeapFree succeeded\n" );
        ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
    }
 
    SetLastError( 0xdeadbeef );
    ptr = HeapReAlloc( heap, 0, NULL, 1 );
    ok( !ptr, "HeapReAlloc succeeded\n" );
    todo_wine
    ok( GetLastError() == NO_ERROR, "got error %lu\n", GetLastError() );
    if (0) /* crashes */
    {
        SetLastError( 0xdeadbeef );
        ptr1 = HeapReAlloc( heap, 0, (void *)0xdeadbe00, 1 );
        ok( !ptr1, "HeapReAlloc succeeded\n" );
        ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
        ret = HeapValidate( heap, 0, (void *)0xdeadbe00 );
        ok( !ret, "HeapValidate succeeded\n" );
        ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
        SetLastError( 0xdeadbeef );
        ptr = (BYTE *)((UINT_PTR)buffer & ~63) + 64;
        ptr1 = HeapReAlloc( heap, 0, ptr, 1 );
        ok( !ptr1, "HeapReAlloc succeeded\n" );
        ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
    }
 
    SetLastError( 0xdeadbeef );
    ret = HeapValidate( heap, 0, NULL );
    ok( ret, "HeapValidate failed, error %lu\n", GetLastError() );
    ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
    ptr = (BYTE *)((UINT_PTR)buffer & ~63) + 64;
    ret = HeapValidate( heap, 0, ptr );
    ok( !ret, "HeapValidate succeeded\n" );
    ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, 0, 0 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == 0, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    ptr1 = pHeapReAlloc( heap, 0, ptr, ~(SIZE_T)0 - 7 );
    ok( !ptr1, "HeapReAlloc succeeded\n" );
    ptr1 = pHeapReAlloc( heap, 0, ptr, ~(SIZE_T)0 );
    ok( !ptr1, "HeapReAlloc succeeded\n" );
    ret = HeapValidate( heap, 0, ptr );
    ok( ret, "HeapValidate failed, error %lu\n", GetLastError() );
    ret = pHeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = HeapValidate( heap, 0, ptr );
    ok( !ret, "HeapValidate succeeded\n" );
    ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
 
    ptr = pHeapAlloc( heap, 0, ~(SIZE_T)0 );
    ok( !ptr, "HeapAlloc succeeded\n" );
 
    ptr = HeapAlloc( heap, 0, 1 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    ptr1 = HeapReAlloc( heap, 0, ptr, 0 );
    ok( !!ptr1, "HeapReAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr1 );
    ok( size == 0, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, 0, 5 * alloc_size + 1 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, 0, alloc_size );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == alloc_size, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    ptr1 = HeapAlloc( heap, 0, 4 * alloc_size );
    ok( !!ptr1, "HeapAlloc failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    /* test pointer alignment */
 
    align = 0;
    for (i = 0; i < ARRAY_SIZE(ptrs); ++i)
    {
        ptrs[i] = HeapAlloc( heap, 0, alloc_size );
        ok( !!ptrs[i], "HeapAlloc failed, error %lu\n", GetLastError() );
        align |= (UINT_PTR)ptrs[i];
    }
    ok( !(align & (2 * sizeof(void *) - 1)), "got wrong alignment\n" );
    ok( align & (2 * sizeof(void *)), "got wrong alignment\n" );
    for (i = 0; i < ARRAY_SIZE(ptrs); ++i)
    {
        ret = HeapFree( heap, 0, ptrs[i] );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    }
 
    align = 0;
    for (i = 0; i < ARRAY_SIZE(ptrs); ++i)
    {
        ptrs[i] = HeapAlloc( heap, 0, 4 * alloc_size );
        ok( !!ptrs[i], "HeapAlloc failed, error %lu\n", GetLastError() );
        align |= (UINT_PTR)ptrs[i];
    }
    ok( !(align & (8 * sizeof(void *) - 1)), "got wrong alignment\n" );
    ok( align & (8 * sizeof(void *)), "got wrong alignment\n" );
    for (i = 0; i < ARRAY_SIZE(ptrs); ++i)
    {
        ret = HeapFree( heap, 0, ptrs[i] );
        ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    }
 
    /* test HEAP_ZERO_MEMORY */
 
    ptr = HeapAlloc( heap, HEAP_ZERO_MEMORY, 1 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == 1, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, HEAP_ZERO_MEMORY, (1 << 20) );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == (1 << 20), "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, HEAP_ZERO_MEMORY, alloc_size );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == alloc_size, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
 
    ptr = HeapReAlloc( heap, HEAP_ZERO_MEMORY, ptr, 3 * alloc_size );
    ok( !!ptr, "HeapReAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == 3 * alloc_size, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
 
    /* shrinking a small-ish block in place and growing back is okay */
    ptr1 = HeapReAlloc( heap, HEAP_REALLOC_IN_PLACE_ONLY, ptr, alloc_size * 3 / 2 );
    ok( ptr1 == ptr, "HeapReAlloc HEAP_REALLOC_IN_PLACE_ONLY failed, error %lu\n", GetLastError() );
    ptr1 = HeapReAlloc( heap, HEAP_REALLOC_IN_PLACE_ONLY, ptr, 2 * alloc_size );
    ok( ptr1 == ptr, "HeapReAlloc HEAP_REALLOC_IN_PLACE_ONLY failed, error %lu\n", GetLastError() );
 
    ptr = HeapReAlloc( heap, HEAP_ZERO_MEMORY, ptr, 1 );
    ok( !!ptr, "HeapReAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == 1, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
 
    ptr = HeapReAlloc( heap, HEAP_ZERO_MEMORY, ptr, (1 << 20) );
    ok( !!ptr, "HeapReAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == (1 << 20), "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
 
    /* shrinking a very large block decommits pages and fail to grow in place */
    ptr1 = HeapReAlloc( heap, HEAP_REALLOC_IN_PLACE_ONLY, ptr, alloc_size * 3 / 2 );
    ok( ptr1 == ptr, "HeapReAlloc HEAP_REALLOC_IN_PLACE_ONLY failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr1 = HeapReAlloc( heap, HEAP_REALLOC_IN_PLACE_ONLY, ptr, 2 * alloc_size );
    todo_wine
    ok( ptr1 != ptr, "HeapReAlloc HEAP_REALLOC_IN_PLACE_ONLY succeeded\n" );
    todo_wine
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY || broken(GetLastError() == 0xdeadbeef) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
#endif
 
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* fixed size heaps */
 
    heap = HeapCreate( 0, alloc_size, alloc_size );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    /* threshold between failure and success varies, and w7pro64 has a much larger overhead. */
 
#ifdef __REACTOS__
    if (is_reactos()) {
        ok(FALSE, "FIXME: The rest of this test crashes on ReactOS!\n");
        return;
    }
#endif
    ptr = HeapAlloc( heap, 0, alloc_size - (0x400 + 0x100 * sizeof(void *)) );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == alloc_size - (0x400 + 0x100 * sizeof(void *)),
        "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ptr1 = HeapAlloc( heap, 0, alloc_size - (0x200 + 0x80 * sizeof(void *)) );
    ok( !ptr1, "HeapAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    heap = HeapCreate( 0, 8 * alloc_size, 8 * alloc_size );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ptr = HeapAlloc( heap, 0, 0 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == 0, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    /* cannot allocate large blocks from fixed size heap */
 
    SetLastError( 0xdeadbeef );
    ptr1 = HeapAlloc( heap, 0, 4 * alloc_size );
    ok( !ptr1, "HeapAlloc succeeded\n" );
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY || broken(GetLastError() == ERROR_INSUFFICIENT_BUFFER) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
#endif
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, 0, alloc_size );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == alloc_size, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr1 = HeapAlloc( heap, 0, 4 * alloc_size );
    ok( !ptr1, "HeapAlloc succeeded\n" );
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY || broken(GetLastError() == ERROR_INSUFFICIENT_BUFFER) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
#endif
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ptr = HeapAlloc( heap, HEAP_ZERO_MEMORY, alloc_size );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == alloc_size, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
 
    ptr = HeapReAlloc( heap, HEAP_ZERO_MEMORY, ptr, 2 * alloc_size );
    ok( !!ptr, "HeapReAlloc failed, error %lu\n", GetLastError() );
    size = HeapSize( heap, 0, ptr );
    ok( size == 2 * alloc_size, "HeapSize returned %#Ix, error %lu\n", size, GetLastError() );
    while (size) if (ptr[--size]) break;
    ok( !size && !ptr[0], "memory wasn't zeroed\n" );
 
    ptr1 = HeapReAlloc( heap, HEAP_REALLOC_IN_PLACE_ONLY, ptr, alloc_size * 3 / 2 );
    ok( ptr1 == ptr, "HeapReAlloc HEAP_REALLOC_IN_PLACE_ONLY failed, error %lu\n", GetLastError() );
    ptr1 = HeapReAlloc( heap, HEAP_REALLOC_IN_PLACE_ONLY, ptr, 2 * alloc_size );
    ok( ptr1 == ptr, "HeapReAlloc HEAP_REALLOC_IN_PLACE_ONLY failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    count = 0;
    memset( &rtl_entries, 0, sizeof(rtl_entries) );
    memset( &rtl_entry, 0xcd, sizeof(rtl_entry) );
    rtl_entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while (!RtlWalkHeap( heap, &rtl_entry )) rtl_entries[count++] = rtl_entry;
#ifdef __REACTOS__
    ok( count == 3 || broken(count == 4) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 3, "got count %lu\n", count );
#endif
 
    count = 0;
    memset( &entries, 0, sizeof(entries) );
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 3 || broken(count == 4) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 3, "got count %lu\n", count );
#endif
 
    for (i = 0; i < count; ++i)
    {
        winetest_push_context( "%Iu", i );
        ok( rtl_entries[i].lpData == entries[i].lpData, "got lpData %p\n", rtl_entries[i].lpData );
        ok( rtl_entries[i].cbData == entries[i].cbData, "got cbData %#Ix\n", rtl_entries[i].cbData );
        ok( rtl_entries[i].cbOverhead == entries[i].cbOverhead, "got cbOverhead %#x\n", rtl_entries[i].cbOverhead );
        ok( rtl_entries[i].iRegionIndex == entries[i].iRegionIndex, "got iRegionIndex %#x\n", rtl_entries[i].iRegionIndex );
        if (!entries[i].wFlags)
            ok( rtl_entries[i].wFlags == 0, "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_ENTRY_BUSY)
#ifdef __REACTOS__
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_COMMITTED|RTL_HEAP_ENTRY_BLOCK|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 0x411) /* win7 */ || broken(rtl_entries[i].wFlags == RTL_HEAP_ENTRY_BUSY) /* WS03 */,
#else
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_COMMITTED|RTL_HEAP_ENTRY_BLOCK|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 0x411) /* win7 */,
#endif
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_UNCOMMITTED || broken(rtl_entries[i].wFlags == 0x100) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_REGION)
        {
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_REGION, "got wFlags %#x\n", rtl_entries[i].wFlags );
            ok( rtl_entries[i].Region.dwCommittedSize == entries[i].Region.dwCommittedSize,
                "got Region.dwCommittedSize %#lx\n", rtl_entries[i].Region.dwCommittedSize );
            ok( rtl_entries[i].Region.dwUnCommittedSize == entries[i].Region.dwUnCommittedSize,
                "got Region.dwUnCommittedSize %#lx\n", rtl_entries[i].Region.dwUnCommittedSize );
            ok( rtl_entries[i].Region.lpFirstBlock == entries[i].Region.lpFirstBlock,
                "got Region.lpFirstBlock %p\n", rtl_entries[i].Region.lpFirstBlock );
            ok( rtl_entries[i].Region.lpLastBlock == entries[i].Region.lpLastBlock,
                "got Region.lpLastBlock %p\n", rtl_entries[i].Region.lpLastBlock );
        }
        winetest_pop_context();
    }
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[0].wFlags == PROCESS_HEAP_REGION, "got wFlags %#x\n", entries[0].wFlags );
    ok( entries[0].lpData == heap, "got lpData %p\n", entries[0].lpData );
    ok( entries[0].cbData <= 0x1000 /* sizeof(*heap) */, "got cbData %#lx\n", entries[0].cbData );
    ok( entries[0].cbOverhead == 0, "got cbOverhead %#x\n", entries[0].cbOverhead );
    ok( entries[0].iRegionIndex == 0, "got iRegionIndex %d\n", entries[0].iRegionIndex );
    todo_wine
    ok( entries[0].Region.dwCommittedSize == 0x400 * sizeof(void *),
        "got Region.dwCommittedSize %#lx\n", entries[0].Region.dwCommittedSize );
    ok( entries[0].Region.dwUnCommittedSize == 0x10000 - entries[0].Region.dwCommittedSize ||
        entries[0].Region.dwUnCommittedSize == 0x10000 * sizeof(void *) - entries[0].Region.dwCommittedSize /* win7 */,
        "got Region.dwUnCommittedSize %#lx\n", entries[0].Region.dwUnCommittedSize );
    todo_wine
    ok( (BYTE *)entries[0].Region.lpFirstBlock == (BYTE *)entries[0].lpData + entries[0].cbData + 2 * sizeof(void *) ||
        (BYTE *)entries[0].Region.lpFirstBlock == (BYTE *)entries[0].lpData + entries[0].cbData + 4 * sizeof(void *),
        "got Region.lpFirstBlock %p\n", entries[0].Region.lpFirstBlock );
    ok( entries[0].Region.lpLastBlock == (BYTE *)entries[2].lpData + entries[2].cbData,
        "got Region.lpLastBlock %p\n", entries[0].Region.lpLastBlock );
 
    ok( entries[1].wFlags == 0, "got wFlags %#x\n", entries[1].wFlags );
    ok( entries[1].lpData != NULL, "got lpData %p\n", entries[1].lpData );
    ok( entries[1].cbData != 0, "got cbData %#lx\n", entries[1].cbData );
    ok( entries[1].cbOverhead == 4 * sizeof(void *), "got cbOverhead %#x\n", entries[1].cbOverhead );
    ok( entries[1].iRegionIndex == 0, "got iRegionIndex %d\n", entries[1].iRegionIndex );
 
    ok( entries[2].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[2].wFlags );
    ok( entries[2].lpData == (BYTE *)entries[0].lpData + entries[0].Region.dwCommittedSize,
        "got lpData %p\n", entries[2].lpData );
    ok( entries[2].lpData == (BYTE *)entries[1].lpData + entries[1].cbData + 2 * entries[1].cbOverhead,
        "got lpData %p\n", entries[2].lpData );
    ok( entries[2].cbData == entries[0].Region.dwUnCommittedSize - 0x1000 ||
        entries[2].cbData == entries[0].Region.dwUnCommittedSize /* win7 */,
        "got cbData %#lx\n", entries[2].cbData );
    ok( entries[2].cbOverhead == 0, "got cbOverhead %#x\n", entries[2].cbOverhead );
    ok( entries[2].iRegionIndex == 0, "got iRegionIndex %d\n", entries[2].iRegionIndex );
#ifdef __REACTOS__
    }
#endif
 
    ptr = HeapAlloc( heap, HEAP_ZERO_MEMORY, 5 * alloc_size );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
 
    count = 0;
    memset( &rtl_entries, 0, sizeof(rtl_entries) );
    memset( &rtl_entry, 0xcd, sizeof(rtl_entry) );
    rtl_entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while (!RtlWalkHeap( heap, &rtl_entry )) rtl_entries[count++] = rtl_entry;
#ifdef __REACTOS__
    ok( count == 4 || broken(count == 5) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 4, "got count %lu\n", count );
#endif
 
    memmove( entries + 16, entries, 3 * sizeof(entry) );
    count = 0;
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 4 || broken(count == 5) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 4, "got count %lu\n", count );
#endif
    ok( !memcmp( entries + 16, entries, 3 * sizeof(entry) ), "entries differ\n" );
 
    for (i = 0; i < count; ++i)
    {
        winetest_push_context( "%Iu", i );
        ok( rtl_entries[i].lpData == entries[i].lpData, "got lpData %p\n", rtl_entries[i].lpData );
        ok( rtl_entries[i].cbData == entries[i].cbData, "got cbData %#Ix\n", rtl_entries[i].cbData );
        ok( rtl_entries[i].cbOverhead == entries[i].cbOverhead, "got cbOverhead %#x\n", rtl_entries[i].cbOverhead );
        ok( rtl_entries[i].iRegionIndex == entries[i].iRegionIndex, "got iRegionIndex %#x\n", rtl_entries[i].iRegionIndex );
        if (!entries[i].wFlags)
            ok( rtl_entries[i].wFlags == 0, "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_ENTRY_BUSY)
#ifdef __REACTOS__
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_COMMITTED|RTL_HEAP_ENTRY_BLOCK|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 0x411) /* win7 */ || broken(rtl_entries[i].wFlags == RTL_HEAP_ENTRY_BUSY) /* WS03 */ || broken(rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_BLOCK|0x9)) /* WS03 */,
#else
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_COMMITTED|RTL_HEAP_ENTRY_BLOCK|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 0x411) /* win7 */,
#endif
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_UNCOMMITTED || broken(rtl_entries[i].wFlags == 0x100) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_REGION)
        {
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_REGION, "got wFlags %#x\n", rtl_entries[i].wFlags );
            ok( rtl_entries[i].Region.dwCommittedSize == entries[i].Region.dwCommittedSize,
                "got Region.dwCommittedSize %#lx\n", rtl_entries[i].Region.dwCommittedSize );
            ok( rtl_entries[i].Region.dwUnCommittedSize == entries[i].Region.dwUnCommittedSize,
                "got Region.dwUnCommittedSize %#lx\n", rtl_entries[i].Region.dwUnCommittedSize );
            ok( rtl_entries[i].Region.lpFirstBlock == entries[i].Region.lpFirstBlock,
                "got Region.lpFirstBlock %p\n", rtl_entries[i].Region.lpFirstBlock );
            ok( rtl_entries[i].Region.lpLastBlock == entries[i].Region.lpLastBlock,
                "got Region.lpLastBlock %p\n", rtl_entries[i].Region.lpLastBlock );
        }
        winetest_pop_context();
    }
 
    ok( entries[3].wFlags == PROCESS_HEAP_ENTRY_BUSY ||
#ifdef __REACTOS__
        broken(entries[3].wFlags == (PROCESS_HEAP_ENTRY_BUSY | PROCESS_HEAP_ENTRY_DDESHARE)) /* win7 */ || broken(entries[3].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE) /* WS03 */,
#else
        broken(entries[3].wFlags == (PROCESS_HEAP_ENTRY_BUSY | PROCESS_HEAP_ENTRY_DDESHARE)) /* win7 */,
#endif
        "got wFlags %#x\n", entries[3].wFlags );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[3].lpData == ptr, "got lpData %p\n", entries[3].lpData );
    ok( entries[3].cbData == 5 * alloc_size, "got cbData %#lx\n", entries[3].cbData );
#ifdef __REACTOS__
    }
#endif
    ok( entries[3].cbOverhead == 0 || entries[3].cbOverhead == 8 * sizeof(void *) /* win7 */,
        "got cbOverhead %#x\n", entries[3].cbOverhead );
#ifdef __REACTOS__
    ok( entries[3].iRegionIndex == 64 || broken(entries[3].iRegionIndex == 0) /* WS03 */, "got iRegionIndex %d\n", entries[3].iRegionIndex );
#else
    ok( entries[3].iRegionIndex == 64, "got iRegionIndex %d\n", entries[3].iRegionIndex );
#endif
 
    ptr1 = HeapAlloc( heap, HEAP_ZERO_MEMORY, 5 * alloc_size );
    ok( !!ptr1, "HeapAlloc failed, error %lu\n", GetLastError() );
 
    count = 0;
    memset( &rtl_entries, 0, sizeof(rtl_entries) );
    memset( &rtl_entry, 0xcd, sizeof(rtl_entry) );
    rtl_entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while (!RtlWalkHeap( heap, &rtl_entry )) rtl_entries[count++] = rtl_entry;
#ifdef __REACTOS__
    ok( count == 5 || broken(count == 6) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 5, "got count %lu\n", count );
#endif
 
    memmove( entries + 16, entries, 4 * sizeof(entry) );
    count = 0;
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 5 || broken(count == 6) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 5, "got count %lu\n", count );
#endif
    ok( !memcmp( entries + 16, entries, 4 * sizeof(entry) ), "entries differ\n" );
 
    for (i = 0; i < count; ++i)
    {
        winetest_push_context( "%Iu", i );
        ok( rtl_entries[i].lpData == entries[i].lpData, "got lpData %p\n", rtl_entries[i].lpData );
        ok( rtl_entries[i].cbData == entries[i].cbData, "got cbData %#Ix\n", rtl_entries[i].cbData );
        ok( rtl_entries[i].cbOverhead == entries[i].cbOverhead, "got cbOverhead %#x\n", rtl_entries[i].cbOverhead );
        ok( rtl_entries[i].iRegionIndex == entries[i].iRegionIndex, "got iRegionIndex %#x\n", rtl_entries[i].iRegionIndex );
        if (!entries[i].wFlags)
            ok( rtl_entries[i].wFlags == 0, "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_ENTRY_BUSY)
#ifdef __REACTOS__
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_COMMITTED|RTL_HEAP_ENTRY_BLOCK|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 0x411) /* win7 */ || broken(rtl_entries[i].wFlags == RTL_HEAP_ENTRY_BUSY) /* WS03 */ || broken(rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_BLOCK|0x9)) /* WS03 */,
#else
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_COMMITTED|RTL_HEAP_ENTRY_BLOCK|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 0x411) /* win7 */,
#endif
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_UNCOMMITTED || broken(rtl_entries[i].wFlags == 0x100) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_REGION)
        {
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_REGION, "got wFlags %#x\n", rtl_entries[i].wFlags );
            ok( rtl_entries[i].Region.dwCommittedSize == entries[i].Region.dwCommittedSize,
                "got Region.dwCommittedSize %#lx\n", rtl_entries[i].Region.dwCommittedSize );
            ok( rtl_entries[i].Region.dwUnCommittedSize == entries[i].Region.dwUnCommittedSize,
                "got Region.dwUnCommittedSize %#lx\n", rtl_entries[i].Region.dwUnCommittedSize );
            ok( rtl_entries[i].Region.lpFirstBlock == entries[i].Region.lpFirstBlock,
                "got Region.lpFirstBlock %p\n", rtl_entries[i].Region.lpFirstBlock );
            ok( rtl_entries[i].Region.lpLastBlock == entries[i].Region.lpLastBlock,
                "got Region.lpLastBlock %p\n", rtl_entries[i].Region.lpLastBlock );
        }
        winetest_pop_context();
    }
 
    ok( entries[4].wFlags == PROCESS_HEAP_ENTRY_BUSY ||
        broken(entries[4].wFlags == (PROCESS_HEAP_ENTRY_BUSY | PROCESS_HEAP_ENTRY_DDESHARE)) /* win7 */,
        "got wFlags %#x\n", entries[4].wFlags );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok( entries[4].lpData == ptr1, "got lpData %p\n", entries[4].lpData );
    ok( entries[4].cbData == 5 * alloc_size, "got cbData %#lx\n", entries[4].cbData );
    ok( entries[4].cbOverhead == 0 || entries[4].cbOverhead == 8 * sizeof(void *) /* win7 */,
        "got cbOverhead %#x\n", entries[4].cbOverhead );
    ok( entries[4].iRegionIndex == 64, "got iRegionIndex %d\n", entries[4].iRegionIndex );
 
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
    memmove( entries + 16, entries, 3 * sizeof(entry) );
    count = 0;
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 3 || broken(count == 4) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 3, "got count %lu\n", count );
#endif
    ok( !memcmp( entries + 16, entries, 3 * sizeof(entry) ), "entries differ\n" );
 
    ptr = HeapAlloc( heap, HEAP_ZERO_MEMORY, 123 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
 
    memmove( entries + 16, entries, 3 * sizeof(entry) );
    count = 0;
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 4 || broken(count == 5) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 4, "got count %lu\n", count );
#endif
    ok( !memcmp( entries + 16, entries, 1 * sizeof(entry) ), "entries differ\n" );
    ok( memcmp( entries + 17, entries + 2, 2 * sizeof(entry) ), "entries differ\n" );
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[1].wFlags == PROCESS_HEAP_ENTRY_BUSY, "got wFlags %#x\n", entries[1].wFlags );
    ok( entries[1].lpData == ptr, "got lpData %p\n", entries[1].lpData );
    ok( entries[1].cbData == 123, "got cbData %#lx\n", entries[1].cbData );
    ok( entries[1].cbOverhead != 0, "got cbOverhead %#x\n", entries[1].cbOverhead );
    ok( entries[1].iRegionIndex == 0, "got iRegionIndex %d\n", entries[1].iRegionIndex );
 
    ok( entries[2].wFlags == 0, "got wFlags %#x\n", entries[2].wFlags );
    ok( entries[2].lpData == (BYTE *)entries[1].lpData + entries[1].cbData + entries[1].cbOverhead + 2 * sizeof(void *),
        "got lpData %p\n", entries[2].lpData );
    ok( entries[2].cbData != 0, "got cbData %#lx\n", entries[2].cbData );
    ok( entries[2].cbOverhead == 4 * sizeof(void *), "got cbOverhead %#x\n", entries[2].cbOverhead );
    ok( entries[2].iRegionIndex == 0, "got iRegionIndex %d\n", entries[2].iRegionIndex );
 
    ok( entries[3].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[3].wFlags );
    ok( entries[3].lpData == (BYTE *)entries[0].lpData + entries[0].Region.dwCommittedSize,
        "got lpData %p\n", entries[3].lpData );
    ok( entries[3].lpData == (BYTE *)entries[2].lpData + entries[2].cbData + 2 * entries[2].cbOverhead,
        "got lpData %p\n", entries[3].lpData );
    ok( entries[3].cbData == entries[0].Region.dwUnCommittedSize - 0x1000 ||
        entries[3].cbData == entries[0].Region.dwUnCommittedSize /* win7 */,
        "got cbData %#lx\n", entries[3].cbData );
    ok( entries[3].cbOverhead == 0, "got cbOverhead %#x\n", entries[3].cbOverhead );
    ok( entries[3].iRegionIndex == 0, "got iRegionIndex %d\n", entries[3].iRegionIndex );
#ifdef __REACTOS__
    }
#endif
 
    ptr1 = HeapAlloc( heap, HEAP_ZERO_MEMORY, 456 );
    ok( !!ptr1, "HeapAlloc failed, error %lu\n", GetLastError() );
 
    memmove( entries + 16, entries, 4 * sizeof(entry) );
    count = 0;
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 5 || broken(count == 6) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 5, "got count %lu\n", count );
#endif
    ok( !memcmp( entries + 16, entries, 2 * sizeof(entry) ), "entries differ\n" );
    ok( memcmp( entries + 18, entries + 3, 2 * sizeof(entry) ), "entries differ\n" );
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[2].wFlags == PROCESS_HEAP_ENTRY_BUSY, "got wFlags %#x\n", entries[2].wFlags );
    ok( entries[2].lpData == ptr1, "got lpData %p\n", entries[2].lpData );
    ok( entries[2].cbData == 456, "got cbData %#lx\n", entries[2].cbData );
    ok( entries[2].cbOverhead != 0, "got cbOverhead %#x\n", entries[2].cbOverhead );
    ok( entries[2].iRegionIndex == 0, "got iRegionIndex %d\n", entries[2].iRegionIndex );
 
    ok( entries[3].wFlags == 0, "got wFlags %#x\n", entries[3].wFlags );
    ok( entries[3].lpData == (BYTE *)entries[2].lpData + entries[2].cbData + entries[2].cbOverhead + 2 * sizeof(void *),
        "got lpData %p\n", entries[3].lpData );
    ok( entries[3].cbData != 0, "got cbData %#lx\n", entries[3].cbData );
    ok( entries[3].cbOverhead == 4 * sizeof(void *), "got cbOverhead %#x\n", entries[3].cbOverhead );
    ok( entries[3].iRegionIndex == 0, "got iRegionIndex %d\n", entries[3].iRegionIndex );
 
    ok( entries[4].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[4].wFlags );
    ok( entries[4].lpData == (BYTE *)entries[0].lpData + entries[0].Region.dwCommittedSize,
        "got lpData %p\n", entries[4].lpData );
    ok( entries[4].lpData == (BYTE *)entries[3].lpData + entries[3].cbData + 2 * entries[3].cbOverhead,
        "got lpData %p\n", entries[4].lpData );
    ok( entries[4].cbData == entries[0].Region.dwUnCommittedSize - 0x1000 ||
        entries[4].cbData == entries[0].Region.dwUnCommittedSize /* win7 */,
        "got cbData %#lx\n", entries[4].cbData );
    ok( entries[4].cbOverhead == 0, "got cbOverhead %#x\n", entries[4].cbOverhead );
    ok( entries[4].iRegionIndex == 0, "got iRegionIndex %d\n", entries[4].iRegionIndex );
#ifdef __REACTOS__
    }
#endif
 
    ret = HeapFree( heap, 0, ptr1 );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
    ret = HeapFree( heap, 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) { /* NOTE: This crashes on WS03. */
#endif
    size = 0;
    SetLastError( 0xdeadbeef );
    ret = pHeapQueryInformation( 0, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( !ret, "HeapQueryInformation succeeded\n" );
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
    ok( size == 0, "got size %Iu\n", size );
#ifdef __REACTOS__
    }
#endif
 
    size = 0;
    SetLastError( 0xdeadbeef );
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, NULL, 0, &size );
    ok( !ret, "HeapQueryInformation succeeded\n" );
    ok( GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError() );
    ok( size == sizeof(ULONG), "got size %Iu\n", size );
 
    SetLastError( 0xdeadbeef );
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, NULL, 0, NULL );
    ok( !ret, "HeapQueryInformation succeeded\n" );
    ok( GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got error %lu\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    compat_info = 0xdeadbeef;
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info) + 1, NULL );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
    ok( compat_info == 0, "got compat_info %lu\n", compat_info );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* check setting LFH compat info */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( compat_info == 0 || broken(compat_info == 1) /* WS03 */, "got HeapCompatibilityInformation %lu\n", compat_info );
#else
    ok( compat_info == 0, "got HeapCompatibilityInformation %lu\n", compat_info );
#endif
 
    compat_info = 2;
    ret = pHeapSetInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info) );
    ok( ret, "HeapSetInformation failed, error %lu\n", GetLastError() );
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
    ok( compat_info == 2, "got HeapCompatibilityInformation %lu\n", compat_info );
 
    /* cannot be undone */
 
    compat_info = 0;
    SetLastError( 0xdeadbeef );
    ret = pHeapSetInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info) );
    ok( !ret, "HeapSetInformation succeeded\n" );
    ok( GetLastError() == ERROR_GEN_FAILURE, "got error %lu\n", GetLastError() );
    compat_info = 1;
    SetLastError( 0xdeadbeef );
    ret = pHeapSetInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info) );
    ok( !ret, "HeapSetInformation succeeded\n" );
    ok( GetLastError() == ERROR_GEN_FAILURE, "got error %lu\n", GetLastError() );
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
    ok( compat_info == 2, "got HeapCompatibilityInformation %lu\n", compat_info );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* cannot set LFH with HEAP_NO_SERIALIZE */
 
    heap = HeapCreate( HEAP_NO_SERIALIZE, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
    ok( compat_info == 0, "got HeapCompatibilityInformation %lu\n", compat_info );
 
    compat_info = 2;
    SetLastError( 0xdeadbeef );
    ret = pHeapSetInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info) );
    ok( !ret, "HeapSetInformation succeeded\n" );
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_INVALID_PARAMETER || broken(GetLastError() == ERROR_GEN_FAILURE) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_INVALID_PARAMETER, "got error %lu\n", GetLastError() );
#endif
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
    ok( compat_info == 0, "got HeapCompatibilityInformation %lu\n", compat_info );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* some allocation pattern automatically enables LFH */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( compat_info == 0 || broken(compat_info == 1) /* WS03 */, "got HeapCompatibilityInformation %lu\n", compat_info );
#else
    ok( compat_info == 0, "got HeapCompatibilityInformation %lu\n", compat_info );
#endif
 
    for (i = 0; i < 0x12; i++) ptrs[i] = pHeapAlloc( heap, 0, 0 );
    for (i = 0; i < 0x12; i++) HeapFree( heap, 0, ptrs[i] );
 
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( compat_info == 2 || broken(compat_info == 1) /* WS03 */, "got HeapCompatibilityInformation %lu\n", compat_info );
#else
    ok( compat_info == 2, "got HeapCompatibilityInformation %lu\n", compat_info );
#endif
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* LFH actually doesn't enable immediately, the pattern is required */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    compat_info = 2;
    ret = pHeapSetInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info) );
    ok( ret, "HeapSetInformation failed, error %lu\n", GetLastError() );
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
    ok( compat_info == 2, "got HeapCompatibilityInformation %lu\n", compat_info );
 
    for (i = 0; i < 0x11; i++) ptrs[i] = pHeapAlloc( heap, 0, 24 + 2 * sizeof(void *) );
    for (i = 0; i < 0x11; i++) HeapFree( heap, 0, ptrs[i] );
 
    count = 0;
    memset( &entries, 0xcd, sizeof(entries) );
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( count == 3 || broken(count == 7) /* WS03 */, "got count %lu\n", count );
#else
    ok( count == 3, "got count %lu\n", count );
#endif
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[0].wFlags == PROCESS_HEAP_REGION, "got wFlags %#x\n", entries[0].wFlags );
    ok( entries[0].lpData == heap, "got lpData %p\n", entries[0].lpData );
    ok( entries[0].cbData <= 0x1000 /* sizeof(*heap) */, "got cbData %#lx\n", entries[0].cbData );
    ok( entries[0].cbOverhead == 0, "got cbOverhead %#x\n", entries[0].cbOverhead );
    ok( entries[0].iRegionIndex == 0, "got iRegionIndex %d\n", entries[0].iRegionIndex );
    ok( entries[1].wFlags == 0, "got wFlags %#x\n", entries[1].wFlags );
    ok( entries[2].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[2].wFlags );
#ifdef __REACTOS__
    }
#endif
 
    for (i = 0; i < 0x12; i++) ptrs[i] = pHeapAlloc( heap, 0, 24 + 2 * sizeof(void *) );
    for (i = 0; i < 0x12; i++) HeapFree( heap, 0, ptrs[i] );
 
    count = 0;
    memset( &entries, 0xcd, sizeof(entries) );
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
    todo_wine
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok( count > 24, "got count %lu\n", count );
    if (count < 2) count = 2;
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[0].wFlags == PROCESS_HEAP_REGION, "got wFlags %#x\n", entries[0].wFlags );
    ok( entries[0].lpData == heap, "got lpData %p\n", entries[0].lpData );
    ok( entries[0].cbData <= 0x1000 /* sizeof(*heap) */, "got cbData %#lx\n", entries[0].cbData );
    ok( entries[0].cbOverhead == 0, "got cbOverhead %#x\n", entries[0].cbOverhead );
    ok( entries[0].iRegionIndex == 0, "got iRegionIndex %d\n", entries[0].iRegionIndex );
    todo_wine /* Wine currently reports the LFH group as a single block here */
    ok( entries[1].wFlags == 0, "got wFlags %#x\n", entries[1].wFlags );
 
    for (i = 0; i < 0x12; i++)
    {
        todo_wine
        ok( entries[4 + i].wFlags == 0, "got wFlags %#x\n", entries[4 + i].wFlags );
        todo_wine
        ok( entries[4 + i].cbData == 0x20, "got cbData %#lx\n", entries[4 + i].cbData );
        todo_wine
        ok( entries[4 + i].cbOverhead == 2 * sizeof(void *), "got cbOverhead %#x\n", entries[4 + i].cbOverhead );
    }
#ifdef __REACTOS__
    }
#endif
 
    if (entries[count - 1].wFlags == PROCESS_HEAP_REGION) /* > win7 */
        ok( entries[count - 2].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[count - 2].wFlags );
    else
        ok( entries[count - 1].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[count - 2].wFlags );
 
    count = 0;
    memset( &rtl_entries, 0, sizeof(rtl_entries) );
    memset( &rtl_entry, 0xcd, sizeof(rtl_entry) );
    rtl_entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while (!RtlWalkHeap( heap, &rtl_entry )) rtl_entries[count++] = rtl_entry;
    todo_wine
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok( count > 24, "got count %lu\n", count );
    if (count < 2) count = 2;
 
    for (i = 3; i < count; ++i)
    {
        winetest_push_context( "%Iu", i );
        ok( rtl_entries[i].lpData == entries[i].lpData, "got lpData %p\n", rtl_entries[i].lpData );
        ok( rtl_entries[i].cbData == entries[i].cbData, "got cbData %#Ix\n", rtl_entries[i].cbData );
        ok( rtl_entries[i].cbOverhead == entries[i].cbOverhead, "got cbOverhead %#x\n", rtl_entries[i].cbOverhead );
        ok( rtl_entries[i].iRegionIndex == entries[i].iRegionIndex, "got iRegionIndex %#x\n", rtl_entries[i].iRegionIndex );
        if (!entries[i].wFlags)
            ok( rtl_entries[i].wFlags == 0 || rtl_entries[i].wFlags == RTL_HEAP_ENTRY_LFH, "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_ENTRY_BUSY)
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_LFH|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 1) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_UNCOMMITTED || broken(rtl_entries[i].wFlags == 0x100) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_REGION)
        {
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_LFH|RTL_HEAP_ENTRY_REGION), "got wFlags %#x\n", rtl_entries[i].wFlags );
            ok( rtl_entries[i].Region.dwCommittedSize == entries[i].Region.dwCommittedSize,
                "got Region.dwCommittedSize %#lx\n", rtl_entries[i].Region.dwCommittedSize );
            ok( rtl_entries[i].Region.dwUnCommittedSize == entries[i].Region.dwUnCommittedSize,
                "got Region.dwUnCommittedSize %#lx\n", rtl_entries[i].Region.dwUnCommittedSize );
            ok( rtl_entries[i].Region.lpFirstBlock == entries[i].Region.lpFirstBlock,
                "got Region.lpFirstBlock %p\n", rtl_entries[i].Region.lpFirstBlock );
            ok( rtl_entries[i].Region.lpLastBlock == entries[i].Region.lpLastBlock,
                "got Region.lpLastBlock %p\n", rtl_entries[i].Region.lpLastBlock );
        }
        winetest_pop_context();
    }
 
    for (i = 0; i < 0x12; i++) ptrs[i] = pHeapAlloc( heap, 0, 24 + 2 * sizeof(void *) );
 
    count = 0;
    memset( &entries, 0xcd, sizeof(entries) );
    memset( &entry, 0xcd, sizeof(entry) );
    entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while ((ret = HeapWalk( heap, &entry ))) entries[count++] = entry;
    ok( GetLastError() == ERROR_NO_MORE_ITEMS, "got error %lu\n", GetLastError() );
    todo_wine
    ok( count > 24, "got count %lu\n", count );
    if (count < 2) count = 2;
 
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    ok( entries[0].wFlags == PROCESS_HEAP_REGION, "got wFlags %#x\n", entries[0].wFlags );
    ok( entries[0].lpData == heap, "got lpData %p\n", entries[0].lpData );
    ok( entries[0].cbData <= 0x1000 /* sizeof(*heap) */, "got cbData %#lx\n", entries[0].cbData );
    ok( entries[0].cbOverhead == 0, "got cbOverhead %#x\n", entries[0].cbOverhead );
    ok( entries[0].iRegionIndex == 0, "got iRegionIndex %d\n", entries[0].iRegionIndex );
    ok( entries[1].wFlags == 0 || entries[1].wFlags == PROCESS_HEAP_ENTRY_BUSY /* win7 */, "got wFlags %#x\n", entries[1].wFlags );
 
    for (i = 1; i < count - 2; i++)
    {
        if (entries[i].wFlags != PROCESS_HEAP_ENTRY_BUSY) continue;
        todo_wine /* Wine currently reports the LFH group as a single block */
        ok( entries[i].cbData == 0x18 + 2 * sizeof(void *), "got cbData %#lx\n", entries[i].cbData );
        ok( entries[i].cbOverhead == 0x8, "got cbOverhead %#x\n", entries[i].cbOverhead );
    }
#ifdef __REACTOS__
    }
#endif
 
    if (entries[count - 1].wFlags == PROCESS_HEAP_REGION) /* > win7 */
        ok( entries[count - 2].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[count - 2].wFlags );
    else
        ok( entries[count - 1].wFlags == PROCESS_HEAP_UNCOMMITTED_RANGE, "got wFlags %#x\n", entries[count - 2].wFlags );
 
    count = 0;
    memset( &rtl_entries, 0, sizeof(rtl_entries) );
    memset( &rtl_entry, 0xcd, sizeof(rtl_entry) );
    rtl_entry.lpData = NULL;
    SetLastError( 0xdeadbeef );
    while (!RtlWalkHeap( heap, &rtl_entry )) rtl_entries[count++] = rtl_entry;
    todo_wine
    ok( count > 24, "got count %lu\n", count );
    if (count < 2) count = 2;
 
    for (i = 3; i < count; ++i)
    {
        winetest_push_context( "%Iu", i );
        ok( rtl_entries[i].lpData == entries[i].lpData, "got lpData %p\n", rtl_entries[i].lpData );
        ok( rtl_entries[i].cbData == entries[i].cbData, "got cbData %#Ix\n", rtl_entries[i].cbData );
        ok( rtl_entries[i].cbOverhead == entries[i].cbOverhead, "got cbOverhead %#x\n", rtl_entries[i].cbOverhead );
        ok( rtl_entries[i].iRegionIndex == entries[i].iRegionIndex, "got iRegionIndex %#x\n", rtl_entries[i].iRegionIndex );
        if (!entries[i].wFlags)
            ok( rtl_entries[i].wFlags == 0 || rtl_entries[i].wFlags == RTL_HEAP_ENTRY_LFH, "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_ENTRY_BUSY)
        {
            todo_wine
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_LFH|RTL_HEAP_ENTRY_BUSY) || broken(rtl_entries[i].wFlags == 1) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        }
        else if (entries[i].wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
            ok( rtl_entries[i].wFlags == RTL_HEAP_ENTRY_UNCOMMITTED || broken(rtl_entries[i].wFlags == 0x100) /* win7 */,
                "got wFlags %#x\n", rtl_entries[i].wFlags );
        else if (entries[i].wFlags & PROCESS_HEAP_REGION)
        {
            ok( rtl_entries[i].wFlags == (RTL_HEAP_ENTRY_LFH|RTL_HEAP_ENTRY_REGION), "got wFlags %#x\n", rtl_entries[i].wFlags );
            ok( rtl_entries[i].Region.dwCommittedSize == entries[i].Region.dwCommittedSize,
                "got Region.dwCommittedSize %#lx\n", rtl_entries[i].Region.dwCommittedSize );
            ok( rtl_entries[i].Region.dwUnCommittedSize == entries[i].Region.dwUnCommittedSize,
                "got Region.dwUnCommittedSize %#lx\n", rtl_entries[i].Region.dwUnCommittedSize );
            ok( rtl_entries[i].Region.lpFirstBlock == entries[i].Region.lpFirstBlock,
                "got Region.lpFirstBlock %p\n", rtl_entries[i].Region.lpFirstBlock );
            ok( rtl_entries[i].Region.lpLastBlock == entries[i].Region.lpLastBlock,
                "got Region.lpLastBlock %p\n", rtl_entries[i].Region.lpLastBlock );
        }
        winetest_pop_context();
    }
 
    for (i = 0; i < 0x12; i++) HeapFree( heap, 0, ptrs[i] );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* check HEAP_NO_SERIALIZE HeapCreate flag effect */
 
    heap = HeapCreate( HEAP_NO_SERIALIZE, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = TRUE;
    thread_params.flags = 0;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = FALSE;
    thread_params.flags = 0;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* check HEAP_NO_SERIALIZE HeapAlloc / HeapFree flag effect */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = TRUE;
    thread_params.flags = 0;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( res == WAIT_TIMEOUT, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = FALSE;
    thread_params.flags = 0;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( res == WAIT_TIMEOUT, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = FALSE;
    thread_params.flags = HEAP_NO_SERIALIZE;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    /* check LFH heap locking */
 
    heap = HeapCreate( 0, 0, 0 );
    ok( !!heap, "HeapCreate failed, error %lu\n", GetLastError() );
    ok( !((ULONG_PTR)heap & 0xffff), "wrong heap alignment\n" );
 
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( compat_info == 0 || broken(compat_info == 1) /* WS03 */, "got HeapCompatibilityInformation %lu\n", compat_info );
#else
    ok( compat_info == 0, "got HeapCompatibilityInformation %lu\n", compat_info );
#endif
 
    for (i = 0; i < 0x12; i++) ptrs[i] = pHeapAlloc( heap, 0, 0 );
    for (i = 0; i < 0x12; i++) HeapFree( heap, 0, ptrs[i] );
 
    ret = pHeapQueryInformation( heap, HeapCompatibilityInformation, &compat_info, sizeof(compat_info), &size );
    ok( ret, "HeapQueryInformation failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    ok( compat_info == 2 || broken(compat_info == 1) /* WS03 */, "got HeapCompatibilityInformation %lu\n", compat_info );
#else
    ok( compat_info == 2, "got HeapCompatibilityInformation %lu\n", compat_info );
#endif
 
    /* locking is serialized */
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = TRUE;
    thread_params.flags = 0;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( res == WAIT_TIMEOUT, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
 
    /* but allocation is not */
 
    ret = HeapLock( heap );
    ok( ret, "HeapLock failed, error %lu\n", GetLastError() );
    thread_params.heap = heap;
    thread_params.lock = FALSE;
    thread_params.flags = 0;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread_params.ready_event, 100 );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    ret = HeapUnlock( heap );
    ok( ret, "HeapUnlock failed, error %lu\n", GetLastError() );
    if (res) res = WaitForSingleObject( thread_params.ready_event, 100 );
 
    ret = HeapDestroy( heap );
    ok( ret, "HeapDestroy failed, error %lu\n", GetLastError() );
 
 
    thread_params.done = TRUE;
    SetEvent( thread_params.start_event );
    res = WaitForSingleObject( thread, INFINITE );
    ok( !res, "WaitForSingleObject returned %#lx, error %lu\n", res, GetLastError() );
    CloseHandle( thread_params.start_event );
    CloseHandle( thread_params.ready_event );
    CloseHandle( thread );
}

Referenced by START_TEST().

test_LocalAlloc()

static void test_LocalAlloc ( void  )

static

Definition at line 2401 of file heap.c.

{
    static const UINT flags_tests[] =
    {
        LMEM_FIXED,
        LMEM_FIXED | LMEM_DISCARDABLE,
        LMEM_MOVEABLE,
        LMEM_MOVEABLE | LMEM_NODISCARD,
        LMEM_MOVEABLE | LMEM_DISCARDABLE,
        LMEM_MOVEABLE | LMEM_DISCARDABLE | LMEM_NOCOMPACT | LMEM_NODISCARD,
    };
    static const UINT realloc_flags_tests[] =
    {
        LMEM_FIXED,
        LMEM_FIXED | LMEM_MODIFY,
        LMEM_MOVEABLE,
        LMEM_MOVEABLE | LMEM_MODIFY,
        LMEM_MOVEABLE | LMEM_DISCARDABLE,
        LMEM_MOVEABLE | LMEM_MODIFY | LMEM_DISCARDABLE,
        LMEM_MOVEABLE | LMEM_DISCARDABLE | LMEM_NOCOMPACT | LMEM_NODISCARD,
        LMEM_MOVEABLE | LMEM_MODIFY | LMEM_DISCARDABLE | LMEM_NOCOMPACT | LMEM_NODISCARD,
    };
    static const char zero_buffer[100000] = {0};
    static const SIZE_T buffer_size = ARRAY_SIZE(zero_buffer);
    const HLOCAL invalid_mem = LongToHandle( 0xdeadbee0 + sizeof(void *) );
    void *const invalid_ptr = LongToHandle( 0xdeadbee0 );
    SIZE_T size, small_size = 12, nolfh_size = 0x20000;
    HLOCAL locals[0x10000];
    HLOCAL mem, tmp_mem;
    BYTE *ptr, *tmp_ptr;
    ULONG tmp_flags;
    UINT i, flags;
    BOOL ret;
 
    mem = LocalFree( 0 );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
    mem = LocalReAlloc( 0, 10, LMEM_MOVEABLE );
    ok( !mem, "LocalReAlloc succeeded\n" );
 
    for (i = 0; i < ARRAY_SIZE(locals); ++i)
    {
        mem = LocalAlloc( LMEM_MOVEABLE | LMEM_DISCARDABLE, 0 );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        locals[i] = mem;
    }
 
    SetLastError( 0xdeadbeef );
    mem = LocalAlloc( LMEM_MOVEABLE | LMEM_DISCARDABLE, 0 );
    ok( !mem, "LocalAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    mem = GlobalAlloc( GMEM_MOVEABLE | GMEM_DISCARDABLE, 0 );
    ok( !mem, "GlobalAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
 
    mem = LocalAlloc( LMEM_DISCARDABLE, 0 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    for (i = 0; i < ARRAY_SIZE(locals); ++i)
    {
        mem = LocalFree( locals[i] );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
    }
 
    /* make sure LFH is enabled for some small block size */
    for (i = 0; i < 0x12; i++) locals[i] = pLocalAlloc( LMEM_FIXED, small_size );
    for (i = 0; i < 0x12; i++) LocalFree( locals[i] );
 
    mem = LocalAlloc( LMEM_MOVEABLE, 0 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    mem = LocalReAlloc( mem, 10, LMEM_MOVEABLE );
    ok( !!mem, "LocalReAlloc failed, error %lu\n", GetLastError() );
    size = LocalSize( mem );
    ok( size >= 10 && size <= 16, "LocalSize returned %Iu\n", size );
    mem = LocalReAlloc( mem, 0, LMEM_MOVEABLE );
    ok( !!mem, "LocalReAlloc failed, error %lu\n", GetLastError() );
    size = LocalSize( mem );
    ok( size == 0, "LocalSize returned %Iu\n", size );
    mem = LocalReAlloc( mem, 10, LMEM_MOVEABLE );
    ok( !!mem, "LocalReAlloc failed, error %lu\n", GetLastError() );
    size = LocalSize( mem );
    ok( size >= 10 && size <= 16, "LocalSize returned %Iu\n", size );
    tmp_mem = pLocalFree( mem );
    ok( !tmp_mem, "LocalFree failed, error %lu\n", GetLastError() );
    size = LocalSize( mem );
    ok( size == 0, "LocalSize returned %Iu\n", size );
 
    mem = LocalAlloc( LMEM_MOVEABLE, 256 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    ptr = LocalLock( mem );
    ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
    ok( ptr != mem, "got unexpected ptr %p\n", ptr );
    tmp_mem = LocalHandle( ptr );
    ok( tmp_mem == mem, "LocalHandle returned unexpected handle\n" );
    flags = LocalFlags( mem );
    ok( flags == 1, "LocalFlags returned %#x, error %lu\n", flags, GetLastError() );
    tmp_ptr = LocalLock( mem );
    ok( !!tmp_ptr, "LocalLock failed, error %lu\n", GetLastError() );
    ok( tmp_ptr == ptr, "got ptr %p, expected %p\n", tmp_ptr, ptr );
    flags = LocalFlags( mem );
    ok( flags == 2, "LocalFlags returned %#x, error %lu\n", flags, GetLastError() );
    ret = LocalUnlock( mem );
    ok( ret, "LocalUnlock failed, error %lu\n", GetLastError() );
    flags = LocalFlags( mem );
    ok( flags == 1, "LocalFlags returned %#x, error %lu\n", flags, GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = LocalUnlock( mem );
    ok( !ret, "LocalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_SUCCESS, "got error %lu\n", GetLastError() );
    flags = LocalFlags( mem );
    ok( !flags, "LocalFlags returned %#x, error %lu\n", flags, GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = LocalUnlock( mem );
    ok( !ret, "LocalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_NOT_LOCKED, "got error %lu\n", GetLastError() );
    tmp_mem = LocalFree( mem );
    ok( !tmp_mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    /* freed handles are caught */
    mem = LocalAlloc( LMEM_MOVEABLE, 256 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = pLocalFree( mem );
    ok( !tmp_mem, "LocalFree failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = pLocalFree( mem );
    ok( tmp_mem == mem, "LocalFree succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    flags = LocalFlags( mem );
    ok( flags == LMEM_INVALID_HANDLE, "LocalFlags succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    size = LocalSize( mem );
    ok( size == 0, "LocalSize succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = LocalLock( mem );
    ok( !ptr, "LocalLock succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = LocalUnlock( mem );
    ok( !ret, "LocalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = LocalReAlloc( mem, 0, LMEM_MOVEABLE );
    ok( !tmp_mem, "LocalReAlloc succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    if (sizeof(void *) != 8) /* crashes on 64-bit */
    {
        SetLastError( 0xdeadbeef );
        tmp_mem = LocalHandle( mem );
        ok( !tmp_mem, "LocalHandle succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    }
 
#ifdef __REACTOS__
    if (is_reactos()) {
        ok(FALSE, "FIXME: invalid handle and invalid pointer tests crash on ReactOS!\n");
    } else {
#endif
    /* invalid handles are caught */
    SetLastError( 0xdeadbeef );
    tmp_mem = pLocalFree( invalid_mem );
    ok( tmp_mem == invalid_mem, "LocalFree succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    flags = LocalFlags( invalid_mem );
    ok( flags == LMEM_INVALID_HANDLE, "LocalFlags succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    size = LocalSize( invalid_mem );
    ok( size == 0, "LocalSize succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = LocalLock( invalid_mem );
    ok( !ptr, "LocalLock succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = LocalUnlock( invalid_mem );
    ok( !ret, "LocalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = LocalReAlloc( invalid_mem, 0, LMEM_MOVEABLE );
    ok( !tmp_mem, "LocalReAlloc succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    if (sizeof(void *) != 8) /* crashes on 64-bit */
    {
        SetLastError( 0xdeadbeef );
        tmp_mem = LocalHandle( invalid_mem );
        ok( !tmp_mem, "LocalHandle succeeded\n" );
        ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    }
 
    /* invalid pointers are caught */
    SetLastError( 0xdeadbeef );
    tmp_mem = pLocalFree( invalid_ptr );
    ok( tmp_mem == invalid_ptr, "LocalFree succeeded\n" );
    todo_wine
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOACCESS || broken(GetLastError() == ERROR_INVALID_HANDLE) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
#endif
    SetLastError( 0xdeadbeef );
    flags = LocalFlags( invalid_ptr );
    todo_wine
    ok( flags == LMEM_INVALID_HANDLE, "LocalFlags succeeded\n" );
    todo_wine
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOACCESS || broken(GetLastError() == ERROR_INVALID_HANDLE) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
#endif
    SetLastError( 0xdeadbeef );
    size = LocalSize( invalid_ptr );
    ok( size == 0, "LocalSize succeeded\n" );
    ok( GetLastError() == ERROR_INVALID_HANDLE, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = LocalLock( invalid_ptr );
    ok( !ptr, "LocalLock succeeded\n" );
    ok( GetLastError() == 0xdeadbeef, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = LocalUnlock( invalid_ptr );
    ok( !ret, "LocalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_NOT_LOCKED, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = LocalReAlloc( invalid_ptr, 0, LMEM_MOVEABLE );
    ok( !tmp_mem, "LocalReAlloc succeeded\n" );
    todo_wine
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = LocalHandle( invalid_ptr );
    ok( !tmp_mem, "LocalHandle succeeded\n" );
    todo_wine
#ifdef __REACTOS__
    ok( GetLastError() == ERROR_NOACCESS || broken(GetLastError() == ERROR_INVALID_HANDLE) /* WS03 */, "got error %lu\n", GetLastError() );
#else
    ok( GetLastError() == ERROR_NOACCESS, "got error %lu\n", GetLastError() );
#endif
#ifdef __REACTOS__
    }
#endif
 
    /* LMEM_FIXED block doesn't allow resize, though it succeeds with LMEM_MODIFY */
    mem = LocalAlloc( LMEM_FIXED, small_size );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = LocalReAlloc( mem, small_size - 1, LMEM_MODIFY );
    ok( !!tmp_mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    ok( tmp_mem == mem, "got ptr %p, expected %p\n", tmp_mem, mem );
    size = LocalSize( mem );
    ok( size == small_size, "LocalSize returned %Iu\n", size );
    SetLastError( 0xdeadbeef );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA) {
#endif
    tmp_mem = LocalReAlloc( mem, small_size, 0 );
    ok( !tmp_mem, "LocalReAlloc succeeded\n" );
    ok( GetLastError() == ERROR_NOT_ENOUGH_MEMORY, "got error %lu\n", GetLastError() );
#ifdef __REACTOS__
    }
#endif
    if (tmp_mem) mem = tmp_mem;
    tmp_mem = LocalReAlloc( mem, 1024 * 1024, LMEM_MODIFY );
    ok( !!tmp_mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    ok( tmp_mem == mem, "got ptr %p, expected %p\n", tmp_mem, mem );
    size = LocalSize( mem );
    ok( size == small_size, "LocalSize returned %Iu\n", size );
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    /* LMEM_FIXED block can be relocated with LMEM_MOVEABLE */
    mem = LocalAlloc( LMEM_FIXED, small_size );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    tmp_mem = LocalReAlloc( mem, small_size + 1, LMEM_MOVEABLE );
    ok( !!tmp_mem, "LocalReAlloc failed, error %lu\n", GetLastError() );
#ifdef __REACTOS__
    if (GetNTVersion() >= _WIN32_WINNT_VISTA)
#endif
    ok( tmp_mem != mem, "LocalReAlloc didn't relocate memory\n" );
    ptr = LocalLock( tmp_mem );
    ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
    ok( ptr == tmp_mem, "got ptr %p, expected %p\n", ptr, tmp_mem );
    tmp_mem = LocalFree( tmp_mem );
    ok( !tmp_mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    /* test LocalReAlloc flags / LocalLock / size combinations */
 
#ifdef __REACTOS__
    if (GetNTVersion() < _WIN32_WINNT_VISTA) {
        skip("realloc_flags_tests invalid for WS03.\n");
    } else {
#endif
    for (i = 0; i < ARRAY_SIZE(realloc_flags_tests); i++)
    {
        struct mem_entry expect_entry, entry;
 
        flags = realloc_flags_tests[i];
 
        winetest_push_context( "flags %#x", flags );
 
        mem = pLocalAlloc( LMEM_FIXED, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = LocalReAlloc( mem, 512, flags );
        ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags != LMEM_MOVEABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem != mem, "LocalReAlloc returned %p\n", tmp_mem );
        if (tmp_mem) mem = tmp_mem;
 
        size = LocalSize( mem );
        if (flags == LMEM_MOVEABLE) ok( size == 512, "LocalSize returned %Iu\n", size );
        else ok( size == small_size, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_FIXED, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        tmp_mem = LocalReAlloc( mem, nolfh_size + 512, flags );
        ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == nolfh_size + 512, "LocalSize returned %Iu\n", size );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_FIXED, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = LocalReAlloc( mem, 10, flags );
        ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags != LMEM_MOVEABLE) todo_wine_if(!flags) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else todo_wine ok( tmp_mem != mem, "LocalReAlloc returned %p\n", tmp_mem );
        if (tmp_mem) mem = tmp_mem;
 
        size = LocalSize( mem );
        if (flags == LMEM_MOVEABLE) ok( size == 10, "LocalSize returned %Iu\n", size );
        else todo_wine_if(!flags) ok( size == small_size, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_FIXED, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        tmp_mem = LocalReAlloc( mem, 10, flags );
        ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == 10, "LocalSize returned %Iu\n", size );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_FIXED, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
 
        tmp_mem = LocalReAlloc( mem, 0, flags );
        ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags != LMEM_MOVEABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem != mem, "LocalReAlloc returned %p\n", tmp_mem );
        if (tmp_mem) mem = tmp_mem;
 
        size = LocalSize( mem );
        if (flags == LMEM_MOVEABLE) ok( size == 0 || broken( size == 1 ) /* w7 */, "LocalSize returned %Iu\n", size );
        else ok( size == small_size, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_FIXED, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( !is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        tmp_mem = LocalReAlloc( mem, 0, flags );
        ok( !is_mem_entry( tmp_mem ), "unexpected moveable %p\n", tmp_mem );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == 0 || broken( size == 1 ) /* w7 */, "LocalSize returned %Iu\n", size );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = LocalLock( mem );
        ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 512, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else if (flags & LMEM_MOVEABLE) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
#ifdef __REACTOS__
        else ok( !tmp_mem || broken(GetNTVersion() == _WIN32_WINNT_VISTA), "LocalReAlloc succeeded\n" );
#else
        else ok( !tmp_mem, "LocalReAlloc succeeded\n" );
#endif
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
#ifdef __REACTOS__
        if (flags == LMEM_MOVEABLE) ok( entry.ptr != expect_entry.ptr || broken(GetNTVersion() == _WIN32_WINNT_VISTA), "got unexpected ptr %p\n", entry.ptr );
#else
        if (flags == LMEM_MOVEABLE) ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
#endif
        else ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags == LMEM_MOVEABLE) ok( size == 512, "LocalSize returned %Iu\n", size );
#ifdef __REACTOS__
        else ok( size == small_size || broken(size == 512) /* Vista */, "LocalSize returned %Iu\n", size );
#else
        else ok( size == small_size, "LocalSize returned %Iu\n", size );
#endif
 
        ret = LocalUnlock( mem );
        ok( !ret, "LocalUnlock succeeded\n" );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = LocalLock( mem );
        ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, nolfh_size + 512, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == nolfh_size + 512, "LocalSize returned %Iu\n", size );
 
        ret = LocalUnlock( mem );
        ok( !ret, "LocalUnlock succeeded\n" );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = LocalLock( mem );
        ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 10, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == small_size, "LocalSize returned %Iu\n", size );
        else ok( size == 10, "LocalSize returned %Iu\n", size );
 
        ret = LocalUnlock( mem );
        ok( !ret, "LocalUnlock succeeded\n" );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = LocalLock( mem );
        ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 10, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p\n", tmp_mem );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == 10, "LocalSize returned %Iu\n", size );
 
        ret = LocalUnlock( mem );
        ok( !ret, "LocalUnlock succeeded\n" );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = LocalLock( mem );
        ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 0, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        ok( size == small_size, "LocalSize returned %Iu\n", size );
 
        ret = LocalUnlock( mem );
        ok( !ret, "LocalUnlock succeeded\n" );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        ptr = LocalLock( mem );
        ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 0, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
 
        ret = LocalUnlock( mem );
        ok( !ret, "LocalUnlock succeeded\n" );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 512, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( entry.ptr == expect_entry.ptr, "got ptr %p\n", entry.ptr );
#ifdef __REACTOS__
        else ok( entry.ptr != expect_entry.ptr || broken(GetNTVersion() == _WIN32_WINNT_VISTA), "got unexpected ptr %p\n", entry.ptr );
#else
        else ok( entry.ptr != expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
#endif
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == small_size, "LocalSize returned %Iu\n", size );
        else ok( size == 512, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, nolfh_size + 512, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got unexpected ptr %p\n", entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == nolfh_size + 512, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 10, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == small_size, "LocalSize returned %Iu\n", size );
        else ok( size == 10, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 10, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags & (LMEM_DISCARDABLE | LMEM_MODIFY)) ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
        else ok( size == 10, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, small_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 0, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags == LMEM_FIXED) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if (flags == LMEM_MOVEABLE)
        {
            expect_entry.flags |= 8;
            expect_entry.ptr = NULL;
        }
        else if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags == LMEM_MOVEABLE) ok( size == 0, "LocalSize returned %Iu\n", size );
        else ok( size == small_size, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
 
        mem = pLocalAlloc( LMEM_MOVEABLE, nolfh_size );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        ok( is_mem_entry( mem ), "unexpected moveable %p\n", mem );
        expect_entry = *mem_entry_from_HANDLE( mem );
 
        tmp_mem = LocalReAlloc( mem, 0, flags );
        if (flags & LMEM_MODIFY) ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        else if (flags == LMEM_FIXED) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else if (flags & LMEM_DISCARDABLE) ok( !tmp_mem, "LocalReAlloc succeeded\n" );
        else ok( tmp_mem == mem, "LocalReAlloc returned %p, error %lu\n", tmp_mem, GetLastError() );
        entry = *mem_entry_from_HANDLE( mem );
        if (flags == LMEM_MOVEABLE)
        {
            expect_entry.flags |= 8;
            expect_entry.ptr = NULL;
        }
        else if ((flags & LMEM_DISCARDABLE) && (flags & LMEM_MODIFY)) expect_entry.flags |= 4;
        ok( entry.ptr == expect_entry.ptr, "got ptr %p was %p\n", entry.ptr, expect_entry.ptr );
        ok( entry.flags == expect_entry.flags, "got flags %#Ix was %#Ix\n", entry.flags, expect_entry.flags );
 
        size = LocalSize( mem );
        if (flags == LMEM_MOVEABLE) ok( size == 0, "LocalSize returned %Iu\n", size );
        else ok( size == nolfh_size, "LocalSize returned %Iu\n", size );
 
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
        winetest_pop_context();
    }
#ifdef __REACTOS__
    }
#endif
 
    mem = LocalAlloc( LMEM_FIXED, 100 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ret = LocalUnlock( mem );
    ok( !ret, "LocalUnlock succeeded\n" );
    ok( GetLastError() == ERROR_NOT_LOCKED, "got error %lu\n", GetLastError() );
    tmp_mem = LocalHandle( mem );
    ok( tmp_mem == mem, "LocalHandle returned unexpected handle\n" );
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    mem = LocalAlloc( LMEM_FIXED, 0 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    size = LocalSize( mem );
#ifdef __REACTOS__
    ok( size == 0 || broken(size == 1) /* Vista */, "LocalSize returned %Iu\n", size );
#else
    ok( size == 0, "LocalSize returned %Iu\n", size );
#endif
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    /* trying to lock empty memory should give an error */
    mem = LocalAlloc( LMEM_MOVEABLE | LMEM_ZEROINIT, 0 );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    ptr = LocalLock( mem );
    ok( !ptr, "LocalLock succeeded\n" );
    ok( GetLastError() == ERROR_DISCARDED, "got error %lu\n", GetLastError() );
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    mem = LocalAlloc( 0, buffer_size );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    size = LocalSize( mem );
    ok( size >= buffer_size, "LocalSize returned %Iu, error %lu\n", size, GetLastError() );
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    mem = LocalAlloc( LMEM_ZEROINIT, buffer_size );
    ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
    size = LocalSize( mem );
    ok( size >= buffer_size, "LocalSize returned %Iu, error %lu\n", size, GetLastError() );
    ptr = LocalLock( mem );
    ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
    ok( ptr == mem, "got ptr %p, expected %p\n", ptr, mem );
    ok( !memcmp( ptr, zero_buffer, buffer_size ), "LocalAlloc didn't clear memory\n" );
 
    /* Check that we cannot change LMEM_FIXED to LMEM_MOVEABLE */
    mem = LocalReAlloc( mem, 0, LMEM_MODIFY | LMEM_MOVEABLE );
    ok( !!mem, "LocalReAlloc failed, error %lu\n", GetLastError() );
    ok( mem == ptr, "LocalReAlloc returned unexpected handle\n" );
    size = LocalSize( mem );
    ok( size == buffer_size, "LocalSize returned %Iu, error %lu\n", size, GetLastError() );
 
    ptr = LocalLock( mem );
    ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
    ok( ptr == mem, "got unexpected ptr %p\n", ptr );
    ret = LocalUnlock( mem );
    ok( !ret, "LocalUnlock succeeded, error %lu\n", GetLastError() );
    ok( GetLastError() == ERROR_NOT_LOCKED, "got error %lu\n", GetLastError() );
 
    tmp_mem = LocalReAlloc( mem, 2 * buffer_size, LMEM_MOVEABLE | LMEM_ZEROINIT );
    ok( !!tmp_mem, "LocalReAlloc failed\n" );
    ok( tmp_mem == mem || broken( tmp_mem != mem ) /* happens sometimes?? */,
        "LocalReAlloc returned unexpected handle\n" );
    mem = tmp_mem;
 
    size = LocalSize( mem );
    ok( size >= 2 * buffer_size, "LocalSize returned %Iu, error %lu\n", size, GetLastError() );
    ptr = LocalLock( mem );
    ok( !!ptr, "LocalLock failed, error %lu\n", GetLastError() );
    ok( ptr == mem, "got unexpected ptr %p\n", ptr );
    ok( !memcmp( ptr, zero_buffer, buffer_size ), "LocalReAlloc didn't clear memory\n" );
    ok( !memcmp( ptr + buffer_size, zero_buffer, buffer_size ),
        "LocalReAlloc didn't clear memory\n" );
 
    tmp_mem = LocalHandle( ptr );
    ok( tmp_mem == mem, "LocalHandle returned unexpected handle\n" );
    tmp_mem = LocalDiscard( mem );
    ok( !!tmp_mem, "LocalDiscard failed, error %lu\n", GetLastError() );
    ok( tmp_mem == mem, "LocalDiscard returned unexpected handle\n" );
    ret = LocalUnlock( mem );
    ok( !ret, "LocalUnlock succeeded, error %lu\n", GetLastError() );
    ok( GetLastError() == ERROR_NOT_LOCKED, "got error %lu\n", GetLastError() );
 
    tmp_mem = LocalDiscard( mem );
    ok( tmp_mem == mem, "LocalDiscard failed, error %lu\n", GetLastError() );
    mem = LocalFree( mem );
    ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
 
    for (i = 0; i < ARRAY_SIZE(flags_tests); i++)
    {
        mem = LocalAlloc( flags_tests[i], 4 );
        ok( !!mem, "LocalAlloc failed, error %lu\n", GetLastError() );
        flags = LocalFlags( mem );
        ok( !(flags & ~LMEM_DISCARDABLE), "got flags %#x, error %lu\n", flags, GetLastError() );
        mem = LocalFree( mem );
        ok( !mem, "LocalFree failed, error %lu\n", GetLastError() );
    }
 
    ptr = HeapAlloc( GetProcessHeap(), 0, 16 );
    ok( !!ptr, "HeapAlloc failed, error %lu\n", GetLastError() );
    SetLastError( 0xdeadbeef );
    tmp_mem = LocalHandle( ptr );
    ok( !!tmp_mem, "LocalHandle failed, error %lu\n", GetLastError() );
    ok( tmp_mem == ptr, "LocalHandle returned unexpected handle\n" );
    tmp_ptr = (void *)0xdeadbeef;
    tmp_flags = 0xdeadbeef;
    ret = pRtlGetUserInfoHeap( GetProcessHeap(), 0, ptr, (void **)&tmp_ptr, &tmp_flags );
    ok( ret, "RtlGetUserInfoHeap failed, error %lu\n", GetLastError() );
    ok( tmp_ptr == (void *)0xdeadbeef, "got user value %p\n", tmp_ptr );
    ok( tmp_flags == 0, "got user flags %#lx\n", tmp_flags );
    ret = HeapFree( GetProcessHeap(), 0, ptr );
    ok( ret, "HeapFree failed, error %lu\n", GetLastError() );
}

Referenced by START_TEST().

UINT()

static UINT ( WINAPI *  pGlobalFlags )

static

ULONG()

static ULONG ( WINAPI *  pRtlGetNtGlobalFlags )

static

Variable Documentation

DWORD

DWORD

Definition at line 45 of file heap.c.

Referenced by _heapwalk().

HEAP_INFORMATION_CLASS

void SIZE_T *static HEAP_INFORMATION_CLASS

Definition at line 56 of file heap.c.

LPVOID

LPVOID

Definition at line 46 of file heap.c.

SIZE_T

void SIZE_T *static void SIZE_T

Definition at line 45 of file heap.c.

ULONG

void void ULONG *static void void *static void ULONG

Definition at line 49 of file heap.c.

Referenced by RtlpDeCommitFreeBlock(), RtlpExtendHeap(), RtlpFindAndCommitPages(), RtlpGrowBlockInPlace(), RtlpInitializeHeap(), RtlpInitializeHeapSegment(), RtlpValidateHeapSegment(), RtlQueryHeapInformation(), and RtlReAllocateHeap().