// Copyright (c) 1999-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\system\t_kucopy.cpp

// Test copying between kernel and user side.

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include "d_kucopy.h"

#include "../mmu/mmudetect.h"

//#define QUICK

_LIT(KLddFileName,"D_KUCOPY.LDD");

_LIT(KLitKernExec,"KERN-EXEC");

RTest test(_L("T_KUCOPY"));

RKUCopy KU;

TInt BufSize;

TInt RandSize;

TUint8* Buf1;

TUint8* Buf2;

TUint8* Random;

TBool KernProt=EFalse;

_LIT8(KTest8_1,"1");

_LIT8(KTest8_2,"Test2");

_LIT8(KTest8_3,"extensionality emptyset pairset separation powerset unionset infinity foundation replacement choice");

_LIT8(KTest8_4,"And darkness and decay and the red death held illimitable dominion over all.");

_LIT16(KTest16_1,"39");

_LIT16(KTest16_2,"Test16");

_LIT16(KTest16_3,"extensionality emptyset pairset separation powerset unionset infinity foundation replacement choice.");

_LIT16(KTest16_4,"And darkness and decay and the red death held illimitable dominion over all.");

static const TDesC8* const TestStrings8[]=

	{

	&KTest8_1,

	&KTest8_2,

	&KTest8_3,

	&KTest8_4,

	};

static const TDesC16* const TestStrings16[]=

	{

	&KTest16_1,

	&KTest16_2,

	&KTest16_3,

	&KTest16_4,

	};

#define NTESTS8		((TInt)(sizeof(TestStrings8)/sizeof(const TDesC8*)))

#define NTESTS16	((TInt)(sizeof(TestStrings16)/sizeof(const TDesC16*)))

enum TTest

	{

	EPut,

	EGet,

	EPut32,

	EGet32,

	ESet,

	EDesPut8,

	EDesGet8,

	EDesInfo8,

	EDesPut16,

	EDesGet16,

	EDesInfo16,

	};

void DoPutGetTest(TInt aSrcOffset, TInt aDestOffset, TInt aLen, TTest aTest)

	{

	// Use the first BufSize of random data as background, the rest as copy data.

	// Use Buf1 as target

//	test.Printf(_L("s=%4d d=%4d l=%4d t=%d\n"),aSrcOffset,aDestOffset,aLen,aTest);

	switch (aTest)

		{

		case EPut:

			Mem::Move(Buf1,Random,BufSize);

			KU.Put(Buf1+aDestOffset,aSrcOffset+BufSize,aLen);

			break;

		case EGet:

			KU.Get(Random+BufSize+aSrcOffset,aDestOffset,aLen);

			KU.Read(Buf1);

			break;

		case EPut32:

			Mem::Move(Buf1,Random,BufSize);

			KU.Put32((TUint32*)(Buf1+aDestOffset),aSrcOffset+BufSize,aLen);

			break;

		case EGet32:

			KU.Get32((const TUint32*)(Random+BufSize+aSrcOffset),aDestOffset,aLen);

			KU.Read(Buf1);

			break;

		default:

			User::Panic(_L("PutGetTest"),aTest);

		}

	// Should now have:

	// Buf1[0...aDestOffset-1]=Random[0...aDestOffset-1]

	// Buf1[aDestOffset...aDestOffset+aLen-1]=Random[BufSize+aSrcOffset...BufSize+aSrcOffset+aLen-1]

	// Buf1[aDestOffset+aLen...BufSize-1]=Random[aDestOffset+aLen...BufSize-1]

	test(Mem::Compare(Buf1,aDestOffset,Random,aDestOffset)==0);

	test(Mem::Compare(Buf1+aDestOffset,aLen,Random+BufSize+aSrcOffset,aLen)==0);

	test(Mem::Compare(Buf1+aDestOffset+aLen,BufSize-aDestOffset-aLen,Random+aDestOffset+aLen,BufSize-aDestOffset-aLen)==0);

	}

void DoSetTest(TInt aOffset, TInt aLen, TUint8 aValue)

	{

	Mem::Move(Buf1,Random,BufSize);

	KU.Set(Buf1+aOffset,aLen,aValue);

	test(Mem::Compare(Buf1,aOffset,Random,aOffset)==0);

	TUint8* p=Buf1+aOffset;

	TUint8* pE=p+aLen;

	while (p<pE)

		test(*p++==aValue);

	test(Mem::Compare(Buf1+aOffset+aLen,BufSize-aOffset-aLen,Random+aOffset+aLen,BufSize-aOffset-aLen)==0);

	}

void TestDesGet8(const TDesC8& aSrc)

	{

	TPtr8 dest(Buf2,0,BufSize);

	KU.DesGet(dest,aSrc);

	test(dest==aSrc);

	}

void TestDesGet8()

	{

	TInt i;

	for (i=0; i<NTESTS8; ++i)

		{

		const TDesC8* orig=TestStrings8[i];

		TestDesGet8(*orig);	// test EBufC

		TBuf8<256> buf=*orig;

		TestDesGet8(buf);	// test EBuf

		TPtrC8 ptrc(orig->Ptr(),orig->Length());

		TestDesGet8(ptrc);	// test EPtrC

		TPtr8 ptr((TUint8*)orig->Ptr(),orig->Length(),orig->Length());

		TestDesGet8(ptr);	// test EPtr

		HBufC8* pH=orig->Alloc();

		test(pH!=NULL);

		TPtr8 bufCptr(pH->Des());

		TestDesGet8(bufCptr);	// test EBufCPtr

		User::Free(pH);

		}

	}

void TestDesPut8(TDesC8& aDest, const TDesC8* aExtraDest, const TDesC8& aSrc)

	{

	KU.DesPut((TDes8&)aDest,aSrc);

	test(aDest==aSrc);

	if (aExtraDest)

		test(*aExtraDest==aSrc);	// for testing EBufCPtr

	}

void TestDesPut8()

	{

	TInt i;

	for (i=0; i<NTESTS8; ++i)

		{

		const TDesC8* orig=TestStrings8[i];

		TBuf8<256> buf;

		TestDesPut8(buf,NULL,*orig);	// test EBuf

		Mem::FillZ((TAny*)buf.Ptr(),256);

		TPtr8 ptr((TUint8*)buf.Ptr(),0,256);

		TestDesPut8(ptr,NULL,*orig);	// test EPtr

		HBufC8* pH=HBufC8::New(256);

		test(pH!=NULL);

		TPtr8 bufCptr(pH->Des());

		TestDesPut8(bufCptr,pH,*orig);	// test EBufCPtr

		User::Free(pH);

		}

	}

void TestDesInfo8(const TDesC8& aDes, TInt aLength, TInt aMaxLength, const TUint8* aPtr)

	{

	SDesInfo info;

	KU.DesInfo(aDes,info);

	test(aLength==info.iLength);

	test(aMaxLength==info.iMaxLength);

	test((TAny*)aPtr==info.iPtr);

	}

void TestDesInfo8()

	{

	TInt i;

	for (i=0; i<NTESTS8; ++i)

		{

		const TDesC8* orig=TestStrings8[i];

		TestDesInfo8(*orig,orig->Length(),-1,orig->Ptr());	// test EBufC

		TBuf8<256> buf;

		TestDesInfo8(buf,0,256,buf.Ptr());				// test EBuf

		buf=*orig;

		TestDesInfo8(buf,orig->Length(),256,buf.Ptr());	// test EBuf

		TBuf8<203> buf2;

		TestDesInfo8(buf2,0,203,buf2.Ptr());			// test EBuf

		buf2=*orig;

		TestDesInfo8(buf2,orig->Length(),203,buf2.Ptr());	// test EBuf

		TPtrC8 ptrc(orig->Ptr(),orig->Length());

		TestDesInfo8(ptrc,orig->Length(),-1,orig->Ptr());	// test EPtrC

		TPtr8 ptr((TUint8*)orig->Ptr(),orig->Length(),orig->Length());

		TestDesInfo8(ptr,orig->Length(),orig->Length(),orig->Ptr());	// test EPtr

		HBufC8* pH=orig->Alloc();

		test(pH!=NULL);

		TPtr8 bufCptr(pH->Des());

		TestDesInfo8(*pH,orig->Length(),-1,pH->Ptr());

		TestDesInfo8(bufCptr,orig->Length(),User::AllocLen(pH)-sizeof(TDesC8),pH->Ptr());

		User::Free(pH);

		}

	}

void RunTestInThread(TThreadFunction aFn, TAny* aParameter, const TDesC* aPanicCat, TInt aExitCode, TInt aLine)

	{

	test.Printf(_L("Line %d\n"),aLine);

	RThread t;

	TInt r=t.Create(KNullDesC(),aFn,0x2000,NULL,aParameter);

	test(r==KErrNone);

	TRequestStatus s;

	t.Logon(s);

	t.Resume();

	User::WaitForRequest(s);

	if (aPanicCat)

		{

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

		test(t.ExitCategory()==*aPanicCat);

		test(t.ExitReason()==aExitCode);

		}

	else

		{

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

		test(t.ExitReason()==aExitCode);

		}

	CLOSE_AND_WAIT(t);

	}

TInt DesGet8Thread(TAny* aPtr)

	{

	TBuf8<256> dest;

	KU.DesGet(dest, *(const TDesC8*)aPtr);

	return 0;

	}

TInt DesPut8Thread(TAny* aPtr)

	{

	KU.DesPut(*(TDes8*)aPtr,KTest8_4);

	return 0;

	}

TInt DesInfo8Thread(TAny* aPtr)

	{

	SDesInfo info;

	KU.DesInfo(*(TDesC8*)aPtr,info);

	return 0;

	}

void TestErrors()

	{

	TBool jit=User::JustInTime();

	User::SetJustInTime(EFalse);

	TUint8* Kern=KU.KernelBufferAddress();

	TUint x=0xffffffff;

	TBuf8<256> ubuf;

	TPtrC8 uptrc(Buf1,100);

	TPtrC8 kptrc(Kern,1);

	TPtr8 kptr(Kern,10,256);

	RunTestInThread(DesGet8Thread,&x,&KLitKernExec,EKUDesInfoInvalidType,__LINE__);

	RunTestInThread(DesGet8Thread,&ubuf,NULL,KErrNone,__LINE__);

	RunTestInThread(DesGet8Thread,&ubuf,NULL,KErrNone,__LINE__);

	if (KernProt)

		{

		RunTestInThread(DesGet8Thread,Kern,&KLitKernExec,ECausedException,__LINE__);

		RunTestInThread(DesGet8Thread,&kptrc,&KLitKernExec,ECausedException,__LINE__);

		RunTestInThread(DesGet8Thread,&kptr,&KLitKernExec,ECausedException,__LINE__);

		}

	RunTestInThread(DesPut8Thread,&x,&KLitKernExec,EKUDesInfoInvalidType,__LINE__);

	RunTestInThread(DesPut8Thread,&ubuf,NULL,KErrNone,__LINE__);

	RunTestInThread(DesPut8Thread,&uptrc,&KLitKernExec,EKUDesSetLengthInvalidType,__LINE__);

	if (KernProt)

		{

		RunTestInThread(DesPut8Thread,Kern,&KLitKernExec,ECausedException,__LINE__);

		RunTestInThread(DesPut8Thread,&kptrc,&KLitKernExec,EKUDesSetLengthInvalidType,__LINE__);

		RunTestInThread(DesPut8Thread,&kptr,&KLitKernExec,ECausedException,__LINE__);

		}

	RunTestInThread(DesInfo8Thread,&x,&KLitKernExec,EKUDesInfoInvalidType,__LINE__);

	RunTestInThread(DesInfo8Thread,&ubuf,NULL,KErrNone,__LINE__);

	RunTestInThread(DesInfo8Thread,&uptrc,NULL,KErrNone,__LINE__);

	RunTestInThread(DesInfo8Thread,&kptrc,NULL,KErrNone,__LINE__);

	RunTestInThread(DesInfo8Thread,&kptr,NULL,KErrNone,__LINE__);

	if (KernProt)

		{

		RunTestInThread(DesInfo8Thread,Kern,&KLitKernExec,ECausedException,__LINE__);

		}

	User::SetJustInTime(jit);

	}

void RequestCompleteBadPointer(TUint aBadAddress)

	{

	TRequestStatus* badStatus = (TRequestStatus*)aBadAddress;

	test.Printf(_L("Test Kern::RequestComplete to %08x\n"), aBadAddress);

	KU.RequestComplete(badStatus);

	test.Printf(_L("Test Kern::RequestComplete to %08x (in current thread)\n"), aBadAddress);

	KU.RequestCompleteLocal(badStatus);

	// Check the thread hasn't been signalled

	TRequestStatus status;

	RTimer timer;

	test_KErrNone(timer.CreateLocal());

	timer.After(status, 100000); // 100ms

	test_Equal(KRequestPending, status.Int());

	User::WaitForAnyRequest();

	test_Equal(KErrNone, status.Int());

	timer.Close();	

	test.Printf(_L("Test Kern::QueueRequestComplete to %08x\n"), aBadAddress);

	TInt r = KU.QueueRequestComplete(badStatus);

	// Kern::QueueRequestComplete will signal even if the pointer is bad, unless:

	//  - the pointer is null

	//  - the call to Setup returned an error

	if (badStatus != NULL && r == KErrNone)

		User::WaitForAnyRequest();

	}

void TestRequestCompleteTrapped()

	{

	TRequestStatus status;

	test.Printf(_L("Test Kern::RequestComplete to %08x\n"), &status);

	status = KRequestPending;

	KU.RequestComplete(&status);

	User::WaitForRequest(status);

	test_Equal(KErrNone, status.Int());

	test.Printf(_L("Test Kern::RequestComplete to %08x (in current thread)\n"), &status);

	status = KRequestPending;

	KU.RequestCompleteLocal(&status);

	User::WaitForRequest(status);

	test_Equal(KErrNone, status.Int());

	test.Printf(_L("Test Kern::QueueRequestComplete to %08x\n"), &status);

	status = KRequestPending;

	KU.QueueRequestComplete(&status);

	User::WaitForRequest(status);

	test_Equal(KErrNone, status.Int());

	RequestCompleteBadPointer(0x00000000);

	RequestCompleteBadPointer(0x00000001);

	RequestCompleteBadPointer(0x00000004);

	RequestCompleteBadPointer(0x00000008);

	if (KernProt)

		{

		RequestCompleteBadPointer(0x80000000);

		RequestCompleteBadPointer(0xfffffff0);

		RequestCompleteBadPointer((TUint)KU.KernelBufferAddress());

		}

	}

GLDEF_C TInt E32Main()

	{

	test.Title();

	test.Start(_L("Load LDD"));

	TInt r=User::LoadLogicalDevice(KLddFileName);

	test(r==KErrNone || r==KErrAlreadyExists);

	test.Next(_L("Open channel"));

	r=KU.Open();

	test(r==KErrNone);

	test.Next(_L("Create chunk"));

	RChunk c;

	r=c.CreateDisconnectedLocal(0,0,0x100000);

	test(r==KErrNone);

	BufSize=KU.Length();

	RandSize=KU.RandomLength();

	test.Printf(_L("BufSize=%x, RandSize=%x\n"),BufSize,RandSize);

	r=c.Commit(0,BufSize);

	test(r==KErrNone);

	r=c.Commit(0x10000,BufSize);

	test(r==KErrNone);

	r=c.Commit(0x20000,RandSize);

	test(r==KErrNone);

	Buf1=c.Base();

	Buf2=c.Base()+0x10000;

	Random=c.Base()+0x20000;

	test.Printf(_L("Buf1 at %08x, Buf2 at %08x, Random at %08x\n"),Buf1,Buf2,Random);

	Mem::Fill(Buf1,BufSize,0xb1);

	Mem::Fill(Buf2,BufSize,0xb2);

	Mem::Fill(Random,RandSize,0x8b);

	KU.ReadRandom(Random);

	KernProt=HaveDirectKernProt();

#ifndef QUICK

	TInt s;

	TInt d;

	TInt l;

	test.Next(_L("Put/Get 1"));

	for (l=1; l<300; l+=3)

		{

		test.Printf(_L("PG1: l=%d\n"),l);

		for (s=0; s<=BufSize-l; s+=227)

			{

			for (d=0; d<=BufSize-l; d+=229)

				{

				DoPutGetTest(s,d,l,EPut);

				DoPutGetTest(s,d,l,EGet);

				}

			}

		}

	test.Next(_L("Put/Get 2"));

	for (l=1; l<300; l+=3)

		{

		test.Printf(_L("PG2: l=%d\n"),l);

		for (s=BufSize-l; s>=0; s-=227)

			{

			for (d=BufSize-l; d>=0; d-=229)

				{

				DoPutGetTest(s,d,l,EPut);

				DoPutGetTest(s,d,l,EGet);

				}

			}

		}

	test.Next(_L("Put32/Get32 1"));

	for (l=4; l<300; l+=12)

		{

		test.Printf(_L("PG32,1: l=%d\n"),l);

		for (s=0; s<=BufSize-l; s+=4*59)

			{

			for (d=0; d<=BufSize-l; d+=4*61)

				{

				DoPutGetTest(s,d,l,EPut32);

				DoPutGetTest(s,d,l,EGet32);

				}

			}

		}

	test.Next(_L("Put32/Get32 2"));

	for (l=4; l<300; l+=12)

		{

		test.Printf(_L("PG32,2: l=%d\n"),l);

		for (s=BufSize-l; s>=0; s-=4*59)

			{

			for (d=BufSize-l; d>=0; d-=4*61)

				{

				DoPutGetTest(s,d,l,EPut32);

				DoPutGetTest(s,d,l,EGet32);

				}

			}

		}

	test.Next(_L("Set"));

	for (l=1; l<300; l+=3)

		{

		test.Printf(_L("Set: l=%d\n"),l);

		for (s=0; s<=BufSize-l; s+=83)

			{

			DoSetTest(s,l,0x1b);

			DoSetTest(s,l,0xaa);

			}

		for (s=BufSize-l; s>=0; s-=79)

			{

			DoSetTest(s,l,0x1b);

			DoSetTest(s,l,0xaa);

			}

		}

#endif

	test.Next(_L("DesGet8"));

	TestDesGet8();

	test.Next(_L("DesPut8"));

	TestDesPut8();

	test.Next(_L("DesInfo8"));

	TestDesInfo8();

	test.Next(_L("Errors"));

	TestErrors();

	test.Next(_L("Test Kern::RequestComplete functions trapped"));

	TestRequestCompleteTrapped();

	c.Close();

	KU.Close();

	test.End();

	return 0;

	}