1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\buffer\t_bma.cpp

    15 // Overview:

    16 // Test the bitmap allocation abilities of the CBitMapAllocator class.

    17 // API Information:

    18 // CBitMapAllocator.

    19 // Details:

    20 // - Create an instance of CBitMapAllocator class with positive size using New and NewL methods, 

    21 // verify that object is created and deleted successfully, test the heap allocation failure. 

    22 // - Verify that the heap has not been corrupted by the test.

    23 // - Test Alloc, AllocFromTop, AllocAt, Free, and AllocFromTopFrom methods of 

    24 // CBitMapAllocator class are as expected.

    25 // - Allocate all available memory using Alloc, AllocFromTop, AllocFromTopFrom

    26 // and check that available free space is zero.

    27 // - Allocate more than available memory using Alloc, AllocFromTop,

    28 // AllocFromTopFrom and check the return value is KErrorNoMemory.

    29 // - Free the memory and check that available free space is equal to the size.

    30 // - Allocate at specified blocks, check the allocation and available free block 

    31 // is as expected.

    32 // - Free the block and check the available space is as expected. 

    33 // - Check the alignment of blocks after allocation is as expected.

    34 // - Perform all of the above tests for CBitMapAllocator size of 1, 4, 32, 33, 68, 96, 64, 65 and 63 bits.

    35 // - Allocate some contiguous pages of RAM from the kernel's free page pool with pattern of 

    36 // increasingly large gaps and test that the pages are allocated as specified.

    37 // - Check KErrorNoMemory is returned when extracting a page beyond the available space.

    38 // - Perform a test specifically for defect EXT-5AMDKP, Alloc, Free and ExtractRamPages. Test for 

    39 // expected results.

    40 // - Test whether the heap has been corrupted by any of the tests.

    41 // Platforms/Drives/Compatibility:

    42 // All 

    43 // Assumptions/Requirement/Pre-requisites:

    44 // Failures and causes:

    45 // Base Port information:

    46 // 

    47 //

    48 

    49 #include <e32test.h>

    50 #include <e32base.h>

    51 #include <e32base_private.h>

    52 #include <e32def.h>

    53 #include <e32def_private.h>

    54 

    55 const TInt KMaxAllocations=50;

    56 

    57 LOCAL_D RTest test(_L("T_BMA"));

    58 

    59 LOCAL_C void testNew(TInt aSize)

    60 //

    61 //	Test New

    62 //

    63 	{

    64 

    65 	test.Start(_L("New"));

    66 	__UHEAP_MARK;

    67 	CBitMapAllocator* pBitMapAllocator=CBitMapAllocator::New(aSize);

    68 	test(pBitMapAllocator!=NULL);

    69 	test(pBitMapAllocator->Size()==pBitMapAllocator->Avail());

    70 	delete pBitMapAllocator;

    71 	__UHEAP_CHECK(0);

    72 	for (TInt i=1;i<KMaxAllocations;i++)

    73 		{

    74 		test.Printf(_L("Try %d\n"),i);

    75 		__UHEAP_SETFAIL(RHeap::EDeterministic,i);

    76 		pBitMapAllocator=CBitMapAllocator::New(aSize);

    77 		if (pBitMapAllocator!=NULL)

    78 			break;

    79 		__UHEAP_CHECK(0);

    80 		}

    81 	delete pBitMapAllocator;

    82 	__UHEAP_MARKEND;

    83 	__UHEAP_RESET;

    84 	test.End();

    85 	}

    86 

    87 LOCAL_C void testNewL(TInt aSize)

    88 //

    89 //	Test NewL

    90 //

    91 	{

    92 

    93 	test.Start(_L("NewL"));

    94 	__UHEAP_MARK;

    95 	CBitMapAllocator* pBitMapAllocator=CBitMapAllocator::NewL(aSize);

    96 	test(pBitMapAllocator!=NULL);

    97 	test(pBitMapAllocator->Size()==pBitMapAllocator->Avail());

    98 	delete pBitMapAllocator;

    99 	__UHEAP_CHECK(0);

   100 	test.Next(_L("Repetitive NewL"));

   101 	for (TInt i=1;i<KMaxAllocations;i++)

   102 		{

   103 		test.Printf(_L("Try %d\n"),i);

   104 		__UHEAP_SETFAIL(RHeap::EDeterministic,i);

   105 		TRAPD(r,pBitMapAllocator=CBitMapAllocator::NewL(aSize));

   106 		if (r==KErrNone)

   107 			break;

   108 		__UHEAP_CHECK(0);

   109 		}

   110 	delete pBitMapAllocator;

   111 	__UHEAP_MARKEND;

   112 	__UHEAP_RESET;

   113   	test.End();	

   114 	}

   115 

   116 LOCAL_C void testAlloc(TInt aSize)

   117 //

   118 //	Test Alloc, AllocFromTop, AllocAt, and Free, and AllocFromTopFrom

   119 //

   120 	{

   121 

   122 	CBitMapAllocator* pBitMapAllocator=CBitMapAllocator::New(aSize);

   123 	test(pBitMapAllocator!=NULL);

   124 	test.Start(_L("Alloc all available"));

   125 	TInt available=pBitMapAllocator->Avail();

   126 	TInt i=0;

   127 	for (;i<available;i++)

   128 		{

   129 		TInt j=pBitMapAllocator->Alloc();

   130 		test(j==i);

   131 		}

   132 	test(pBitMapAllocator->Avail()==0);

   133 //

   134 	test.Next(_L("Try to alloc more than available"));

   135 	i=pBitMapAllocator->Alloc();

   136 	test(i==KErrNoMemory);

   137 //

   138 	test.Next(_L("Free"));

   139 	for (i=0;i<available;i++)

   140 		pBitMapAllocator->Free(i);

   141 	test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());

   142 //

   143 	test.Next(_L("AllocFromTop"));	

   144 	for (i=available-1;i>=0;i--)

   145 		{

   146 		TInt j=pBitMapAllocator->AllocFromTop();

   147 		test(j==i);

   148 		}

   149 	test(pBitMapAllocator->Avail()==0);

   150 //

   151 	test.Next(_L("Try to AllocFromTop more than available"));

   152 	i=pBitMapAllocator->AllocFromTop();

   153 	test(i==KErrNoMemory);

   154 //

   155 	test.Next(_L("Free (again)"));

   156 	for (i=0;i<available;i++)

   157 		pBitMapAllocator->Free(i);

   158 	test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());

   159 //

   160 	test.Next(_L("AllocAt"));

   161 	pBitMapAllocator->AllocAt(aSize-1);

   162 	test(pBitMapAllocator->Avail()==pBitMapAllocator->Size()-1);

   163 //

   164 //	test.Next(_L("AllocAt an already allocated cell"));	// this test should cause a Panic.

   165 //	pBitMapAllocator->AllocAt(aSize-1);

   166 //	test(pBitMapAllocator->Avail()==pBitMapAllocator->Size()-1);

   167 //

   168 	test.Next(_L("Free (again)"));

   169 	pBitMapAllocator->Free(aSize-1);

   170 	test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());

   171 //

   172 	test.Next(_L("AllocFromTopFrom"));

   173 	TInt x;

   174 	for (x=available-1;x>0;x--)

   175 		{

   176 		for (i=x;i>=0;i--)

   177 			{

   178 			TInt j=pBitMapAllocator->AllocFromTopFrom(x);

   179 			test(j==i);

   180 			test(!pBitMapAllocator->IsFree(j));

   181 			}

   182 		test(pBitMapAllocator->Avail()==available-x-1);

   183 

   184 		test.Next(_L("Try to AllocFromTopFrom more than available"));

   185 		i=pBitMapAllocator->AllocFromTopFrom(x);

   186 		test(i==KErrNoMemory);

   187 //

   188 		TInt y;

   189 		for (y=0;y<=x;y++)

   190 			{

   191 			for (i=0;i<=x;i++)

   192 				{

   193 				if (pBitMapAllocator->Avail()<=available-x-1)

   194 					pBitMapAllocator->Free(y);

   195 				TInt j=pBitMapAllocator->AllocFromTopFrom(i);

   196 				if (i<y)

   197 					test(j==KErrNoMemory);

   198 				else

   199 					{

   200 					test(j==y);

   201 					test(!pBitMapAllocator->IsFree(j));

   202 					}

   203 				}

   204 			}

   205 	

   206 //

   207 		test.Next(_L("Free (again)"));

   208 		for (i=0;i<=x;i++)

   209 			pBitMapAllocator->Free(i);

   210 		test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());

   211 		}

   212 //

   213 	for (x=available-1;x>0;x--)

   214 		{

   215 		for (i=x;i>=0;i--)

   216 			{

   217 			TInt j=pBitMapAllocator->AllocFromTopFrom(x);

   218 			test(j==i);

   219 			}

   220 		test(pBitMapAllocator->Avail()==available-x-1);

   221 

   222 		test.Next(_L("Try to AllocFromTopFrom more than available"));

   223 		i=pBitMapAllocator->AllocFromTopFrom(x);

   224 		test(i==KErrNoMemory);

   225 	//

   226 		test.Next(_L("Free (again)"));

   227 		for (i=0;i<=x;i++)

   228 			pBitMapAllocator->Free(i);

   229 		test(pBitMapAllocator->Avail()==pBitMapAllocator->Size());

   230 		}

   231 	test.End();

   232 	delete pBitMapAllocator;

   233 	}

   234 

   235 LOCAL_C void testBlock(TInt aSize)

   236 //

   237 // Test Alloc(TInt, TInt&), AllocAligned, AllocAlignedBlock, AllocAt(TInt, TInt),

   238 // IsFree(TInt, TInt), Free(TInt, TInt)

   239 //

   240 	{

   241 	CBitMapAllocator* pB=CBitMapAllocator::New(aSize);

   242 	test(pB!=NULL);

   243 	test.Start(_L("AllocAt block, Free block, IsFree block"));

   244 	TInt available=pB->Avail();

   245 	test(available==aSize);

   246 	TInt start, len;

   247 	for(start=0; start<available; start++)

   248 		{

   249 		for(len=1; len<=available-start; len++)

   250 			{

   251 			pB->AllocAt(start,len);

   252 			test(pB->Avail()==available-len);

   253 			for(TInt i=0; i<available; i++)

   254 				{

   255 				if (i>=start && i<start+len)

   256 					{

   257 					if(pB->IsFree(i))

   258 						test(0);

   259 					}

   260 				else

   261 					{

   262 					if(!pB->IsFree(i))

   263 						test(0);

   264 					}

   265 				}

   266 			if (start)

   267 				test(pB->IsFree(0,start));

   268 			test(!pB->IsFree(0,start+1));

   269 			if (start+len<available)

   270 				{

   271 				test(pB->IsFree(start+len,available-(start+len)));

   272 				test(!pB->IsFree(start+len-1,available-(start+len-1)));

   273 				}

   274 			pB->Free(start,len);

   275 			test(pB->Avail()==available);

   276 			test(pB->IsFree(start,len));

   277 			test(pB->IsFree(0,available));

   278 			}

   279 		}

   280 	test.End();

   281 	test.Start(_L("Alloc consecutive block"));

   282 	TInt askfor, init, pos, consec;

   283 	for(askfor=1; askfor<=available; askfor++)

   284 		{

   285 		test.Printf(_L("Ask for %d\n"),askfor);

   286 		for(init=0; init<available; init++)

   287 			{

   288 			if (init)

   289 				pB->AllocAt(0,init);

   290 			for(pos=init+1; pos<available; pos++)

   291 				{

   292 				pB->AllocAt(pos);

   293 				TInt firstfree=pB->Alloc(askfor, consec);

   294 				if (firstfree!=init)

   295 					test(0);

   296 				TInt number=(pos-init>askfor)?askfor:pos-init;

   297 				if (consec!=number)

   298 					test(0);

   299 				if (number<pos-init)

   300 					{

   301 					firstfree=pB->Alloc(pos-init-number,consec);

   302 					if(firstfree!=init+number)

   303 						test(0);

   304 					if(consec!=pos-init-number)

   305 						test(0);

   306 					}

   307 				test(pB->Avail()==available-pos-1);

   308 				TInt freeto=available;

   309 				if (pos<available-1)

   310 					{

   311 					firstfree=pB->Alloc(askfor,consec);

   312 					number=(available-pos-1>askfor)?askfor:available-pos-1;

   313 					if (firstfree!=pos+1)

   314 						test(0);

   315 					if (consec!=number)

   316 						test(0);

   317 					freeto=pos+1+number;

   318 					}

   319 				test(pB->Avail()==available-freeto);

   320 				if (available==freeto)

   321 					{

   322 					firstfree=pB->Alloc(1,consec);

   323 					if (firstfree!=KErrNoMemory)

   324 						test(0);

   325 					if (consec!=0)

   326 						test(0);

   327 					}

   328 				pB->Free(init,freeto-init);

   329 				}

   330 			if (init)

   331 				pB->Free(0,init);

   332 			test(pB->Avail()==available);

   333 			}

   334 		}

   335 	test.End();

   336 	test.Start(_L("AllocAligned"));

   337 	TInt alignment, alignstep;

   338 	for(alignment=0, alignstep=1; alignstep<available; alignment++, alignstep<<=1 )

   339 		{

   340 		TInt numaligned=(available+alignstep-1)/alignstep;

   341 		TInt next=0;

   342 		TInt r;

   343 		do	{

   344 			r=pB->AllocAligned(alignment);

   345 			if (r>=0)

   346 				{

   347 				if (r!=next)

   348 					test(0);

   349 				next+=alignstep;

   350 				}

   351 			else if (r!=KErrNoMemory)

   352 				test(0);

   353 			} while(r>=0);

   354 		if (pB->Avail()!=available-numaligned)

   355 			test(0);

   356 		for(TInt i=0; i<available; i++)

   357 			{

   358 			if (i==((i>>alignment)<<alignment) )

   359 				{

   360 				if (pB->IsFree(i))

   361 					test(0);

   362 				pB->Free(i);

   363 				}

   364 			else

   365 				{

   366 				if (!pB->IsFree(i))

   367 					test(0);

   368 				}

   369 			}

   370 		test(pB->Avail()==available);

   371 		}

   372 	test.End();

   373 	test.Start(_L("AllocAlignedBlock"));

   374 	for(alignment=0, alignstep=1; alignstep<available; alignment++, alignstep<<=1 )

   375 		{

   376 		TInt numalignedblocks=available/alignstep;

   377 		TInt next=0;

   378 		TInt r;

   379 		do	{

   380 			r=pB->AllocAlignedBlock(alignment);

   381 			if (r>=0)

   382 				{

   383 				if (r!=next)

   384 					test(0);

   385 				next+=alignstep;

   386 				}

   387 			else if (r!=KErrNoMemory)

   388 				test(0);

   389 			} while(r>=0);

   390 		if (pB->Avail()!=available-numalignedblocks*alignstep)

   391 			test(0);

   392 		if (pB->Avail()!=0)

   393 			{

   394 			if ( !pB->IsFree(numalignedblocks*alignstep,pB->Avail()) )

   395 				test(0);

   396 			r=pB->Alloc();

   397 			if (r!=numalignedblocks*alignstep)

   398 				test(0);

   399 			pB->Free(r);

   400 			}

   401 		pB->Free(0,numalignedblocks*alignstep);

   402 		if (pB->Avail()!=available)

   403 			test(0);

   404 		TInt freepos, blockpos, c;

   405 		for (freepos=0; freepos<available; freepos+=alignstep)

   406 			{

   407 			for (blockpos=0; blockpos<alignstep; blockpos++)

   408 				{

   409 				c=0;

   410 				for(TInt i=blockpos; i<freepos; i+=alignstep)

   411 					{

   412 					pB->AllocAt(i);

   413 					c++;

   414 					}

   415 				if (pB->Avail()!=available-c)

   416 					test(0);

   417 				r=pB->AllocAlignedBlock(alignment);

   418 				if (available-freepos<alignstep)

   419 					{

   420 					if (r!=KErrNoMemory)

   421 						test(0);

   422 					if (pB->Avail()!=available-c)

   423 						test(0);

   424 					}

   425 				else

   426 					{

   427 					if (r!=freepos)

   428 						test(0);

   429 					if (pB->Avail()!=available-c-alignstep)

   430 						test(0);

   431 					pB->Free(freepos,alignstep);

   432 					if (pB->Avail()!=available-c)

   433 						test(0);

   434 					}

   435 				for(TInt j=blockpos; j<freepos; j+=alignstep)

   436 					pB->Free(j);

   437 				if (pB->Avail()!=available)

   438 					test(0);

   439 				}

   440 			}

   441 		}

   442 	delete pB;

   443 	test.End();

   444 	}

   445 

   446 LOCAL_C void testContiguousAllocation(TInt aSize)

   447 	{//test RemoveRamPages()

   448 	//set up bitmap with pattern of increasingly large gaps -

   449 	//page 1      - in use,page  2        - free

   450 	//pages 3,4   - in use,pages 5,6      - free

   451 	//pages 7,8,9 - in use,pages 10,11,12 - free  ...etc

   452 	test.Start(_L("Create swiss cheese effect..."));

   453 

   454  	CBitMapAllocator* pB=CBitMapAllocator::New(aSize);

   455 	test(pB!=NULL);

   456 

   457 	TInt available=pB->Avail();

   458 	test(available==aSize);

   459 

   460 	TInt i=0;

   461 	TInt j=0;

   462 	TInt k=1;

   463 	while(k<46)

   464 		{

   465 		for(j=0;j<k;j++)

   466 			{

   467 			pB->AllocAt(i+j);

   468 			test(!pB->IsFree(i+j));

   469 			}

   470 		i+=2*k;

   471 		k++;

   472 		}

   473 

   474 	TInt ret=KErrNone;

   475 	TInt pageNo=0;

   476 	for(i=1;i<45;i++)

   477 		{

   478 		ret=pB->ExtractRamPages(i,pageNo);	//look for a gap of size i pages and allocate it

   479 		test(pageNo==i*i);				//test the right page no is returned

   480 		test.Printf(_L("OK  -pageNo is :%d\r\n"),pageNo);

   481 		for(j=i*i;j<i*i + i;j++)		//test that the pages are actually allocated

   482 			test(!pB->IsFree(j));

   483 		}

   484 

   485 	ret=pB->ExtractRamPages(45,pageNo);//there's not a big enough space in the bitmap for this to succeed

   486 	test(ret==KErrNoMemory);

   487 	delete pB;

   488 	test.End();

   489 	}

   490 

   491 LOCAL_C void testAll(TInt aSize)

   492 //

   493 //	Test all BMA functions using a BMA of size aSize

   494 //

   495 	{

   496 

   497 	TBuf<0x40> b;

   498 	b.Format(_L("BitMapAllocator size = %d"),aSize);

   499 	test.Start(b);

   500 //

   501 	testNew(aSize);

   502 	testNewL(aSize);

   503 	testAlloc(aSize);

   504 	testBlock(aSize);

   505 //

   506 	test.End();

   507 	}

   508 

   509 GLDEF_C TInt E32Main()

   510 //

   511 // Test bitmap allocator

   512 //

   513 	{

   514 	test.Title();

   515 	__UHEAP_MARK;

   516 //

   517 	test.Start(_L("1 bit"));

   518 	testAll(1);

   519 

   520 	test.Next(_L("4 bit"));

   521 	testAll(4);

   522 //

   523 	test.Next(_L("32 bit"));

   524 	testAll(32);

   525 //

   526 	test.Next(_L("33 bit"));

   527 	testAll(33);

   528 //

   529 	test.Next(_L("68 bit"));

   530 	testAll(68);

   531 //

   532 	test.Next(_L("96 bit"));

   533 	testAll(96);

   534 //

   535 	test.Next(_L("64 bit"));

   536 	testAll(64);

   537 //

   538 	test.Next(_L("65 bit"));

   539 	testAll(65);

   540 //

   541 	test.Next(_L("63 bit"));

   542 	testAll(63);

   543 

   544 	testContiguousAllocation(2048);

   545 

   546 	test.Next(_L("test defect EXT-5AMDKP"));

   547 

   548 	CBitMapAllocator* pB = CBitMapAllocator::New(64);

   549 	test(pB != NULL);

   550 	pB->AllocAt(0, 32);

   551 	pB->Free(2, 2);

   552 	pB->Free(5, 2);

   553 	pB->Free(8, 2);

   554 	pB->Free(12, 3);

   555 	pB->Free(30, 2);

   556 	TInt page = -1;

   557 	pB->ExtractRamPages(3, page);

   558 	test(page == 12);

   559 	pB->ExtractRamPages(4, page);

   560 	test(page == 30);

   561 	pB->ExtractRamPages(1, page);

   562 	test(page == 2);

   563 	pB->ExtractRamPages(5, page);

   564 	test(page == 34);

   565 	pB->ExtractRamPages(2, page);

   566 	test(page == 5);

   567 	delete pB;	

   568 		

   569 	__UHEAP_MARKEND;

   570 	test.End();

   571 	return(KErrNone);

   572 	}

   573