// Copyright (c) 1996-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_func.cpp

 // Overview:

 // Comprehensive test for the ARM coded Mem, Des and integer divide routines. 

 // Check memory for a large variation of buffer sizes and alignments, 

 // check all the optimizations made in the copying/filling code.

 // API Information:

 // Mem::Fill, Mem::Copy, Mem::Move, Mem::Swap, Mem::Compare

 // Details:

 // - Create blocks, fill some data into one block, copy data across block of varying 

 // lengths, alignments and check the copy is as expected.

 // - Create blocks, fill some data into the block, move data from one block to other 

 // block and check it is as expected.

 // - Create blocks, fill some data and check the data is filled as expected.

 // - Create blocks, fill some data in two blocks, swap the blocks check the data

 // is swapped as expected.

 // - Create blocks, fill some data into the blocks, compare the data at different specified

 // offsets, compare the return value, check it is as expected.

 // - Check the conversion from specified integer numbers in different number systems to 

 // character representation is as expected. Check for both upper and lower case results.

 // - Initialize variables with signed, unsigned, positive, negative integer values, check the 

 // integer division routines	are as expected.  

 // - Check the integer modulo operation results are as expected.

 // Platforms/Drives/Compatibility:

 // All 

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32base.h>

 #include <e32base_private.h>

 #include <e32test.h>

 #include <e32svr.h>

 #include <e32panic.h>

 RTest test(_L("T_FUNC"));

 TInt failed;

 void PrintInfo(TText8* aBuf1,TText8* aBuf2)

     {

     if(aBuf1<aBuf2)

         test.Printf(_L("source before target\n"));

     else if(aBuf1==aBuf2)

         test.Printf(_L("source and target identical\n"));

     else

         test.Printf(_L("target before source\n"));      

     }

 void testFailed(const TDesC& anError)

     {

     test.Printf(_L("Test %S failed\n"),&anError);

     //test.Getch();

     failed=KErrGeneral;

     }

 void testMemCopy()

     {

     TText8 bufa[0x200];

     TText8 bufb[0x200];

     TInt ii,jj,kk;

     test.Next(_L("Mem::Copy"));

 //

 // Test various copying lengths and alignments and src before/after trg

 //

     TInt length;

     TChar a55(0x55);

     TChar aAA(0xaa);

     TUint8* addr;

     for(ii=24;ii<496;ii+=19)

         {

         for(jj=24;jj<496;jj+=18)

             {

             length=Min(496-jj,496-ii);

             Mem::Fill(&bufa[0],512,a55);

             Mem::Fill(&bufb[0],512,aAA);

             addr=Mem::Copy(&bufa[ii],&bufb[jj],length);

             if(addr!=(&bufa[ii]+length))

                 {

                 PrintInfo(bufb,bufa);

                 test.Printf(_L("Mem::Copy returned incorrect address for %d bytes\n"),length);

                 failed=KErrGeneral;

                 //test.Getch();

                 return;

                 }

             for(kk=0;kk<512;kk++)

                 {

                 if(kk<ii && bufa[kk]!=0x55)

                     {

                     PrintInfo(bufb,bufa);

                     test.Printf(_L("Mem::Copy failed copying %d bytes from bufb[%d] to bufa[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=ii && kk<(ii+length) && bufa[kk]!=0xaa)

                     {

                     PrintInfo(bufb,bufa);

                     test.Printf(_L("Mem::Copy failed copying %d bytes from bufb[%d] to bufa[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=(ii+length) && bufa[kk]!=0x55)

                     {

                     PrintInfo(bufb,bufa);

                     test.Printf(_L("Mem::Copy failed copying %d bytes from bufb[%d] to bufa[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 }

             Mem::Fill(&bufa[0],512,a55);

             Mem::Fill(&bufb[0],512,aAA);

             length=Min(496-jj,496-ii);

             addr=Mem::Copy(&bufb[ii],&bufa[jj],length);

             if(addr!=(&bufb[ii]+length))

                 {

                 PrintInfo(bufa,bufb);

                 test.Printf(_L("Mem::Copy returned incorrect address for %d bytes\n"),length);

                 failed=KErrGeneral;

                 //test.Getch();

                 return;

                 }

             for(kk=0;kk<512;kk++)

                 {

                 if(kk<ii && bufb[kk]!=0xaa)

                     {

                     PrintInfo(bufa,bufb);

                     test.Printf(_L("Mem::Copy failed copying %d bytes from bufa[%d] to bufb[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=ii && kk<(ii+length) && bufb[kk]!=0x55)

                     {

                     PrintInfo(bufa,bufb);

                     test.Printf(_L("Mem::Copy failed copying %d bytes from bufa[%d] to bufb[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=(ii+length) && bufb[kk]!=0xaa)

                     {

                     PrintInfo(bufa,bufb);

                     test.Printf(_L("Mem::Copy failed copying %d bytes from bufa[%d] to bufb[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 }

             };

         }

     }

 //

 // Assert panic test, debug ARM build only.   See DEF118984.

 //

 #if defined(_DEBUG) && defined(__CPU_ARM)

 const TInt KMemMoveBufferSize=0x20;

 const TInt KMemMoveBadLength=3;

 enum TMemMoveTest

 	{

 	EMemMoveValid=0,

 	EMemMoveSourceNotAligned=1,

 	EMemMoveTargetNotAligned=2,

 	EMemMoveLengthNotMultipleOf4=3,

 	};

 LOCAL_C TInt MemMoveClient(TAny* aPtr)

 	{

 	TMemMoveTest aMode = *(TMemMoveTest *)&aPtr;

 	TText8 srcbuf[KMemMoveBufferSize];

 	TText8 trgbuf[KMemMoveBufferSize];

 	TText8 *src=srcbuf, *trg=trgbuf;

 	TInt length=KMemMoveBufferSize;

 	switch (aMode)

 		{

 	case EMemMoveValid:

 		break;

 	case EMemMoveSourceNotAligned:

 		src=&srcbuf[1];

 		break;

 	case EMemMoveTargetNotAligned:

 		trg=&trgbuf[1];

 		break;

 	case EMemMoveLengthNotMultipleOf4:

 		length=KMemMoveBadLength;

 		break;

 		}

 	Mem::Move(trg,src,length);

 	return KErrNone;

 	}

 #endif //_DEBUG

 void testMemMove()

     {

     TText8 bufa[0x200];

     TText8 bufb[0x200];

     TInt ii,jj,kk;

     test.Next(_L("Mem::Move()"));

 //

 // Test various copying lengths and alignments and src before/after trg

 //

     TInt length;

     TChar a55(0x55);

     TChar aAA(0xaa);

     TUint8* addr;

     for(ii=0;ii<512;ii+=24)

         {

         for(jj=0;jj<512;jj+=24)

             {

             length=Min(512-jj,512-ii);

             Mem::Fill(&bufa[0],512,a55);

             Mem::Fill(&bufb[0],512,aAA);

             addr=Mem::Move(&bufa[ii],&bufb[jj],length);

             if(addr!=(&bufa[ii]+length))

                 {

                 PrintInfo(bufb,bufa);

                 test.Printf(_L("Mem::Copy returned incorrect address for %d bytes\n"),length);

                 failed=KErrGeneral;

                 //test.Getch();

                 return;

                 }

             for(kk=0;kk<512;kk++)

                 {

                 if(kk<ii && bufa[kk]!=0x55)

                     {

                     PrintInfo(bufb,bufa);

                     test.Printf(_L("Mem::Move failed copying %d bytes from bufb[%d] to bufa[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=ii && kk<(ii+length) && bufa[kk]!=0xaa)

                     {

                     PrintInfo(bufb,bufa);

                     test.Printf(_L("Mem::Move failed copying %d bytes from bufb[%d] to bufa[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=(ii+length) && bufa[kk]!=0x55)

                     {

                     PrintInfo(bufb,bufa);

                     test.Printf(_L("Mem::Move failed copying %d bytes from bufb[%d] to bufa[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 }

             Mem::Fill(&bufa[0],512,a55);

             Mem::Fill(&bufb[0],512,aAA);

             length=Min(512-jj,512-ii);

             addr=Mem::Move(&bufb[ii],&bufa[jj],length);

             if(addr!=(&bufb[ii]+length))

                 {

                 PrintInfo(bufa,bufb);

                 test.Printf(_L("Mem::Copy returned incorrect address for %d bytes\n"),length);

                 failed=KErrGeneral;

                 //test.Getch();

                 return;

                 }

             for(kk=0;kk<512;kk++)

                 {

                 if(kk<ii && bufb[kk]!=0xaa)

                     {

                     PrintInfo(bufa,bufb);

                     test.Printf(_L("Mem::Move failed copying %d bytes from bufa[%d] to bufb[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=ii && kk<(ii+length) && bufb[kk]!=0x55)

                     {

                     PrintInfo(bufa,bufb);

                     test.Printf(_L("Mem::Move failed copying %d bytes from bufa[%d] to bufb[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 if(kk>=(ii+length) && bufb[kk]!=0xaa)

                     {

                     PrintInfo(bufa,bufb);

                     test.Printf(_L("Mem::Move failed copying %d bytes from bufa[%d] to bufb[%d] at byte %d\n"),length,jj,ii,kk);

                     failed=KErrGeneral;

                     //test.Getch();

                     return;

                     }

                 }

             };

         }

 #if defined(_DEBUG) && defined(__CPU_ARM)

     //

     // Test wordmove asserts. Source and target addresses are word aligned,

     // and length is a multiple of the word size.

     // Test asserts (debug build only)

     //

     RThread clientThread;

     TRequestStatus status(KRequestPending);

     User::SetJustInTime(EFalse);

     test.Next(_L("Mem::Move() - wordmove() valid call"));

     test(clientThread.Create(_L("MemMovePanic - Valid"),MemMoveClient,KDefaultStackSize,0x2000,0x2000,(TAny*)EMemMoveValid)==KErrNone);

     clientThread.Logon(status);

     clientThread.Resume();

     User::WaitForRequest(status);

     test(clientThread.ExitType()==EExitKill);

     test(clientThread.ExitReason()==KErrNone);

     clientThread.Close();

     status=KRequestPending;

     test.Next(_L("Mem::Move() - wordmove() source alignment"));

     test(clientThread.Create(_L("MemMovePanic - SrcAlign"),MemMoveClient,KDefaultStackSize,0x2000,0x2000,(TAny*)EMemMoveSourceNotAligned)==KErrNone);

     clientThread.Logon(status);

     clientThread.Resume();

     User::WaitForRequest(status);

     test(clientThread.ExitType()==EExitPanic);

     test(clientThread.ExitReason()==EWordMoveSourceNotAligned);

     clientThread.Close();

     status=KRequestPending;

     test.Next(_L("Mem::Move() - wordmove() target alignment"));

     test(clientThread.Create(_L("MemMovePanic - TrgAlign"),MemMoveClient,KDefaultStackSize,0x2000,0x2000,(TAny*)EMemMoveTargetNotAligned)==KErrNone);

     clientThread.Logon(status);

     clientThread.Resume();

     User::WaitForRequest(status);

     test(clientThread.ExitType()==EExitPanic);

     test(clientThread.ExitReason()==EWordMoveTargetNotAligned);

     clientThread.Close();

     status=KRequestPending;

     test.Next(_L("Mem::Move() - wordmove() length word multiple"));

     test(clientThread.Create(_L("MemMovePanic - LengthMultiple"),MemMoveClient,KDefaultStackSize,0x2000,0x2000,(TAny*)EMemMoveLengthNotMultipleOf4)==KErrNone);

     clientThread.Logon(status);

     clientThread.Resume();

     User::WaitForRequest(status);

     test(clientThread.ExitType()==EExitPanic);

     test(clientThread.ExitReason()==EWordMoveLengthNotMultipleOf4);

     clientThread.Close();

     User::SetJustInTime(ETrue);

 #endif //_DEBUG

     }

 void testMemFill()

     {

     TText8 bufa[0x200];

     TInt ii,jj,kk,pos,length;

     test.Next(_L("Mem::Fill()"));

     TChar a55(0x55);

     TChar aAA(0xaa);

     for(ii=0;ii<512-32;ii++)

         {

 		for(jj=0;jj<32;jj++)

 			{

 			Mem::Fill(&bufa[0],512,aAA);

 			pos=ii+jj;

 			length=512-32-ii;

 			Mem::Fill(&bufa[pos],length,a55);

 			for(kk=0;kk<512;kk++)

 				{

 				if(kk<(pos) && bufa[kk]!=0xaa)

 					{

 					test.Printf(_L("Mem::Fill failed filling %d bytes to bufa[%d] at byte %d (1)\n"),length,pos,kk);

 					failed=KErrGeneral;

 					//test.Getch();

 					return;

 					}

 				if(kk>=(pos) && kk<(pos+length) && bufa[kk]!=0x55)

 					{

 					test.Printf(_L("Mem::Fill failed filling %d bytes to bufa[%d] at byte %d (2)\n"),length,pos,kk);

 					failed=KErrGeneral;

 					//test.Getch();

 					return;

 					}

 				if(kk>=(pos+length) && bufa[kk]!=0xaa)

 					{

 					test.Printf(_L("Mem::Fill failed filling %d bytes to bufa[%d] at byte %d (3)\n"),length,pos,kk);

 					failed=KErrGeneral;

 					//test.Getch();

 					return;

 					}

 				}

 			}

 		}

 	}

 void testMemSwap()

     {

     test.Next(_L("Mem::Swap()"));

     TText8 bufa[0x200];

     TText8 bufb[0x200];

     TInt ii,jj,kk;

     TInt length;

     TChar a55(0x55);

     TChar aAA(0xaa);

     for(ii=24;ii<496;ii+=5)

         {

         for(jj=24;jj<496;jj+=3)

             {

             length=Min(496-jj,496-ii);

             Mem::Fill(&bufa[0],512,a55);

             Mem::Fill(&bufb[0],512,aAA);

             Mem::Swap(&bufa[ii],&bufb[jj],length);

             for(kk=0;kk<512;kk++)

                 {

                 if(kk<ii && bufa[kk]!=0x55)

                     {

                     test.Printf(_L("Mem::Swap failed. bufa[%d] contains wrong byte. Swap length=%d, ii=%d, jj=%d\n"),kk,length,ii,jj);

                     failed=KErrGeneral;

                     //test.Getch();

                     }

                 if(kk>=ii && kk<(ii+length) && bufa[kk]!=0xaa)

                     {

                     test.Printf(_L("Mem::Swap failed. bufa[%d] contains wrong byte. Swap length=%d, ii=%d, jj=%d\n"),kk,length,ii,jj);

                     failed=KErrGeneral;

                     //test.Getch();

                     }

                 if(kk>=(ii+length) && bufa[kk]!=0x55)

                     {

                     test.Printf(_L("Mem::Swap failed. bufa[%d] contains wrong byte. Swap length=%d, ii=%d, jj=%d\n"),kk,length,ii,jj);

                     failed=KErrGeneral;

                     //test.Getch();

                     }

                 if(kk<jj && bufb[kk]!=0xaa)

                     {

                     test.Printf(_L("Mem::Swap failed. bufb[%d] contains wrong byte. Swap length=%d, ii=%d, jj=%d\n"),kk,length,ii,jj);

                     failed=KErrGeneral;

                     //test.Getch();

                     }

                 if(kk>=jj && kk<(jj+length) && bufb[kk]!=0x55)

                     {

                     test.Printf(_L("Mem::Swap failed. bufb[%d] contains wrong byte. Swap length=%d, ii=%d, jj=%d\n"),kk,length,ii,jj);

                     failed=KErrGeneral;

                     //test.Getch();

                     }

                 if(kk>=(jj+length) && bufb[kk]!=0xaa)

                     {

                     test.Printf(_L("Mem::Swap failed. bufb[%d] contains wrong byte. Swap length=%d, ii=%d, jj=%d\n"),kk,length,ii,jj);

                     failed=KErrGeneral;

                     //test.Getch();

                     }

                 }

             }

         }

     }

 void testMemCompare()

     {

     TText8 bufa[516];

     TText8 bufb[516];

     test.Next(_L("Mem::Compare()"));

     TInt ii,jj,kk;

     TChar a55(0x55);

     TChar a11(0x11);

     TChar a99(0x99);

     TInt posi,posj,offi,offj,leni,lenj;

     for(ii=0;ii<512;ii+=2)

         {

         for(jj=0;jj<512;jj+=3)

             {

             Mem::Fill(&bufa[0],512,a55);

             Mem::Fill(&bufb[0],512,a55);

             posi=(511+ii)/2; // get a position somewhere in the middle

             posj=(511+jj)/2;

             bufa[posi]=0x12;

             bufb[posj]=0x12;

             offi=posi-ii;

             offj=posj-jj;

             leni=511-ii;

             lenj=511-jj;

 //

 // Make sure that outside the compare range is different

 //

             Mem::Fill(&bufa[ii+leni],4,a11);

             Mem::Fill(&bufb[jj+lenj],4,a99);

             kk=Mem::Compare(&bufa[ii],leni,&bufb[jj],lenj);

             if(offi==offj) // Wrong byte is at same offset

                 {

                 if(ii==jj) // Same lengths being compared, so should compare ok

                     {

                     if(kk!=0)

                         {

                         test.Printf(_L("%d returned when offi=%d, offj=%d, ii=%d, jj=%d\n"),kk,offi,offj,ii,jj);

                         test.Printf(_L("Should return zero\n"));

                         test.Printf(_L("bufa=%d,bufb=%d, leftl=%d, rightl=%d\n"),&bufa[ii],&bufb[jj],leni,lenj);

                         //test.Getch();

                         failed=KErrGeneral;

                         }

                     }

                 else // Different lengths, so should return difference of lengths

                     {

                     if(kk!=leni-lenj)

                         {

                         test.Printf(_L("%d returned when offi=%d, offj=%d, ii=%d, jj=%d\n"),kk,offi,offj,ii,jj);

                         test.Printf(_L("Should return difference of the lengths\n"));

                         test.Printf(_L("bufa=%d,bufb=%d, leftl=%d, rightl=%d\n"),&bufa[ii],&bufb[jj],leni,lenj);

                         //test.Getch();

                         failed=KErrGeneral;

                         }

                     }

                 }

             if(offi!=offj) // Wrong byte at different offset

                 {

                 if(offi<offj && kk!=0x12-0x55)

                     {

                     test.Printf(_L("%d returned when offi=%d, offj=%d, ii=%d, jj=%d\n"),kk,offi,offj,ii,jj);

                     test.Printf(_L("Should return difference of the bytes\n"));

                     test.Printf(_L("bufa=%d,bufb=%d, leftl=%d, rightl=%d\n"),&bufa[ii],&bufb[jj],leni,lenj);

                     //test.Getch();

                     failed=KErrGeneral;

                     }

                 if(offj<offi && kk!=0x55-0x12)

                     {

                     test.Printf(_L("%d returned when offi=%d, offj=%d, ii=%d, jj=%d\n"),kk,offi,offj,ii,jj);

                     test.Printf(_L("Should return difference of the bytes\n"));

                     test.Printf(_L("bufa=%d,bufb=%d, leftl=%d, rightl=%d\n"),&bufa[ii],&bufb[jj],leni,lenj);

                     //test.Getch();

                     failed=KErrGeneral;

                     }

                 }

             }

         }

     }

 void testDesNum()

     {

     TBuf<36> aBuf;

     test.Next(_L("Des::Num(EHex)"));

     aBuf.Num(0x1b34a678,EHex);

     if(aBuf!=_L("1b34a678"))

         testFailed(_L("Des::Num(0x1b34a678,EHex)"));

     else

         {

         aBuf.Num(0x1234,EHex);

         if(aBuf!=_L("1234"))

             testFailed(_L("Des::Num(0x1234,EHex)"));

         }

     test.Next(_L("Des::Num(EDecimal)"));

     aBuf.Num(7462521,EDecimal);

     if(aBuf!=_L("7462521"))

         testFailed(_L("Des::Num(7462521,EDecimal)"));

     else

         {

         aBuf.Num(1234,EDecimal);

         if(aBuf!=_L("1234"))

             testFailed(_L("Des::Num(1234,EDecimal)"));

         }

     test.Next(_L("Des::Num(EOctal)"));

     aBuf.Num(03521,EOctal);

     if(aBuf!=_L("3521"))

         testFailed(_L("Des::Num(03521,EOctal)"));

     else

         {

         aBuf.Num(0706321,EOctal);

         if(aBuf!=_L("706321"))

             testFailed(_L("Des::Num(0706321,EOctal)"));

         }

     test.Next(_L("Des::Num(EBinary)"));

     aBuf.Num(0x92074625,EBinary);

     if(aBuf!=_L("10010010000001110100011000100101"))

         {

         testFailed(_L("Des::Num(0x92074625,EBinary)"));

         }

     else

         {

         aBuf.Num(0x4625,EBinary);

         if(aBuf!=_L("100011000100101"))

             testFailed(_L("Des::Num(0x4625,EBinary)"));

         }

     }

 void testDesNumUC()

     {

     TBuf<36> aBuf;

     test.Next(_L("Des::NumUC(EHex)"));

     aBuf.NumUC(0x1b3ca678,EHex);

     if(aBuf!=_L("1B3CA678"))

         testFailed(_L("Des::NumUC(0x1b3ca678,EHex)"));

     else

         {

         aBuf.NumUC(0x89abcdef,EHex);

         if(aBuf!=_L("89ABCDEF"))

             testFailed(_L("Des::NumUC(0x89abcdef,EHex)"));

         }

     test.Next(_L("Des::NumUC(EDecimal)"));

     aBuf.NumUC(7462521,EDecimal);

     if(aBuf!=_L("7462521"))

         testFailed(_L("Des::NumUC(7462521,EDecimal)"));

     else

         {

         aBuf.NumUC(1234,EDecimal);

         if(aBuf!=_L("1234"))

             testFailed(_L("Des::NumUC(1234,EDecimal)"));

         }

     test.Next(_L("Des::NumUC(EOctal)"));

     aBuf.NumUC(03521,EOctal);

     if(aBuf!=_L("3521"))

         testFailed(_L("Des::NumUC(03521,EOctal)"));

     else

         {

         aBuf.NumUC(0706321,EOctal);

         if(aBuf!=_L("706321"))

             testFailed(_L("Des::NumUC(0706321,EOctal)"));

         }

     test.Next(_L("Des::NumUC(EBinary)"));

     aBuf.NumUC(0x92074625,EBinary);

     if(aBuf!=_L("10010010000001110100011000100101"))

         {

         testFailed(_L("Des::NumUC(0x92074625,EBinary)"));

         }

     else

         {

         aBuf.NumUC(0x4625,EBinary);

         if(aBuf!=_L("100011000100101"))

             testFailed(_L("Des::NumUC(0x4625,EBinary)"));

         }

     }

 void testDivTen(TInt aInc)

 //

 // Always pass aInc as zero. It's just there to stop the compiler

 // optimising the a=a/10 statements out for you. They must be

 // worked out by the operating system at runtime.

 //

     {

     TUint a=68417814+aInc; // some random unsigned number

     TInt b=-48910759+aInc; // some random signed negative number

     TInt c=2147483647+aInc; // maximum positive number

     TUint d=3147484647u+aInc; // high positive unsigned number

     TUint ar=68417814/10;

     TInt br=-48910759/10;

     TInt cr=2147483647/10;

     TUint dr=3147484647u/10;

     a=a/10;

     b=b/10;

     c=c/10;

     d=d/10;

     test.Next(_L("Integer divide by 10"));

     if(a!=ar)

         {

         test.Printf(_L("68417814/10 gives %u\n"),a);

         failed=KErrGeneral;

         }

     if(b!=br)

         {

         test.Printf(_L("-48910759/10 gives %d\n"),b);

         failed=KErrGeneral;

         }

     if(c!=cr)

         {

         test.Printf(_L("2147483647/10 gives %d\n"),c);

         failed=KErrGeneral;

         }

     if(d!=dr)

         {

         test.Printf(_L("3147484647/10 gives %u\n"),d);

         failed=KErrGeneral;

         }

     }

 void testDivSeven(TInt aInc)

 //

 // Always pass aInc as zero. It's just there to stop the compiler

 // optimising the a=a/7 statements out for you. They must be

 // worked out by the operating system at runtime.

 //

     {

     TUint a=68417814+aInc; // some random unsigned number

     TInt b=-48910759+aInc; // some random signed negative number

     TInt c=2147483647+aInc; // maximum positive number

     TUint d=3147484647u+aInc; // high positive unsigned number

     TUint ar=68417814/7;

     TInt br=-48910759/7;

     TInt cr=2147483647/7;

     TUint dr=3147484647u/7;

     a=a/7;

     b=b/7;

     c=c/7;

     d=d/7;

     test.Next(_L("Integer divide by 7"));

     if(a!=ar)

         {

         test.Printf(_L("68417814/7 gives %u\n"),a);

         failed=KErrGeneral;

         }

     if(b!=br)

         {

         test.Printf(_L("-48910759/7 gives %d\n"),b);

         failed=KErrGeneral;

         }

     if(c!=cr)

         {

         test.Printf(_L("2147483647/7 gives %d\n"),c);

         failed=KErrGeneral;

         }

     if(d!=dr)

         {

         test.Printf(_L("3147484647/7 gives %u\n"),d);

         failed=KErrGeneral;

         }

     }

 void testDivFive(TInt aInc)

 //

 // Always pass aInc as zero. It's just there to stop the compiler

 // optimising the a=a/5 statements out for you. They must be

 // worked out by the operating system at runtime.

 //

     {

     TUint a=68417814+aInc; // some random unsigned number

     TInt b=-48910759+aInc; // some random signed negative number

     TInt c=2147483647+aInc; // maximum positive number

     TUint d=3147484647u+aInc; // high positive unsigned number

     TUint ar=68417814/5;

     TInt br=-48910759/5;

     TInt cr=2147483647/5;

     TUint dr=3147484647u/5;

     a=a/5;

     b=b/5;

     c=c/5;

     d=d/5;

     test.Next(_L("Integer divide by 5"));

     if(a!=ar)

         {

         test.Printf(_L("68417814/5 gives %u\n"),a);

         failed=KErrGeneral;

         }

     if(b!=br)

         {

         test.Printf(_L("-48910759/5 gives %d\n"),b);

         failed=KErrGeneral;

         }

     if(c!=cr)

         {

         test.Printf(_L("2147483647/5 gives %d\n"),c);

         failed=KErrGeneral;

         }

     if(d!=dr)

         {

         test.Printf(_L("3147484647/5 gives %u\n"),d);

         failed=KErrGeneral;

         }

     }

 void testDivSixteen(TInt aInc)

 //

 // Always pass aInc as zero. It's just there to stop the compiler

 // optimising the a=a/16 statements out for you. They must be

 // worked out by the operating system at runtime.

 //

     {

     TUint a=68417814+aInc; // some random unsigned number

     TInt b=-48910759+aInc; // some random signed negative number

     TInt c=2147483647+aInc; // maximum positive number

     TUint d=3147484647u+aInc; // high positive unsigned number

     TUint ar=68417814/16;

     TInt br=-48910759/16;

     TInt cr=2147483647/16;

     TUint dr=3147484647u/16;

     a=a/16;

     b=b/16;

     c=c/16;

     d=d/16;

     test.Next(_L("Integer divide by 16"));

     if(a!=ar)

         {

         test.Printf(_L("68417814/16 gives %u\n"),a);

         failed=KErrGeneral;

         }

     if(b!=br)

         {

         test.Printf(_L("-48910759/16 gives %d\n"),b);

         failed=KErrGeneral;

         }

     if(c!=cr)

         {

         test.Printf(_L("2147483647/16 gives %d\n"),c);

         failed=KErrGeneral;

         }

     if(d!=dr)

         {

         test.Printf(_L("3147484647/16 gives %u\n"),d);

         failed=KErrGeneral;

         }

     }

 void testModulo(TInt aInc)

     {

     test.Next(_L("Integer modulo"));

     TInt ii,kk;

     for(kk=1;kk<32;kk++)

         {

         for(ii=0;ii<kk;ii++)

             {

             TInt jj=(kk*73)+aInc+ii;

             if((jj%kk)!=ii)

                 {

                 test.Printf(_L("%d mod %d gives %d\n"),jj,kk,jj%kk);

                 failed=KErrGeneral;

                 }

             }

         }

     }

 TInt E32Main()

 //

 // Benchmark for Mem functions

 //

     {

     failed=KErrNone;

     test.Title();

     test.Start(_L("T_FUNC"));

     testMemCopy();

     testMemMove();

     testMemFill();

     testMemSwap();

     testMemCompare();

     testDesNum();

     testDesNumUC();

     testDivTen(0);

     testDivSixteen(0);

     testDivFive(0);

     testDivSeven(0);

     testModulo(0);

 	test(failed==KErrNone);

     test.End();

 	return(KErrNone);

     }