TEST( partial_allocate_free , MemoryShakeOut )
{
io::create("Student Values", "Test5.txt");
fprintf(io::getHandle(),"Test5: \n\n");
fprintf(io::getHandle()," 1) allocate block \n");
fprintf(io::getHandle()," 2) free block \n\n");
fprintf(io::getHandle()," memSystem mem; \n");
fprintf(io::getHandle()," mem.InitializeSystem(); \n");
fprintf(io::getHandle()," void *p = mem.Malloc( 0x200 ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( p ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
// Part A:
memSystem mem1;
mem1.InitializeSystem();
void *p1 = mem1.Malloc( 0x200 );
mem1.dump();
// Part B:
mem1.Free( p1 );
mem1.dump();
io::destroy();
// ---- GENERAL CHECK ------------------------------------------------------
// ---- Part A: -------------------------------------------------------------
memSystem mem;
mem.InitializeSystem();
void *p = mem.Malloc( 0x200 );
p; // shut up warning
// ---- Verify A: -----------------------------------------------------------
heapHdr *h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 + 0x10 + 0x200 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40);
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 1 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0x200);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 1 );
CHECK_EQUAL( h->stats.currUsedMem, 0x200 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc5a0 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
memU32 hdrStart;
memU32 hdrEnd;
memU32 blkStart;
memU32 blkEnd;
// ---- USED HDR -------------------------------------------
// Check type
usedHdr *used = (usedHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- USED BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x250);
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- FREE HDR -------------------------------------------
// Check type
freeHdr *free = (freeHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)free->blockType, 0xCC );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x250 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x260 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- FREE BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( free->blockSize, 0xc5a0 );
// ---- Part B: -------------------------------------------------------------
mem.Free( p );
// ---- Verify B: -----------------------------------------------------------
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x0);
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 1 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0x200);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 0 );
CHECK_EQUAL( h->stats.currUsedMem, 0x0 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc7b0 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- FREE HDR -------------------------------------------
// Check type
free = (freeHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)free->blockType, 0xcc );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- FREE BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( free->blockSize, 0xc7b0);
}
TEST( Allocate_3_100_middle_down_free , MemoryShakeOut )
{
io::create("Rodolfo Gomez", "Test11.txt");
fprintf(io::getHandle(),"Test11: \n\n");
fprintf(io::getHandle()," 1) used \n");
fprintf(io::getHandle()," 2) used \n");
fprintf(io::getHandle()," 3) used (make sure it's consumes 100 percent of heap) \n");
fprintf(io::getHandle()," 4) middle down \n\n");
fprintf(io::getHandle()," memSystem mem; \n");
fprintf(io::getHandle()," mem.InitializeSystem(); \n");
fprintf(io::getHandle()," void *a = mem.Malloc( 0x4280 ); \n");
fprintf(io::getHandle()," void *b = mem.Malloc( 0x4280 ); \n");
fprintf(io::getHandle()," void *c = mem.Malloc( 0x4290 ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( b ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( c ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( a ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
// Part A:
memSystem mem1;
mem1.InitializeSystem();
void *a1 = mem1.Malloc( 0x4280 );
void *b1 = mem1.Malloc( 0x4280 );
void *c1 = mem1.Malloc( 0x4290 );
mem1.dump();
// Part B:
mem1.Free( b1 );
mem1.dump();
// Part C:
mem1.Free( c1 );
mem1.dump();
// Part D:
mem1.Free( a1 );
mem1.dump();
io::destroy();
// ---- GENERAL CHECK ------------------------------------------------------
// ---- Part A: -------------------------------------------------------------
memSystem mem;
mem.InitializeSystem();
void *a = mem.Malloc( 0x4280 );
void *b = mem.Malloc( 0x4280 );
void *c = mem.Malloc( 0x4290 );
// ---- Verify A: -----------------------------------------------------------
heapHdr *h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x0);
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x8560 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0xc790);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 3);
CHECK_EQUAL( h->stats.currUsedMem, 0xc790);
CHECK_EQUAL( h->stats.currNumFreeBlocks, 0 );
CHECK_EQUAL( h->stats.currFreeMem, 0x0 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
memU32 hdrStart;
memU32 hdrEnd;
memU32 blkStart;
memU32 blkEnd;
// ---- USED HDR 1 -------------------------------------------
// Check type
usedHdr *used = (usedHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x42d0);
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- USED BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x42d0);
CHECK_EQUAL( used->blockSize, 0x4280 );
// ---- Used HDR 2 -------------------------------------------
// Check type
used = (usedHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x42d0 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x42e0 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x8560 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x40 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x8560);
CHECK_EQUAL( used->blockSize, 0x4280 );
// ---- Used HDR 3 -------------------------------------------
// Check type
used = (usedHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x8560 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x8570 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0);
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x42d0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( used->blockSize, 0x4290 );
// ---- Part B: -------------------------------------------------------------
mem.Free( b );
// ---- Verify B: -----------------------------------------------------------
h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x42d0 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x8560 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0xc790);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 2);
CHECK_EQUAL( h->stats.currUsedMem, 0xc790 - 0x4280 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0x4280 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- HDR 1 -------------------------------------------
// Check type
used = (usedHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x8560 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- USED BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x42d0 );
CHECK_EQUAL( used->blockSize, 0x4280 );
// ---- HDR 2 -------------------------------------------
// Check type
freeHdr *free = (freeHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)free->blockType, 0xCC );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x42d0 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x42e0 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- Free BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x8560 );
CHECK_EQUAL( free->blockSize, 0x4280 );
// ---- Hdr 3 -------------------------------------------
// Check type
used = (usedHdr *) blkEnd;
// Should be free
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x8560 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x8570 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0);
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x40 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- Used Block ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( used->blockSize, 0x4290 );
// ---- Part C: -------------------------------------------------------------
mem.Free( c );
// ---- Verify C: -----------------------------------------------------------
h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x42d0);
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0xc790);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 1);
CHECK_EQUAL( h->stats.currUsedMem, 0x4280);
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0x8520 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- HDR 1 -------------------------------------------
// Check type
used = (usedHdr *) h->stats.heapTopAddr;
CHECK_EQUAL( (int)used->blockType, 0xaa );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- free BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x42d0 );
CHECK_EQUAL( used->blockSize, 0x4280 );
// ---- HDR 2 -------------------------------------------
// Check type
free = (freeHdr *) blkEnd;
CHECK_EQUAL( (int)free->blockType, 0xcc );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x42d0 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x42e0 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0);
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- Used Block ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( free->blockSize, 0x8520 );
// ---- Part D: -------------------------------------------------------------
mem.Free( a );
// ---- Verify D: -----------------------------------------------------------
h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x0 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0xc790 );
CHECK_EQUAL( h->stats.currNumUsedBlocks, 0);
CHECK_EQUAL( h->stats.currUsedMem, 0x0 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc7b0 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- FREE HDR 1 -------------------------------------------
// Check type
free = (freeHdr *) h->stats.heapTopAddr;
// Should be free
CHECK_EQUAL( (int)free->blockType, 0xCC );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- free BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + 0x10 + 0xc7b0);
CHECK_EQUAL( free->blockSize, 0xc7b0 );
}
TEST( Allocate_3_bottom_up_free , MemoryShakeOut )
{
io::create("Hector Medina", "Test7.txt");
fprintf(io::getHandle(),"Test7: \n\n");
fprintf(io::getHandle()," 1) used \n");
fprintf(io::getHandle()," 2) used \n");
fprintf(io::getHandle()," 3) used \n");
fprintf(io::getHandle()," 4) bottom up free \n\n");
fprintf(io::getHandle()," memSystem mem; \n");
fprintf(io::getHandle()," mem.InitializeSystem(); \n");
fprintf(io::getHandle()," void *a = mem.Malloc( 0x200 ); \n");
fprintf(io::getHandle()," void *b = mem.Malloc( 0x200 ); \n");
fprintf(io::getHandle()," void *c = mem.Malloc( 0x200 ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( c ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( b ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
fprintf(io::getHandle()," mem.Free( a ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
// Part A:
memSystem mem1;
mem1.InitializeSystem();
void *a1 = mem1.Malloc( 0x200 );
void *b1 = mem1.Malloc( 0x200 );
void *c1 = mem1.Malloc( 0x200 );
mem1.dump();
// Part B:
mem1.Free( c1 );
mem1.dump();
// Part C:
mem1.Free( b1 );
mem1.dump();
// Part D:
mem1.Free( a1 );
mem1.dump();
io::destroy();
// ---- GENERAL CHECK ------------------------------------------------------
// ---- Part A: -------------------------------------------------------------
memSystem mem;
mem.InitializeSystem();
void *a = mem.Malloc( 0x200 );
void *b = mem.Malloc( 0x200 );
void *c = mem.Malloc( 0x200 );
// ---- Verify A: -----------------------------------------------------------
heapHdr *h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 + 0x10 + 0x200);
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 3);
CHECK_EQUAL( h->stats.currUsedMem, 3*0x200 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc180 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
memU32 hdrStart;
memU32 hdrEnd;
memU32 blkStart;
memU32 blkEnd;
// ---- USED HDR 1 -------------------------------------------
// Check type
usedHdr *used = (usedHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x250 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- USED BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x250);
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- Used HDR 2 -------------------------------------------
// Check type
used = (usedHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x250 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x260 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x250+0x200+0x10 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x40 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x460);
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- Used HDR 3 -------------------------------------------
// Check type
used = (usedHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x460 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x470 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0);
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x250 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x460+0x200+0x10);
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- free HDR 4 -------------------------------------------
// Check type
freeHdr *free = (freeHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)free->blockType, 0xcc );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x670 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x680 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- free BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( free->blockSize, 0xc180 );
// ---- Part B: -------------------------------------------------------------
mem.Free( c );
// ---- Verify B: -----------------------------------------------------------
h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 + 0x10 + 0x200 + 0x10 + 0x200 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x250);
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 2);
CHECK_EQUAL( h->stats.currUsedMem, 2*0x200 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc180 + 0x200 + 0x10);
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- USED HDR 1 -------------------------------------------
// Check type
used = (usedHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x250 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- USED BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x250);
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- Used HDR 2 -------------------------------------------
// Check type
used = (usedHdr *) blkEnd;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x250 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x260 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x40 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x250 + (0x200 + 0x10));
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- Used free 3 -------------------------------------------
// Check type
free = (freeHdr *) blkEnd;
// Should be free
CHECK_EQUAL( (int)free->blockType, 0xCC );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x460 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x470 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0);
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( free->blockSize, 0xc390 );
// ---- Part C: -------------------------------------------------------------
mem.Free( b );
// ---- Verify C: -----------------------------------------------------------
h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 + 0x10 + 0x200 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 1);
CHECK_EQUAL( h->stats.currUsedMem, 0x200 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc5a0);
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- used HDR 1 -------------------------------------------
// Check type
used = (usedHdr *) h->stats.heapTopAddr;
// Should be free
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + 0x10 + 0x200);
CHECK_EQUAL( used->blockSize, 0x200 );
// ---- free hdr 2 -------------------------------------------
// Check type
free = (freeHdr *) blkEnd;
// Should be free
CHECK_EQUAL( (int)free->blockType, 0xCC );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x250 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x260 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- used BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( free->blockSize, 0xc5a0 );
// ---- Part D: -------------------------------------------------------------
mem.Free( a );
// ---- Verify D: -----------------------------------------------------------
h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0x40 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x0 );
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 3 );
CHECK_EQUAL( h->stats.peakUsedMemory, 3*0x200);
CHECK_EQUAL( h->stats.currNumUsedBlocks, 0);
CHECK_EQUAL( h->stats.currUsedMem, 0x0 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 1 );
CHECK_EQUAL( h->stats.currFreeMem, 0xc7b0 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
// ---- FREE HDR 1 -------------------------------------------
// Check type
free = (freeHdr *) h->stats.heapTopAddr;
// Should be free
CHECK_EQUAL( (int)free->blockType, 0xCC );
hdrStart = (memU32)free;
hdrEnd = (memU32)free + sizeof(freeHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(free->freePrev), 0x0 );
// Next
CHECK_EQUAL( PTR_FIX(free->freeNext), 0x0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(freeHdr) );
// ---- free BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + free->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0x40 + 0x10 + 0xc7b0);
CHECK_EQUAL( free->blockSize, 0xc7b0 );
}
TEST( Allocate_Everything , MemoryShakeOut )
{
io::create("Hector Medina", "Test2.txt");
fprintf(io::getHandle(),"Test2: \n\n");
fprintf(io::getHandle(),"1) allocate the biggest block \n");
fprintf(io::getHandle()," memSystem mem; \n");
fprintf(io::getHandle()," mem.InitializeSystem(); \n");
fprintf(io::getHandle()," void *p = mem.Malloc( 0xc7b0 ); \n");
fprintf(io::getHandle()," mem.dump(); \n");
memSystem mem;
mem.InitializeSystem();
void *p = mem.Malloc( 0xc7b0 );
mem.dump();
p; // to shut up warnings
io::destroy();
// ---- GENERAL CHECK ------------------------------------------------------
heapHdr *h = mem.getHeap();
// Sanit check, make sure everything is heap relative for testing
CHECK_EQUAL( PTR_FIX(h), 0 );
// Heap Start / Heap Bottom
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), HEAP_SIZE );
// Used / Free
CHECK_EQUAL( PTR_FIX(h->freeHead), 0 );
CHECK_EQUAL( PTR_FIX(h->usedHead), 0x40);
// ---- Heap Stats ------------------------------------------------------
CHECK_EQUAL( h->stats.peakNumUsed, 1 );
CHECK_EQUAL( h->stats.peakUsedMemory, 0xc7b0 );
CHECK_EQUAL( h->stats.currNumUsedBlocks, 1 );
CHECK_EQUAL( h->stats.currUsedMem, 0xc7b0 );
CHECK_EQUAL( h->stats.currNumFreeBlocks, 0 );
CHECK_EQUAL( h->stats.currFreeMem, 0x0 );
CHECK_EQUAL( h->stats.sizeHeap, 0xc800 );
CHECK_EQUAL( h->stats.sizeHeapHeader, 0x40 );
CHECK_EQUAL( PTR_FIX( h->stats.heapTopAddr), 0x40 );
CHECK_EQUAL( PTR_FIX(h->stats.heapBottomAddr), 0xc800 );
// ---- Heap Walk ------------------------------------------------------
// ---- Heap Hdr -------------------------------------------------------
// HeapHdr Start
CHECK_EQUAL( PTR_FIX( (memU32)h->stats.heapTopAddr-sizeof(heapHdr) ), 0 );
// HeapHdr End
CHECK_EQUAL( PTR_FIX(h->stats.heapTopAddr), h->stats.sizeHeapHeader );
// HeapHdr Size
CHECK_EQUAL( h->stats.sizeHeapHeader, sizeof(heapHdr) );
// ---- Block walk ------------------------------------------------------
memU32 hdrStart;
memU32 hdrEnd;
memU32 blkStart;
memU32 blkEnd;
// ---- HDR -------------------------------------------
// Check type
usedHdr *used = (usedHdr *) h->stats.heapTopAddr;
// Should be USED
CHECK_EQUAL( (int)used->blockType, 0xAA );
hdrStart = (memU32)used;
hdrEnd = (memU32)used + sizeof(usedHdr);
// Hdr Start
CHECK_EQUAL( PTR_FIX(hdrStart), 0x40 );
// Hdr End
CHECK_EQUAL( PTR_FIX(hdrEnd), 0x50 );
// Prev
CHECK_EQUAL( PTR_FIX(used->usedPrev), 0 );
// Next
CHECK_EQUAL( PTR_FIX(used->usedNext), 0 );
// Hdr Size
CHECK_EQUAL( hdrEnd - hdrStart, sizeof(usedHdr) );
// ---- BLOCK ----------------------------------------------------
blkStart = hdrEnd;
blkEnd = blkStart + used->blockSize;
CHECK_EQUAL( PTR_FIX(blkStart), PTR_FIX(hdrEnd) );
CHECK_EQUAL( PTR_FIX(blkEnd), 0xc800);
CHECK_EQUAL( used->blockSize, 0xc7b0 );
}
