// 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\mmu\t_chunk.cpp

// Overview:

// Test RChunk class

// API Information:

// RChunk, RChangeNotifier, TFindChunk

// Details:

// - Test adjusting chunks: create a global chunk, adjust it, do some size 

// checks, verify Create() rounds up to chunk multiple, verify that adjust

// request for size greater than MaxSize returns an error.

// - Test creating chunks with small sizes (0 and 1), verify results are as expected.

// - Create multiple local and global chunks, verify that Size,MaxSize,Name & FullName methods 

// are as expected. 

// Check Create method of global chunk if the name is already in use. Check the name can be 

// reused after the chunk is closed.

// - Perform adjust tests on a chunk, verify results are as expected.

// - Open and test global chunks with multiple references, verify results are as expected.

// - Open and test local chunks, check TFindChunk::Next method, verify results are as expected.

// - Check user thread is panicked if it creates or adjusts chunk with negative size or of an

// invalid type or with an invalid name.

// - Check the chunk is filled in with the appropriate clear value after creation, verify results

// are as expected.

// - Test sharing a chunk between threads, verify results are as expected.

// - Create a thread to watch for notification of changes in free memory and

// changes in out of memory status. Verify adjusting an RChunk generates

// the expected notifications.

// - Test finding a global chunk by name and verify results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32panic.h>

#include <e32svr.h>

#include "mmudetect.h"

#include "d_gobble.h"

#include "freeram.h"

const TInt KHeapSize=0x200;

//const TInt KNumberOfChunks=10; can't have that many

const TInt KNumberOfChunks=3;

const TInt KChunkNum=5;

const TInt KNormalReturn=194;

#ifdef __WINS__

const TInt KMinChunkSizeInBytesMinus1=0x0000ffff;

const TUint KMinChunkSizeInBytesMask=0xffff0000;

#elif defined (__X86__)

const TInt KMinChunkSizeInBytesMinus1=0x003fffff;

const TUint KMinChunkSizeInBytesMask=0xffc00000;

#else

const TInt KMinChunkSizeInBytesMinus1=0x000fffff;

const TUint KMinChunkSizeInBytesMask=0xfff00000;

#endif

const TInt KMinPageSizeInBytesMinus1=0x00000fff;

const TUint KMinPageSizeInBytesMask=0xfffff000;

TInt gPageSize;

LOCAL_D RTest test(_L("T_CHUNK"));

LOCAL_D RTest t(_L("ShareThread"));

LOCAL_D RChunk gChunk;

LOCAL_D TPtr nullPtr(NULL,0);

TUint32 MemModel;

enum TDirective

	{

	ENormal,

	ECreateNegative,

	EAdjustNegative,

	ECreateInvalidType,

	ECreateInvalidName,

	ECreateNoName,

	};

const TUint8 KDfltClearByte = 0x3;

TBool CheckChunkCleared(RChunk& aRC, TInt aOffset=0, TUint8 aClearByte = KDfltClearByte)

	{

	TUint8* base = aRC.Base()+aOffset;

	TInt size = aRC.Size();

	test.Printf(_L("Testing chunk for 0x%x - size: %d!\n"), aClearByte, size);

	TBool ret=ETrue;

	for(TInt i = 0; i<size; i++)

		if(base[i] != aClearByte)

			ret=EFalse;

	memset((TAny*)base, 0x05, size);

	return ret;

	}

TInt roundToPageSize(TInt aSize)

	{

	return(((aSize+KMinPageSizeInBytesMinus1)&KMinPageSizeInBytesMask));

	}

TInt roundToChunkSize(TInt aSize)

	{

	if(MemModel==EMemModelTypeFlexible)

		return roundToPageSize(aSize);

	return(((aSize+KMinChunkSizeInBytesMinus1)&KMinChunkSizeInBytesMask));

	}

TInt ThreadEntry2(TAny* /*aParam*/)

//

//	Thread to read from shared chunk

//

	{

	RChunk c;

	TInt r;

	r=c.OpenGlobal(_L("Marmalade"),ETrue);

	t(r==KErrNone);

	TUint8* base=c.Base();

	for (TInt8 i=0;i<10;i++)

		t(*base++==i); // check the chunk has 0-9

	c.Close();

	return(KErrNone);

	}

TInt ThreadEntry(TAny* aDirective)

//

//	Thread to create a Panic in a variety of ways

//

	{

	switch((TUint)aDirective)

		{

	case ENormal:

		{

		return KNormalReturn;

		}

	case ECreateNegative:

		{

		gChunk.CreateLocal(0x10,-0x10);

		test(EFalse); 

		}

	case EAdjustNegative:

		{

		gChunk.Adjust(-0x10);

		test(EFalse);

		}

	case ECreateInvalidType :

		{

		TChunkCreateInfo createInfo;

		createInfo.SetCode(gPageSize, gPageSize);

		_LIT(KChunkName, "Chunky");

		createInfo.SetGlobal(KChunkName);

		RChunk chunk;

		chunk.Create(createInfo);

		test(EFalse);

		}

	default:

		test(EFalse);

		}

	return(KErrNone);

	}

//

//	Test the clear flags for the specified chunk.

//	Assumes chunk has one commited region from base to aBytes.

//

void TestClearChunk(RChunk& aChunk, TUint aBytes, TUint8 aClearByte)

	{

	test_Equal(ETrue, CheckChunkCleared(aChunk, 0, aClearByte));

	test_KErrNone(aChunk.Adjust(0));

	test_KErrNone(aChunk.Adjust(aBytes));

	test_Equal(ETrue, CheckChunkCleared(aChunk, 0, aClearByte));

	aChunk.Close();

	}

//

// Create the specified thread and verify the exit reason.

//

void TestThreadExit(TExitType aExitType, TInt aExitReason, TThreadFunction aFunc, TAny* aThreadParam)

	{

	RThread thread;

	test_KErrNone(thread.Create(_L("RChunkPanicThread"), aFunc, KDefaultStackSize, 

								KHeapSize, KHeapSize, aThreadParam));

	// Disable JIT debugging.

	TBool justInTime=User::JustInTime();

	User::SetJustInTime(EFalse);

	TRequestStatus status;

	thread.Logon(status); 

	thread.Resume();

	User::WaitForRequest(status);

	test_Equal(aExitType, thread.ExitType());

	test_Equal(aExitReason, status.Int());

	test_Equal(aExitReason, thread.ExitReason());

	if (aExitType == EExitPanic)

		test(thread.ExitCategory()==_L("USER"));

	CLOSE_AND_WAIT(thread);

	// Put JIT debugging back to previous status.

	User::SetJustInTime(justInTime);

	}

//

// Thread function to create a chunk with invalid attributes

//

TInt ChunkPanicThread(TAny* aCreateInfo)

	{

	// This should panic.

	RChunk chunk;

	chunk.Create((*(TChunkCreateInfo*) aCreateInfo));

	test(EFalse);

	return KErrGeneral;	// Shouldn't reach here.

	}

void testInitialise()

	{

	test.Next(_L("Load gobbler LDD"));

	TInt r = User::LoadLogicalDevice(KGobblerLddFileName);

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

	// get system info...

	MemModel = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL) & EMemModelTypeMask;

	test_KErrNone(UserHal::PageSizeInBytes(gPageSize));

	}

void test1()

//

//	Test creating chunks with silly sizes

//

	{

	__KHEAP_MARK;

	RChunk chunk;

	TInt r;

	test.Start(_L("Create global chunks"));

	r=chunk.CreateGlobal(_L("Fopp"),1,1);

	test(r==KErrNone);

	chunk.Close();

	r=chunk.CreateGlobal(_L("Fopp"),0,0);

	test(r==KErrArgument);

	__KHEAP_CHECK(0);

	test.Next(_L("Create local chunks"));	  

	r=chunk.CreateLocal(1,1);

	test(r==KErrNone);

	chunk.Close();

	r=chunk.CreateLocal(0,0);

	test(r==KErrArgument);

	test.End();

	__KHEAP_MARKEND;

	}

void test2(TInt aSize)

//

//	Test local/global chunk creation

//

	{

	RChunk lchunk[KNumberOfChunks];

	RChunk gchunk[KNumberOfChunks];

	RChunk chunk;

	__KHEAP_MARK;

	test.Start(_L("Create multiple local and global chunks"));

	TInt i;

	TBuf<0x40> name;

	TFullName fullname;

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

		{

		TInt r;

		// create a local chunk

		r=lchunk[i].CreateLocal(aSize,aSize);

		test(r==KErrNone);

		r=lchunk[i].MaxSize();

		test(r==roundToChunkSize(aSize));

		test(lchunk[i].Size()==roundToPageSize(aSize)); // was 0

		test(lchunk[i].Name().Left(6)==_L("Local-"));

		fullname=RProcess().Name();

		fullname+=_L("::");

		fullname+=lchunk[i].Name();

		test(lchunk[i].FullName().CompareF(fullname)==0);

		// create a global chunk

		name.Format(_L("Chunk%d"),i);

		r=gchunk[i].CreateGlobal(name,aSize,aSize);

		test(r==KErrNone);

  		test(gchunk[i].MaxSize()==roundToChunkSize(aSize));

		test(gchunk[i].Size()==roundToPageSize(aSize)); // was 0

		test(gchunk[i].Name()==name);

		}

	// make room for another chunk

	lchunk[KNumberOfChunks-1].Close();

	gchunk[KNumberOfChunks-1].Close();

//	Try to create a global chunk with a duplicate name

	test.Next(_L("Create a chunk with a duplicate name"));

	TInt r=chunk.CreateGlobal(_L("Chunk0"),aSize,aSize);

	test(r==KErrAlreadyExists);

 	test.Next(_L("Close all chunks"));

	for (i=0; i<KNumberOfChunks-1; i++)

		{

		lchunk[i].Close();

		gchunk[i].Close();

		}

	test.Next(_L("Reuse a name"));

	r=chunk.CreateGlobal(_L("Chunk1"),aSize,aSize);

	test(r==KErrNone);

	test(chunk.MaxSize()==roundToChunkSize(aSize));

   	test(chunk.Size()==roundToPageSize(aSize));	

	test(chunk.Name()==_L("Chunk1"));

  	chunk.Close();

	test.End();

	__KHEAP_MARKEND;

	}

void test3_2(RChunk& aChunk, TInt aSize)

//

//	Perform Adjust tests on aChunk

//

	{

	TInt r;

	test.Start(_L("Adjust to full size"));

	r=aChunk.Adjust(aSize);

 	test(r==KErrNone);

	test(aChunk.Size()==roundToPageSize(aSize));

	test(aChunk.MaxSize()==roundToChunkSize(aSize));

	test.Next(_L("Adjust a chunk to half size"));

	r=aChunk.Adjust(aSize/2);

	test(r==KErrNone);

	test(aChunk.Size()==roundToPageSize(aSize/2));

	test(aChunk.MaxSize()==roundToChunkSize(aSize));

	test.Next(_L("Adjust to same size"));

	r=aChunk.Adjust(aSize/2);

	test(r==KErrNone);

	test(aChunk.Size()==roundToPageSize(aSize/2));

	test(aChunk.MaxSize()==roundToChunkSize(aSize));

	test.Next(_L("Adjusting to size=0"));

 	r=aChunk.Adjust(0);

	test(r==KErrNone);

	test(aChunk.Size()==0);

	test(aChunk.MaxSize()==roundToChunkSize(aSize));

	test.Next(_L("Adjust back to half size"));

	r=aChunk.Adjust(aSize/2);

	test(r==KErrNone);

	test(aChunk.Size()==roundToPageSize(aSize/2));

	test(aChunk.MaxSize()==roundToChunkSize(aSize));

	test.End();

	}

void test3(TInt aSize)

//

//	Test Adjust size of chunk	

//

	{

	RChunk chunk;

	__KHEAP_MARK;	

	TInt r;

//	Run Adjust tests with a local chunk

	test.Start(_L("Local Chunk.Adjust()"));

	r=chunk.CreateLocal(aSize,aSize);

	test3_2(chunk, aSize);

	chunk.Close();

//	Run Adjust tests with a global chunk

	test.Next(_L("Global Chunk.Adjust()"));

	r=chunk.CreateGlobal(_L("Fopp"),aSize,aSize);

	test(KErrNone==r);

	test3_2(chunk,aSize);

	chunk.Close();

	test.End();

	__KHEAP_MARKEND;

	}

void test4(TInt aSize)

//

//	Test OpenGlobal

//

	{

	RChunk chunk[KChunkNum];

	RChunk c1, c2, c3;

	TName name;

	__KHEAP_MARK;

	TInt i,r;

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

		{

		name.Format(_L("Chunk%d"), i);

		r=chunk[i].CreateGlobal(name,aSize,aSize);

		}

	test.Start(_L("Open Global chunks"));

	r=c1.OpenGlobal(_L("Chunk1"),EFalse); // 2nd ref to this chunk

	test(r==KErrNone);

	r=c2.OpenGlobal(_L("Chunk3"),EFalse); // 2nd ref to this chunk

	test(r==KErrNone);

	r=c3.OpenGlobal(_L("Chunk4"),EFalse); // 2nd ref to this chunk

	test(r==KErrNone);

	c3.Close();

	test.Next(_L("Attempt Open non-existant chunk"));

	r=c3.OpenGlobal(_L("Non Existant Chunk"),EFalse);

	test(r==KErrNotFound);

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

		{

		test.Printf(_L("Closing chunk %d\n"),i);

		chunk[i].Close();

		}

	test.Next(_L("Test chunks with multiple references are still valid"));

	r=c1.Adjust(aSize/2);

	test(r==KErrNone);

	test(c1.MaxSize()==roundToChunkSize(aSize));

	test(c1.Size()==roundToPageSize(aSize/2));

	test(c1.Name()==_L("Chunk1"));

	r=c2.Adjust(aSize/2);

	test(r==KErrNone);

	test(c2.MaxSize()==roundToChunkSize(aSize));

	test(c2.Size()==roundToPageSize(aSize/2));

	test(c2.Name()==_L("Chunk3"));

//	Open another reference to a chunk

	r=c3.OpenGlobal(_L("Chunk3"),EFalse);

	test(r==KErrNone);

	test(c3.Base()==c2.Base());

	test(c3.Size()==c2.Size());

	test(c2.Size()!=aSize);

//	Adjust with one reference

	r=c3.Adjust(aSize);

	test(r==KErrNone);

//	Test sizes from the other

	test(c2.Size()==roundToPageSize(aSize));

	test(c2.MaxSize()==roundToChunkSize(aSize));

	c1.Close();

	c2.Close();

	c3.Close();

	test.Next(_L("And check the heap..."));

	test.End();

	__KHEAP_MARKEND;

	}

void test5(TInt aSize)

//

//	Test Open

//

	{

	RChunk chunk[2*KNumberOfChunks];

	RChunk c1;

	test.Start(_L("Creating Local and Global Chunks"));

	__KHEAP_MARK;

	TInt i,r;

	TBuf<0x40> b;

//	Create KNumberOfChunks Global chunks

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

		{

		b.Format(_L("Chunk%d"), i);

		r=chunk[i].CreateGlobal(b,aSize,aSize);

		test(chunk[i].Name()==b);

		test(r==KErrNone);

		b.Format(_L("This is chunk %d"), i);

		b.Append(TChar(0));

		chunk[i].Adjust(aSize);

		Mem::Copy(chunk[i].Base(), b.Ptr(), b.Size());

		test(chunk[i].MaxSize()==roundToChunkSize(aSize));

		test(chunk[i].Size()==roundToPageSize(aSize));

		}

	test.Next(_L("Find and Open the Chunks"));

	TFindChunk find;

	TFullName name;

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

		{

		test.Printf(_L("Opening chunk %d\n"),i);

		find.Find(chunk[i].FullName());

		r = find.Next(name);

		test(r==KErrNone);

		c1.Open(find);

		b=TPtrC((TText*)c1.Base());

		name.Format(_L("This is chunk %d"), i);

		test(b==name);

		c1.Close();

		}

	test.Next(_L("Close chunks"));