--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/buffer/t_bma.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,573 @@
+// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\buffer\t_bma.cpp
+// Overview:
+// Test the bitmap allocation abilities of the CBitMapAllocator class.
+// API Information:
+// CBitMapAllocator.
+// Details:
+// - Create an instance of CBitMapAllocator class with positive size using New and NewL methods,
+// verify that object is created and deleted successfully, test the heap allocation failure.
+// - Verify that the heap has not been corrupted by the test.
+// - Test Alloc, AllocFromTop, AllocAt, Free, and AllocFromTopFrom methods of
+// CBitMapAllocator class are as expected.
+// - Allocate all available memory using Alloc, AllocFromTop, AllocFromTopFrom
+// and check that available free space is zero.
+// - Allocate more than available memory using Alloc, AllocFromTop,
+// AllocFromTopFrom and check the return value is KErrorNoMemory.
+// - Free the memory and check that available free space is equal to the size.
+// - Allocate at specified blocks, check the allocation and available free block
+// is as expected.
+// - Free the block and check the available space is as expected.
+// - Check the alignment of blocks after allocation is as expected.
+// - Perform all of the above tests for CBitMapAllocator size of 1, 4, 32, 33, 68, 96, 64, 65 and 63 bits.
+// - Allocate some contiguous pages of RAM from the kernel's free page pool with pattern of
+// increasingly large gaps and test that the pages are allocated as specified.
+// - Check KErrorNoMemory is returned when extracting a page beyond the available space.
+// - Perform a test specifically for defect EXT-5AMDKP, Alloc, Free and ExtractRamPages. Test for
+// expected results.
+// - Test whether the heap has been corrupted by any of the tests.
+// Platforms/Drives/Compatibility:
+// All
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+//
+//
+
+#include <e32test.h>
+#include <e32base.h>
+#include <e32base_private.h>
+#include <e32def.h>
+#include <e32def_private.h>
+
+const TInt KMaxAllocations=50;
+
+LOCAL_D RTest test(_L("T_BMA"));
+
+LOCAL_C void testNew(TInt aSize)
+//
+// Test New
+//
+ {
+
+ test.Start(_L("New"));
+ __UHEAP_MARK;
+ CBitMapAllocator* pBitMapAllocator=CBitMapAllocator::New(aSize);
+ test(pBitMapAllocator!=NULL);
+ test(pBitMapAllocator->Size()==pBitMapAllocator->Avail());
+ delete pBitMapAllocator;
+ __UHEAP_CHECK(0);
+ for (TInt i=1;i<KMaxAllocations;i++)
+ {
+ test.Printf(_L("Try %d\n"),i);
+ __UHEAP_SETFAIL(RHeap::EDeterministic,i);
+ pBitMapAllocator=CBitMapAllocator::New(aSize);
+ if (pBitMapAllocator!=NULL)
+ break;
+ __UHEAP_CHECK(0);
+ }
+ delete pBitMapAllocator;
+ __UHEAP_MARKEND;
+ __UHEAP_RESET;
+ test.End();
+ }
+
+LOCAL_C void testNewL(TInt aSize)
+//
+// Test NewL
+//
+ {
+
+ test.Start(_L("NewL"));
+ __UHEAP_MARK;
+ CBitMapAllocator* pBitMapAllocator=CBitMapAllocator::NewL(aSize);
+ test(pBitMapAllocator!=NULL);
+ test(pBitMapAllocator->Size()==pBitMapAllocator->Avail());
+ delete pBitMapAllocator;
+ __UHEAP_CHECK(0);
+ test.Next(_L("Repetitive NewL"));
+ for (TInt i=1;i<KMaxAllocations;i++)
+ {
+ test.Printf(_L("Try %d\n"),i);
+ __UHEAP_SETFAIL(RHeap::EDeterministic,i);
+ TRAPD(r,pBitMapAllocator=CBitMapAllocator::NewL(aSize));
+ if (r==KErrNone)
+ break;
+ __UHEAP_CHECK(0);
+ }
+ delete pBitMapAllocator;
+ __UHEAP_MARKEND;
+ __UHEAP_RESET;
+ test.End();
+ }
+
+LOCAL_C void testAlloc(TInt aSize)
+//
+// Test Alloc, AllocFromTop, AllocAt, and Free, and AllocFromTopFrom
+//
+ {
+
+ CBitMapAllocator* pBitMapAllocator=CBitMapAllocator::New(aSize);
+ test(pBitMapAllocator!=NULL);
+ test.Start(_L("Alloc all available"));
+ TInt available=pBitMapAllocator->Avail();
+ TInt i=0;
+ for (;i<available;i++)
+ {
+ TInt j=pBitMapAllocator->Alloc();
+ test(j==i);
+ }
+ test(pBitMapAllocator->Avail()==0);
+//
+ test.Next(_L("Try to alloc more than available"));
+ i=pBitMapAllocator->Alloc();
+ test(i==KErrNoMemory);
+//
+ test.Next(_L("Free"));
+ for (i=0;i<available;i++)
+ pBitMapAllocator->Free(i);
+ test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());
+//
+ test.Next(_L("AllocFromTop"));
+ for (i=available-1;i>=0;i--)
+ {
+ TInt j=pBitMapAllocator->AllocFromTop();
+ test(j==i);
+ }
+ test(pBitMapAllocator->Avail()==0);
+//
+ test.Next(_L("Try to AllocFromTop more than available"));
+ i=pBitMapAllocator->AllocFromTop();
+ test(i==KErrNoMemory);
+//
+ test.Next(_L("Free (again)"));
+ for (i=0;i<available;i++)
+ pBitMapAllocator->Free(i);
+ test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());
+//
+ test.Next(_L("AllocAt"));
+ pBitMapAllocator->AllocAt(aSize-1);
+ test(pBitMapAllocator->Avail()==pBitMapAllocator->Size()-1);
+//
+// test.Next(_L("AllocAt an already allocated cell")); // this test should cause a Panic.
+// pBitMapAllocator->AllocAt(aSize-1);
+// test(pBitMapAllocator->Avail()==pBitMapAllocator->Size()-1);
+//
+ test.Next(_L("Free (again)"));
+ pBitMapAllocator->Free(aSize-1);
+ test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());
+//
+ test.Next(_L("AllocFromTopFrom"));
+ TInt x;
+ for (x=available-1;x>0;x--)
+ {
+ for (i=x;i>=0;i--)
+ {
+ TInt j=pBitMapAllocator->AllocFromTopFrom(x);
+ test(j==i);
+ test(!pBitMapAllocator->IsFree(j));
+ }
+ test(pBitMapAllocator->Avail()==available-x-1);
+
+ test.Next(_L("Try to AllocFromTopFrom more than available"));
+ i=pBitMapAllocator->AllocFromTopFrom(x);
+ test(i==KErrNoMemory);
+//
+ TInt y;
+ for (y=0;y<=x;y++)
+ {
+ for (i=0;i<=x;i++)
+ {
+ if (pBitMapAllocator->Avail()<=available-x-1)
+ pBitMapAllocator->Free(y);
+ TInt j=pBitMapAllocator->AllocFromTopFrom(i);
+ if (i<y)
+ test(j==KErrNoMemory);
+ else
+ {
+ test(j==y);
+ test(!pBitMapAllocator->IsFree(j));
+ }
+ }
+ }
+
+//
+ test.Next(_L("Free (again)"));
+ for (i=0;i<=x;i++)
+ pBitMapAllocator->Free(i);
+ test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());
+ }
+//
+ for (x=available-1;x>0;x--)
+ {
+ for (i=x;i>=0;i--)
+ {
+ TInt j=pBitMapAllocator->AllocFromTopFrom(x);
+ test(j==i);
+ }
+ test(pBitMapAllocator->Avail()==available-x-1);
+
+ test.Next(_L("Try to AllocFromTopFrom more than available"));
+ i=pBitMapAllocator->AllocFromTopFrom(x);
+ test(i==KErrNoMemory);
+ //
+ test.Next(_L("Free (again)"));
+ for (i=0;i<=x;i++)
+ pBitMapAllocator->Free(i);
+ test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());
+ }
+ test.End();
+ delete pBitMapAllocator;
+ }
+
+LOCAL_C void testBlock(TInt aSize)
+//
+// Test Alloc(TInt, TInt&), AllocAligned, AllocAlignedBlock, AllocAt(TInt, TInt),
+// IsFree(TInt, TInt), Free(TInt, TInt)
+//
+ {
+ CBitMapAllocator* pB=CBitMapAllocator::New(aSize);
+ test(pB!=NULL);
+ test.Start(_L("AllocAt block, Free block, IsFree block"));
+ TInt available=pB->Avail();
+ test(available==aSize);
+ TInt start, len;
+ for(start=0; start<available; start++)
+ {
+ for(len=1; len<=available-start; len++)
+ {
+ pB->AllocAt(start,len);
+ test(pB->Avail()==available-len);
+ for(TInt i=0; i<available; i++)
+ {
+ if (i>=start && i<start+len)
+ {
+ if(pB->IsFree(i))
+ test(0);
+ }
+ else
+ {
+ if(!pB->IsFree(i))
+ test(0);
+ }
+ }
+ if (start)
+ test(pB->IsFree(0,start));
+ test(!pB->IsFree(0,start+1));
+ if (start+len<available)
+ {
+ test(pB->IsFree(start+len,available-(start+len)));
+ test(!pB->IsFree(start+len-1,available-(start+len-1)));
+ }
+ pB->Free(start,len);
+ test(pB->Avail()==available);
+ test(pB->IsFree(start,len));
+ test(pB->IsFree(0,available));
+ }
+ }
+ test.End();
+ test.Start(_L("Alloc consecutive block"));
+ TInt askfor, init, pos, consec;
+ for(askfor=1; askfor<=available; askfor++)
+ {
+ test.Printf(_L("Ask for %d\n"),askfor);
+ for(init=0; init<available; init++)
+ {
+ if (init)
+ pB->AllocAt(0,init);
+ for(pos=init+1; pos<available; pos++)
+ {
+ pB->AllocAt(pos);
+ TInt firstfree=pB->Alloc(askfor, consec);
+ if (firstfree!=init)
+ test(0);
+ TInt number=(pos-init>askfor)?askfor:pos-init;
+ if (consec!=number)
+ test(0);
+ if (number<pos-init)
+ {
+ firstfree=pB->Alloc(pos-init-number,consec);
+ if(firstfree!=init+number)
+ test(0);
+ if(consec!=pos-init-number)
+ test(0);
+ }
+ test(pB->Avail()==available-pos-1);
+ TInt freeto=available;
+ if (pos<available-1)
+ {
+ firstfree=pB->Alloc(askfor,consec);
+ number=(available-pos-1>askfor)?askfor:available-pos-1;
+ if (firstfree!=pos+1)
+ test(0);
+ if (consec!=number)
+ test(0);
+ freeto=pos+1+number;
+ }
+ test(pB->Avail()==available-freeto);
+ if (available==freeto)
+ {
+ firstfree=pB->Alloc(1,consec);
+ if (firstfree!=KErrNoMemory)
+ test(0);
+ if (consec!=0)
+ test(0);
+ }
+ pB->Free(init,freeto-init);
+ }
+ if (init)
+ pB->Free(0,init);
+ test(pB->Avail()==available);
+ }
+ }
+ test.End();
+ test.Start(_L("AllocAligned"));
+ TInt alignment, alignstep;
+ for(alignment=0, alignstep=1; alignstep<available; alignment++, alignstep<<=1 )
+ {
+ TInt numaligned=(available+alignstep-1)/alignstep;
+ TInt next=0;
+ TInt r;
+ do {
+ r=pB->AllocAligned(alignment);
+ if (r>=0)
+ {
+ if (r!=next)
+ test(0);
+ next+=alignstep;
+ }
+ else if (r!=KErrNoMemory)
+ test(0);
+ } while(r>=0);
+ if (pB->Avail()!=available-numaligned)
+ test(0);
+ for(TInt i=0; i<available; i++)
+ {
+ if (i==((i>>alignment)<<alignment) )
+ {
+ if (pB->IsFree(i))
+ test(0);
+ pB->Free(i);
+ }
+ else
+ {
+ if (!pB->IsFree(i))
+ test(0);
+ }
+ }
+ test(pB->Avail()==available);
+ }
+ test.End();
+ test.Start(_L("AllocAlignedBlock"));
+ for(alignment=0, alignstep=1; alignstep<available; alignment++, alignstep<<=1 )
+ {
+ TInt numalignedblocks=available/alignstep;
+ TInt next=0;
+ TInt r;
+ do {
+ r=pB->AllocAlignedBlock(alignment);
+ if (r>=0)
+ {
+ if (r!=next)
+ test(0);
+ next+=alignstep;
+ }
+ else if (r!=KErrNoMemory)
+ test(0);
+ } while(r>=0);
+ if (pB->Avail()!=available-numalignedblocks*alignstep)
+ test(0);
+ if (pB->Avail()!=0)
+ {
+ if ( !pB->IsFree(numalignedblocks*alignstep,pB->Avail()) )
+ test(0);
+ r=pB->Alloc();
+ if (r!=numalignedblocks*alignstep)
+ test(0);
+ pB->Free(r);
+ }
+ pB->Free(0,numalignedblocks*alignstep);
+ if (pB->Avail()!=available)
+ test(0);
+ TInt freepos, blockpos, c;
+ for (freepos=0; freepos<available; freepos+=alignstep)
+ {
+ for (blockpos=0; blockpos<alignstep; blockpos++)
+ {
+ c=0;
+ for(TInt i=blockpos; i<freepos; i+=alignstep)
+ {
+ pB->AllocAt(i);
+ c++;
+ }
+ if (pB->Avail()!=available-c)
+ test(0);
+ r=pB->AllocAlignedBlock(alignment);
+ if (available-freepos<alignstep)
+ {
+ if (r!=KErrNoMemory)
+ test(0);
+ if (pB->Avail()!=available-c)
+ test(0);
+ }
+ else
+ {
+ if (r!=freepos)
+ test(0);
+ if (pB->Avail()!=available-c-alignstep)
+ test(0);
+ pB->Free(freepos,alignstep);
+ if (pB->Avail()!=available-c)
+ test(0);
+ }
+ for(TInt j=blockpos; j<freepos; j+=alignstep)
+ pB->Free(j);
+ if (pB->Avail()!=available)
+ test(0);
+ }
+ }
+ }
+ delete pB;
+ test.End();
+ }
+
+LOCAL_C void testContiguousAllocation(TInt aSize)
+ {//test RemoveRamPages()
+ //set up bitmap with pattern of increasingly large gaps -
+ //page 1 - in use,page 2 - free
+ //pages 3,4 - in use,pages 5,6 - free
+ //pages 7,8,9 - in use,pages 10,11,12 - free ...etc
+ test.Start(_L("Create swiss cheese effect..."));
+
+ CBitMapAllocator* pB=CBitMapAllocator::New(aSize);
+ test(pB!=NULL);
+
+ TInt available=pB->Avail();
+ test(available==aSize);
+
+ TInt i=0;
+ TInt j=0;
+ TInt k=1;
+ while(k<46)
+ {
+ for(j=0;j<k;j++)
+ {
+ pB->AllocAt(i+j);
+ test(!pB->IsFree(i+j));
+ }
+ i+=2*k;
+ k++;
+ }
+
+ TInt ret=KErrNone;
+ TInt pageNo=0;
+ for(i=1;i<45;i++)
+ {
+ ret=pB->ExtractRamPages(i,pageNo); //look for a gap of size i pages and allocate it
+ test(pageNo==i*i); //test the right page no is returned
+ test.Printf(_L("OK -pageNo is :%d\r\n"),pageNo);
+ for(j=i*i;j<i*i + i;j++) //test that the pages are actually allocated
+ test(!pB->IsFree(j));
+ }
+
+ ret=pB->ExtractRamPages(45,pageNo);//there's not a big enough space in the bitmap for this to succeed
+ test(ret==KErrNoMemory);
+ delete pB;
+ test.End();
+ }
+
+LOCAL_C void testAll(TInt aSize)
+//
+// Test all BMA functions using a BMA of size aSize
+//
+ {
+
+ TBuf<0x40> b;
+ b.Format(_L("BitMapAllocator size = %d"),aSize);
+ test.Start(b);
+//
+ testNew(aSize);
+ testNewL(aSize);
+ testAlloc(aSize);
+ testBlock(aSize);
+//
+ test.End();
+ }
+
+GLDEF_C TInt E32Main()
+//
+// Test bitmap allocator
+//
+ {
+ test.Title();
+ __UHEAP_MARK;
+//
+ test.Start(_L("1 bit"));
+ testAll(1);
+
+ test.Next(_L("4 bit"));
+ testAll(4);
+//
+ test.Next(_L("32 bit"));
+ testAll(32);
+//
+ test.Next(_L("33 bit"));
+ testAll(33);
+//
+ test.Next(_L("68 bit"));
+ testAll(68);
+//
+ test.Next(_L("96 bit"));
+ testAll(96);
+//
+ test.Next(_L("64 bit"));
+ testAll(64);
+//
+ test.Next(_L("65 bit"));
+ testAll(65);
+//
+ test.Next(_L("63 bit"));
+ testAll(63);
+
+ testContiguousAllocation(2048);
+
+ test.Next(_L("test defect EXT-5AMDKP"));
+
+ CBitMapAllocator* pB = CBitMapAllocator::New(64);
+ test(pB != NULL);
+ pB->AllocAt(0, 32);
+ pB->Free(2, 2);
+ pB->Free(5, 2);
+ pB->Free(8, 2);
+ pB->Free(12, 3);
+ pB->Free(30, 2);
+ TInt page = -1;
+ pB->ExtractRamPages(3, page);
+ test(page == 12);
+ pB->ExtractRamPages(4, page);
+ test(page == 30);
+ pB->ExtractRamPages(1, page);
+ test(page == 2);
+ pB->ExtractRamPages(5, page);
+ test(page == 34);
+ pB->ExtractRamPages(2, page);
+ test(page == 5);
+ delete pB;
+
+ __UHEAP_MARKEND;
+ test.End();
+ return(KErrNone);
+ }
+