marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Declare LocalDiscard and GlobalDiscard (used by kernel/tests/alloc.c) 

Remove the DISCARD_DEFINED #ifdefs.
Remove another double HeapFree (caused an assert when run on NT4),
and a HeapSize on a freed heap (the test failed on Win9x).
Fix the LocalLock/LocalUnlock tests (the memory must be allocated
with LMEM_MOVEABLE otherwise the tests don't make sense).
Remove many unnecessary casts.
Improved error reporting somewhat.
oldstable
Francois Gouget 2002-12-19 01:03:48 +00:00 committed by Alexandre Julliard
parent 4b1479c990
commit 305ead6205
2 changed files with 44 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
dlls/kernel/tests/alloc.c
View File

@ -22,11 +22,6 @@
#include "winbase.h"
#include "winerror.h"
/* Currently Wine doesn't have macros for LocalDiscard and GlobalDiscard
so I am disableing the checks for them. These macros are equivalent
to reallocing '0' bytes, so we try that instead
*/
#define DISCARD_DEFINED 0
/* The following functions don't have tests, because either I don't know how
to test them, or they are WinNT only, or require multiple threads.
@ -69,7 +64,7 @@ static void test_Heap(void)
more tweaking for otherWindows variants.
*/
memchunk=10*sysInfo.dwPageSize;
heap=HeapCreate((DWORD)NULL,2*memchunk,5*memchunk);
heap=HeapCreate(0,2*memchunk,5*memchunk);
/* Check that HeapCreate allocated the right amount of ram */
todo_wine {
@ -77,25 +72,25 @@ static void test_Heap(void)
MSDN says the maximum heap size should be dwMaximumSize rounded up to the
nearest page boundary
*/
mem1=HeapAlloc(heap,(DWORD)NULL,5*memchunk+1);
mem1=HeapAlloc(heap,0,5*memchunk+1);
ok(mem1==NULL,"HeapCreate allocated more Ram than it should have");
if(mem1) {
HeapFree(heap,(DWORD)NULL,mem1);
HeapFree(heap,0,mem1);
}
}
/* Check that a normal alloc works */
mem1=HeapAlloc(heap,(DWORD)NULL,memchunk);
mem1=HeapAlloc(heap,0,memchunk);
ok(mem1!=NULL,"HeapAlloc failed");
if(mem1) {
ok(HeapSize(heap,(DWORD)NULL,mem1)>=memchunk, "HeapAlloc should return a big enough memory block");
ok(HeapSize(heap,0,mem1)>=memchunk, "HeapAlloc should return a big enough memory block");
}
/* Check that a 'zeroing' alloc works */
mem2=(UCHAR *)HeapAlloc(heap,HEAP_ZERO_MEMORY,memchunk);
mem2=HeapAlloc(heap,HEAP_ZERO_MEMORY,memchunk);
ok(mem2!=NULL,"HeapAlloc failed");
if(mem2) {
ok(HeapSize(heap,(DWORD)NULL,mem2)>=memchunk,"HeapAlloc should return a big enough memory block");
ok(HeapSize(heap,0,mem2)>=memchunk,"HeapAlloc should return a big enough memory block");
error=0;
for(i=0;i<memchunk;i++) {
if(mem2[i]!=0) {
@ -106,17 +101,17 @@ static void test_Heap(void)
}
/* Check that HeapAlloc returns NULL when requested way too much memory */
mem3=HeapAlloc(heap,(DWORD)NULL,5*memchunk);
mem3=HeapAlloc(heap,0,5*memchunk);
ok(mem3==NULL,"HeapAlloc should return NULL");
if(mem3) {
ok(HeapFree(heap,(DWORD)NULL,mem3),"HeapFree didn't pass successfully");
ok(HeapFree(heap,0,mem3),"HeapFree didn't pass successfully");
}
/* Check that HeapRealloc works */
mem2a=(UCHAR *)HeapReAlloc(heap,HEAP_ZERO_MEMORY,mem2,memchunk+5*sysInfo.dwPageSize);
mem2a=HeapReAlloc(heap,HEAP_ZERO_MEMORY,mem2,memchunk+5*sysInfo.dwPageSize);
ok(mem2a!=NULL,"HeapReAlloc failed");
if(mem2a) {
ok(HeapSize(heap,(DWORD)NULL,mem2a)>=memchunk+5*sysInfo.dwPageSize,"HeapReAlloc failed");
ok(HeapSize(heap,0,mem2a)>=memchunk+5*sysInfo.dwPageSize,"HeapReAlloc failed");
error=0;
for(i=0;i<5*sysInfo.dwPageSize;i++) {
if(mem2a[memchunk+i]!=0) {
@ -138,26 +133,16 @@ static void test_Heap(void)
/* Check that HeapFree works correctly */
if(mem1a) {
ok(HeapFree(heap,(DWORD)NULL,mem1a),"HeapFree failed");
ok(HeapFree(heap,0,mem1a),"HeapFree failed");
} else {
ok(HeapFree(heap,(DWORD)NULL,mem1),"HeapFree failed");
ok(HeapFree(heap,0,mem1),"HeapFree failed");
}
if(mem2a) {
ok(HeapFree(heap,(DWORD)NULL,mem2a),"HeapFree failed");
ok(HeapFree(heap,0,mem2a),"HeapFree failed");
} else {
ok(HeapFree(heap,(DWORD)NULL,mem2),"HeapFree failed");
ok(HeapFree(heap,0,mem2),"HeapFree failed");
}
/* take just freed pointer */
if (mem1a)
mem1 = mem1a;
/* try to free it one more time */
HeapFree(heap, 0, mem1);
dwSize = HeapSize(heap, 0, mem1);
ok(dwSize == 0xFFFFFFFF, "The size");
/* 0-length buffer */
mem1 = HeapAlloc(heap, 0, 0);
ok(mem1 != NULL, "Reserved memory");
@ -194,7 +179,7 @@ static void test_Global(void)
SetLastError(NO_ERROR);
/* Check that a normal alloc works */
mem1=GlobalAlloc((UINT)NULL,memchunk);
mem1=GlobalAlloc(0,memchunk);
ok(mem1!=NULL,"GlobalAlloc failed");
if(mem1) {
ok(GlobalSize(mem1)>=memchunk, "GlobalAlloc should return a big enough memory block");
@ -202,11 +187,11 @@ static void test_Global(void)
/* Check that a 'zeroing' alloc works */
mem2=GlobalAlloc(GMEM_ZEROINIT,memchunk);
ok(mem2!=NULL,"GlobalAlloc failed");
ok(mem2!=NULL,"GlobalAlloc failed: error=%ld",GetLastError());
if(mem2) {
ok(GlobalSize(mem2)>=memchunk,"GlobalAlloc should return a big enough memory block");
mem2ptr=(UCHAR *)GlobalLock(mem2);
ok(mem2ptr==(UCHAR *)mem2,"GlobalLock should have returned the same memory as was allocated");
mem2ptr=GlobalLock(mem2);
ok(mem2ptr==mem2,"GlobalLock should have returned the same memory as was allocated");
if(mem2ptr) {
error=0;
for(i=0;i<memchunk;i++) {
@ -220,7 +205,7 @@ static void test_Global(void)
/* Check that GlobalReAlloc works */
/* Check that we can change GMEM_FIXED to GMEM_MOVEABLE */
mem2a=GlobalReAlloc(mem2,0,GMEM_MODIFY | GMEM_MOVEABLE);
ok(mem2a!=NULL,"GlobalReAlloc failed to convert FIXED to MOVEABLE");
ok(mem2a!=NULL,"GlobalReAlloc failed to convert FIXED to MOVEABLE: error=%ld",GetLastError());
if(mem2a!=NULL) {
mem2=mem2a;
}
@ -233,7 +218,7 @@ static void test_Global(void)
ok(mem2a!=NULL,"GlobalReAlloc failed");
if(mem2a) {
ok(GlobalSize(mem2a)>=2*memchunk,"GlobalReAlloc failed");
mem2ptr=(UCHAR *)GlobalLock(mem2a);
mem2ptr=GlobalLock(mem2a);
ok(mem2ptr!=NULL,"GlobalLock Failed.");
if(mem2ptr) {
error=0;
@ -249,15 +234,8 @@ static void test_Global(void)
ok(mem2b==mem2a,"GlobalHandle didn't return the correct memory handle");
/* Check that we can't discard locked memory */
#if DISCARD_DEFINED
/* Wine doesn't include the GlobalDiscard function */
mem2b=GlobalDiscard(mem2a);
ok(mem2b==NULL,"Discarded memory we shouldn't have");
#else
/* This is functionally equivalent to the above */
mem2b=GlobalReAlloc(mem2a,0,GMEM_MOVEABLE);
ok(mem2b==NULL,"Discarded memory we shouldn't have");
#endif
ok(!GlobalUnlock(mem2a) && GetLastError()==NO_ERROR,"GlobalUnlock Failed.");
}
}
@ -292,19 +270,19 @@ static void test_Local(void)
memchunk=100000;
/* Check that a normal alloc works */
mem1=LocalAlloc((UINT)NULL,memchunk);
ok(mem1!=NULL,"LocalAlloc failed");
mem1=LocalAlloc(0,memchunk);
ok(mem1!=NULL,"LocalAlloc failed: error=%ld",GetLastError());
if(mem1) {
ok(LocalSize(mem1)>=memchunk, "LocalAlloc should return a big enough memory block");
}
/* Check that a 'zeroing' alloc works */
mem2=LocalAlloc(LMEM_ZEROINIT,memchunk);
ok(mem2!=NULL,"LocalAlloc failed");
/* Check that a 'zeroing' and lock alloc works */
mem2=LocalAlloc(LMEM_ZEROINIT|LMEM_MOVEABLE,memchunk);
ok(mem2!=NULL,"LocalAlloc failed: error=%ld",GetLastError());
if(mem2) {
ok(LocalSize(mem2)>=memchunk,"LocalAlloc should return a big enough memory block");
mem2ptr=(UCHAR *)LocalLock(mem2);
ok(mem2ptr==(UCHAR *)mem2,"LocalLock Didn't lock it's memory");
mem2ptr=LocalLock(mem2);
ok(mem2ptr!=NULL,"LocalLock: error=%ld",GetLastError());
if(mem2ptr) {
error=0;
for(i=0;i<memchunk;i++) {
@ -313,23 +291,25 @@ static void test_Local(void)
}
}
ok(!error,"LocalAlloc should have zeroed out it's allocated memory");
ok(!(error=LocalUnlock(mem2)) &&
(GetLastError()==ERROR_NOT_LOCKED || GetLastError()==NO_ERROR),
"LocalUnlock Failed.");
SetLastError(0);
error=LocalUnlock(mem2);
ok(error==0 && GetLastError()==NO_ERROR,
"LocalUnlock Failed: rc=%d err=%ld",error,GetLastError());
}
}
mem2a=LocalFree(mem2);
ok(mem2a==NULL, "LocalFree failed: %p",mem2a);
/* Reallocate mem2 as moveable memory */
mem2a=LocalFree(mem2);
mem2=LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,memchunk);
ok(mem2a==NULL && mem2!=NULL, "LocalAlloc failed to create moveable memory");
ok(mem2!=NULL, "LocalAlloc failed to create moveable memory, error=%ld",GetLastError());
/* Check that ReAllocing memory works as expected */
mem2a=LocalReAlloc(mem2,2*memchunk,LMEM_MOVEABLE | LMEM_ZEROINIT);
ok(mem2a!=NULL,"LocalReAlloc failed");
ok(mem2a!=NULL,"LocalReAlloc failed, error=%ld",GetLastError());
if(mem2a) {
ok(LocalSize(mem2a)>=2*memchunk,"LocalReAlloc failed");
mem2ptr=(UCHAR *)LocalLock(mem2a);
mem2ptr=LocalLock(mem2a);
ok(mem2ptr!=NULL,"LocalLock Failed.");
if(mem2ptr) {
error=0;
@ -343,15 +323,8 @@ static void test_Local(void)
mem2b=LocalHandle(mem2ptr);
ok(mem2b==mem2a,"LocalHandle didn't return the correct memory handle");
/* Check that we can't discard locked memory */
#if DISCARD_DEFINED
/* Wine doesn't include the LocalDiscard function */
mem2b=LocalDiscard(mem2a);
ok(mem2b==NULL,"Discarded memory we shouldn't have");
#else
/* This is functionally equivalent to the above */
mem2b=LocalReAlloc(mem2a,0,GMEM_MOVEABLE);
ok(mem2b==NULL,"Discarded memory we shouldn't have");
#endif
SetLastError(NO_ERROR);
ok(!LocalUnlock(mem2a) && GetLastError()==NO_ERROR, "LocalUnlock Failed.");
}

6
include/winbase.h
View File

@ -419,6 +419,8 @@ typedef struct _PROCESS_HEAP_ENTRY
#define NONZEROLHND (LMEM_MOVEABLE)
#define NONZEROLPTR (LMEM_FIXED)
#define LocalDiscard(h) (LocalReAlloc((h),0,LMEM_MOVEABLE))
#define GMEM_FIXED 0x0000
#define GMEM_MOVEABLE 0x0002
#define GMEM_NOCOMPACT 0x0010
@ -438,6 +440,10 @@ typedef struct _PROCESS_HEAP_ENTRY
#define GHND (GMEM_MOVEABLE | GMEM_ZEROINIT)
#define GPTR (GMEM_FIXED | GMEM_ZEROINIT)
#define GlobalLRUNewest(h) ((HANDLE)(h))
#define GlobalLRUOldest(h) ((HANDLE)(h))
#define GlobalDiscard(h) (GlobalReAlloc((h),0,GMEM_MOVEABLE))
#define INVALID_ATOM ((ATOM)0)
#define MAXINTATOM 0xc000
#define MAKEINTATOMA(atom) ((LPCSTR)((ULONG_PTR)((WORD)(atom))))