Index: /trunk/psLib/test/sysUtils/tst_psMemory.c =================================================================== --- /trunk/psLib/test/sysUtils/tst_psMemory.c (revision 639) +++ /trunk/psLib/test/sysUtils/tst_psMemory.c (revision 640) @@ -6,6 +6,6 @@ * @author Robert DeSonia, MHPCC * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-05-11 03:14:49 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2004-05-11 20:52:33 $ * * Copyright 2004 Maui High Performance Computing Center, University of Hawaii @@ -34,4 +34,9 @@ static long memAllocateCallback(const psMemBlock *ptr); static long memFreeCallback(const psMemBlock *ptr); +int TPcheckLeaks(void); +int TPmemCorruption(void); +void memProblemCallback(const psMemBlock *ptr, const char *file, int lineno); + +static int problemCallbackCalled = 0; static int allocCallbackCalled = 0; static int freeCallbackCalled = 0; @@ -43,6 +48,8 @@ {TPOutOfMemory,"450-TPOutOfMemory",0}, {TPrealloc,"451-TPrealloc",0}, - {TPallocCallback,"452-TPallocCallback",0}, - {TPFreeReferencedMemory,"TPFreeReferencedMemory",6}, + {TPallocCallback,"452/453-TPallocCallback",0}, + {TPcheckLeaks,"454-TPcheckLeaks",0}, + {TPmemCorruption,"455-TPmemCorruption",0}, + {TPFreeReferencedMemory,"456-TPFreeReferencedMemory",0}, {NULL} }; @@ -95,10 +102,51 @@ int* mem; int currentId = psMemGetId(); - - fprintf(stderr,"Allocating buffer.\n"); + int ref = 0; + psMemProblemCallback cb; + + psLogMsg(__func__,PS_LOG_INFO,"memory reference count shall be incrementable/decrementable"); + mem = (int*) psAlloc(100*sizeof(int)); + ref = psMemGetRefCounter(mem); + if (ref != 1) { + psError(__func__,"Expected to buffer reference count to be initially 1, but it was %d.",ref); + return 1; + } + psMemIncrRefCounter(mem); - fprintf(stderr,"Freeing buffer after incrementing reference count.\n"); + psMemIncrRefCounter(mem); + psMemIncrRefCounter(mem); + + ref = psMemGetRefCounter(mem); + if (ref != 4) { + psError(__func__,"Expected to find buffer reference count to be 4, but it was %d.",ref); + return 1; + } + + psMemDecrRefCounter(mem); + psMemDecrRefCounter(mem); + + ref = psMemGetRefCounter(mem); + if (ref != 2) { + psError(__func__,"Expected to find buffer reference count to be 2, but it was %d.",ref); + return 1; + } + + psLogMsg(__func__,PS_LOG_INFO,"expect error from free as multiple referenced buffer is freed."); + + problemCallbackCalled = 0; + cb = psMemProblemCallbackSet(memProblemCallback); + + psFree(mem); + + psMemProblemCallbackSet(cb); + + if (problemCallbackCalled != 1) { + psError(__func__,"Expected memProblemCallback to be called once, but was called %d times.", + problemCallbackCalled); + return 1; + } + psFree(mem); @@ -267,6 +315,174 @@ return 1; } - return 0; - + + psMemCheckLeaks(currentId,NULL,NULL); + psMemCheckCorruption(1); + + return 0; + +} + +int TPcheckLeaks(void) +{ + const int numBuffers = 5; + int* buffers[5]; + int lcv; + int currentId = psMemGetId(); + psMemBlock** blks; + int nLeaks = 0; + int lineMark = 0; + + psLogMsg(__func__,PS_LOG_INFO,"psMemCheckLeaks shall return the number of blocks above an ID " + "that are still allocated"); + + for (lcv=0;lcvlineno != lineMark) { + psError(__FILE__,"psMemCheckLeaks found a leak other than the expected one (line %d vs %d) in %s.", + lineMark, blks[0]->lineno, __func__); + return 1; + } + + psFree(buffers[0]); + psFree(blks); + + psLogMsg(__func__,PS_LOG_INFO,"Testing psMemCheckLeaks again with a different leak location"); + psMemCheckLeaks(currentId,NULL,stderr); + + for (lcv=0;lcvlineno != lineMark) { + psError(__FILE__,"psMemCheckLeaks found a leak other than the expected one in %s.",__func__); + return 1; + } + + psFree(buffers[4]); + psFree(blks); + + psLogMsg(__func__,PS_LOG_INFO,"Testing psMemCheckLeaks again with multiple leak locations."); + + for (lcv=0;lcvlineno != lineMark) { + psError(__FILE__,"psMemCheckLeaks found a leak other than the expected one in %s.",__func__); + return 1; + } + + psFree(blks); + psFree(buffers[1]); + psFree(buffers[3]); + + psMemCheckLeaks(currentId,NULL,NULL); + psMemCheckCorruption(1); + + return 0; +} + +int TPmemCorruption(void) +{ + int* buffer = NULL; + int oldValue = 0; + int corruptions = 0; + psMemProblemCallback cb; + + psLogMsg(__func__,PS_LOG_INFO,"psMemCheckCorruption shall detect memory corruptions"); + + buffer = psAlloc(sizeof(int)); + + // cause memory corruption via buffer underflow + *buffer = 1; + buffer--; + oldValue = *buffer; + *buffer = 2; + + problemCallbackCalled = 0; + cb = psMemProblemCallbackSet(memProblemCallback); + + psLogMsg(__func__,PS_LOG_INFO,"psMemCheckCorruption should output an error message and " + "memProblemCallback callback should be called."); + + corruptions = psMemCheckCorruption(0); + + // restore the memory problem callback + psMemProblemCallbackSet(cb); + + // restore the value, 'uncorrupting' the buffer + *buffer = oldValue; + buffer++; + + psFree(buffer); + + if (corruptions != 1) { + psError(__FILE__,"Expected one memory corruption but found %d in %s.", + corruptions, __func__); + return 1; + } + + if (problemCallbackCalled != 1) { + psError(__FILE__,"The memProblemCallback was not invoked but should have been in %s", + __func__); + return 1; + } + + return 0; + +} + +void memProblemCallback(const psMemBlock *ptr, const char *file, int lineno) +{ + psLogMsg(__func__,PS_LOG_INFO,"memory callback called for id %d (%s:%d).", + ptr->id, file, lineno); + problemCallbackCalled++; + return; } Index: /trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr =================================================================== --- /trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr (revision 639) +++ /trunk/psLib/test/sysUtils/verified/tst_psMemory.stderr (revision 640) @@ -34,5 +34,5 @@ /----------------------------- TESTPOINT ------------------------------------------\ | TestFile: tst_psMemory.c | -| TestPoint: psMemory{452-TPallocCallback} | +| TestPoint: psMemory{452/453-TPallocCallback} | | TestType: Positive | \----------------------------------------------------------------------------------/ @@ -47,17 +47,52 @@