static int allocatedBlocks = 0;
static int initialBlocksUsed = 0;
static int allocatedArrays = 0;
static int initialArraysUsed = 0;

static char message[30] = "";


void reportMemoryBallance()
{
int blockBalance = allocatedBlocks - initialBlocksUsed;
int arrayBalance = allocatedArrays - initialArraysUsed;
if (blockBalance == 0 && arrayBalance == 0)
printf("No leaks detected\n");
else
{
if (blockBalance > 0)
printf("Memory leak! %d blocks not deleted\n", blockBalance);
if (arrayBalance > 0)
printf("Memory leak! %d arrays not deleted\n", arrayBalance);
if (blockBalance < 0)
printf("More blocks deleted than newed! %d extra deletes\n", blockBalance);
if (arrayBalance < 0)
printf("More arrays deleted than newed! %d extra deletes\n", arrayBalance);

printf("NOTE - some memory leaks appear to be allocated statics that are not released\n"
" - by the standard library\n"
" - Use the -r switch on your unit tests to repeat the test sequence\n"
" - If no leaks are reported on the second pass, it is likely a static\n"
" - that is not released\n");
}
}


void MemoryLeakWarning[?]::Enable()
{
initialBlocksUsed = allocatedBlocks;
initialArraysUsed = allocatedArrays;
atexit(reportMemoryBallance);
}

void MemoryLeakWarning[?]::Report()
{
if (initialBlocksUsed != allocatedBlocks || initialArraysUsed != allocatedArrays )
{
printf("Memory new/delete imbalance after running tests\n");
}
}

static int blockUsageCheckPoint = 0;
static int arrayUsageCheckPoint = 0;

void MemoryLeakWarning[?]::CheckPointUsage[?]()
{
blockUsageCheckPoint = allocatedBlocks;
arrayUsageCheckPoint = allocatedArrays;
}


bool MemoryLeakWarning[?]::UsageIsNotBalanced[?]()
{
if (blockUsageCheckPoint != allocatedBlocks)
sprintf(message, "this test leaks %d blocks",
allocatedBlocks - blockUsageCheckPoint);

if (arrayUsageCheckPoint != allocatedArrays)
sprintf(message, "this test leaks %d arrays",
allocatedArrays - arrayUsageCheckPoint);

return blockUsageCheckPoint != allocatedBlocks
|| arrayUsageCheckPoint != allocatedArrays;
}

const char* MemoryLeakWarning[?]::Message()
{
return message;
}

void* operator new(size_t size)
{
allocatedBlocks++;
return malloc(size);
}

void operator delete(void* mem)
{
allocatedBlocks;
free(mem);
}

void* operator new[](size_t size)
{
allocatedArrays++;
return malloc(size);
}

void operator delete[](void* mem)
{
allocatedArrays;
free(mem);
}

_CrtSetDbgFlag((a) | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG))

void MemoryLeakWarning[?]::Enable()
{
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
SET_CRT_DEBUG_FIELD( _CRTDBG_LEAK_CHECK_DF );
}

void MemoryLeakWarning[?]::Report()
{
//windows reports leaks automatically when set up as above
}

_CrtMemState s1, s2, s3;


void MemoryLeakWarning[?]::CheckPointUsage[?]()
{
_CrtMemCheckpoint( &s1 );
}

bool MemoryLeakWarning[?]::UsageIsNotBalanced[?]()
{
_CrtMemCheckpoint( &s2 );
if (_CrtMemDifference( &s3, &s1, &s2) )
return true;
else
return false;
}

const char* MemoryLeakWarning[?]::Message()
{
return "this test leaks";
}