// 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);