// 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 "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:

//

#include "../sfbs/UTILS.H"

#include "TFBS.H"

#include "TCLEAN.H"

#include "fbsmessage.h"

#include "fbsdefs.h"

void CTClean::DeleteScanLineBuffer()

	{

	delete iFbs->iScanLineBuffer;

	iFbs->iScanLineBuffer = NULL;

	}

CTClean::CTClean(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iFbs(NULL),

	iStore(NULL),

	iBitmap(NULL),

	iTc(NULL)

	{}

CTClean::~CTClean()

	{

	delete iStore;

	if(iShutdownFbs)

		RFbsSession::GetSession()->SendCommand(EFbsMessShutdown);

	RFbsSession::Disconnect();

	}

void CTClean::ConstructL()

	{

	INFO_PRINTF1(_L("Font/Bitmap Server Thread Death Cleanup Testing"));

	if(RFbsSession::Connect()==KErrNone)

		{

		RFbsSession::Disconnect();

		iShutdownFbs = EFalse;

		}

	else

		{

		FbsStartup();

		iShutdownFbs = ETrue;

		}

	RFbsSession::Connect();

	iFbs=RFbsSession::GetSession();

	iStore=CFbsTypefaceStore::NewL(NULL);

	}

void CTClean::RunTestCaseL(TInt aCurTestCase)

	{

	((CTCleanStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0593"));

		INFO_PRINTF1(_L("Thread Cleanup\r\n"));

		DeadThread();

		break;

	case 2:

#if defined(_DEBUG)

		INFO_PRINTF1(_L("Font\r\n"));

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0594"));

		LaunchThread(EFont1);

		((CTCleanStep*)iStep)->RecordTestResultL();

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0595"));

		LaunchThread(EFont2);

#else

		((CTCleanStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

#endif

		break;

	case 3:

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0596"));

		INFO_PRINTF1(_L("Bitmap\r\n"));

		LaunchThread(EBitmap1);

		break;

	case 4:

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0597"));

		INFO_PRINTF1(_L("Pile\r\n"));

		LaunchThread(EPile1);

		break;

	case 5:

		INFO_PRINTF1(_L("Session\r\n"));

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0598"));

		LaunchThread(ESession1);

		((CTCleanStep*)iStep)->RecordTestResultL();

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0599"));

		LaunchThread(ESession2);

		break;

	case 6:

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0600"));

		INFO_PRINTF1(_L("TypefaceStore\r\n"));

		LaunchThread(ETypefaceStore1);

		break;

	case 7:

		((CTCleanStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0601"));

		INFO_PRINTF1(_L("Bad Message\r\n"));

		LaunchThread(EBadMessage);

	case 8:

		((CTCleanStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTCleanStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();		

		break;

		}

	((CTCleanStep*)iStep)->RecordTestResultL();

	}

TInt CleanupTestThread(TAny* aAny)

	{

	CTClean* theTest = (CTClean*) aAny;

	CTrapCleanup::New();

	RFbsSession::Connect();

	CFbsBitmapEx bmp1;

	CFbsBitmapEx bmp2;

	CFbsBitmapEx bmp3;

	TInt ret=bmp1.Create(TSize(10,10),EGray2);

	theTest->TEST(ret==KErrNone);

	ret=bmp2.Create(TSize(100,100),EGray16);

	theTest->TEST(ret==KErrNone);

	ret=bmp3.Duplicate(bmp2.Handle());

	theTest->TEST(ret==KErrNone);

	CFbsFontEx* fon1;

	CFbsFontEx* fon2;

	CFbsTypefaceStore* tfs=NULL;

	TRAP(ret,tfs=CFbsTypefaceStore::NewL(NULL));

	theTest->TEST(ret==KErrNone);

	ret=tfs->GetNearestFontToDesignHeightInPixels((CFont*&)fon1,TFontSpec(_L("Swiss"),12));

	theTest->TEST(ret==KErrNone);

	fon2=(CFbsFontEx*)User::Alloc(sizeof(CFbsFontEx));

	theTest->TEST(fon2!=NULL);

	new(fon2) CFbsFontEx;

	ret=fon2->Duplicate(fon1->Handle());

	theTest->TEST(ret==KErrNone);

	TInt rc=RFbsSession::GetSession()->ResourceCount();

	theTest->TEST(rc==5);

	TInt id;

#ifdef __WINS__

	ret=tfs->AddFile(_L("z:\\resource\\fonts\\eon14.gdr"),id);

#else

	ret=tfs->AddFile(_L("z:\\resource\\fonts\\eon.gdr"),id);

#endif

	theTest->TEST(ret==KErrNone);

	bmp2.LockHeap();

	RFbsSession::Disconnect();

	User::Panic(_L("CleanupTest"),KErrNone);

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0593

	@SYMTestCaseDesc

	Tests the cleaning when a thead is panicing.

	@SYMTestActions

	Creates a bitmap. Checks the resource count. Creates

	a thread with high priority. Unlocks the heap and locks

	it back again. Disables just-in-time debugging. Waits for 

	he thead to complete its execution. The created thread creates

	its own cleanup stack and connects to a FbsSession. It creates 

	three bitmaps and duplicates one of them to the other. 

	A FbsTypefaceStore object is created on the heap an 

	GetNearestFontToDesignHeightInPixel is called on it. Disconnect

	from the FbsSession. The thread is paniced and terminated. The

	function that created the thread now continues its execution by

	checking the exit reason for the thread. Closes the thead. Enables

	just-in-time again. Locks the heap and unlocks it again.

	Checks the resource count. Deletes scan line buffer. The

	heap is checked for memory leaks.	

	@SYMTestExpectedResults

	Test should pass

*/

void CTClean::DeadThread()

	{

	__UHEAP_MARK;

	CFbsBitmapEx bmp;

	TInt ret=bmp.Create(TSize(100,100),EGray16);

	TEST(ret==KErrNone);

	TInt rc=iFbs->ResourceCount();

	TEST(rc==1);

	RThread thrd;

	TRequestStatus stat;

	thrd.Create(_L("ctt"),CleanupTestThread,KDefaultStackSize,0x8000,0x8000,this);

	thrd.SetPriority(EPriorityMuchMore);

	thrd.Logon(stat);

	User::SetJustInTime(EFalse);

	bmp.LockHeap();

	bmp.UnlockHeap();

	thrd.Resume();

	User::WaitForRequest(stat);

	ret = thrd.ExitReason();

	thrd.Close();

	User::SetJustInTime(ETrue);

	TEST(ret == KErrNone);

	INFO_PRINTF1(_L("About to lock heap\r\n"));

	bmp.LockHeap();

	bmp.UnlockHeap();

	rc=iFbs->ResourceCount();

	TEST(rc==1);

	DeleteScanLineBuffer();

	__UHEAP_MARKEND;

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0594

	@SYMTestCaseDesc

	Tests a CFbsFontEx object in a thead function.

	@SYMTestActions

	Connects to an FbsSession, creates a CFbsFontEx

	object and gets the font address.

	Thread returns with error code KErrNone.

	@SYMTestExpectedResults

	Test should pass

*/

TInt Font1(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	theTest->INFO_PRINTF1(_L("Font1"));

	RFbsSession::Connect();

	CFbsFontEx font;

	(void)font.Address();

	theTest->ERR_PRINTF1(_L("ERROR - NO PANIC"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0595

	@SYMTestCaseDesc

	Tests a CFbsFontEx object in a thead function.

	@SYMTestActions

	Connects to an FbsSession, creates a CFbsFontEx object,

	sets the fonts handle, gets the fonts address.

	Thread returns with error code KErrNone.

	@SYMTestExpectedResults

	Test should pass

*/

TInt Font2(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	theTest->INFO_PRINTF1(_L("Font2"));

	RFbsSession::Connect();

	CFbsFontEx font;

	font.SetHandle();

	(void)font.Address();

	theTest->ERR_PRINTF1(_L("ERROR - NO PANIC"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0596

	@SYMTestCaseDesc

	Creates a bitmap in a thread function, locks the heap

	and panics the thread.

	@SYMTestActions

	Connects to an FbsSession, creates a CFbsBitmapEx object,

	creates a bitmap on the stack. Creation is checked for errors

	and thenb locks the heap. The thread is paniced.

	@SYMTestExpectedResults

	Test should pass

*/

TInt Bitmap1(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	theTest->INFO_PRINTF1(_L("Bitmap1"));

	RFbsSession::Connect();

	CFbsBitmapEx bitmap;

	TInt ret=bitmap.Create(TSize(200,200),EGray16);

	if(ret!=KErrNone)

		{

		theTest->ERR_PRINTF1(_L("ERROR - BITMAP NOT CREATED"));

		}

	bitmap.LockHeap();

	User::Panic(_L(""),KErrNone);

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0597

	@SYMTestCaseDesc

	Tests creation of a chunk in a thread function. 

	@SYMTestActions

	Creates a chunk. The thread returns with error code KErrNone.

	@SYMTestExpectedResults

	Test should pass

*/

TInt Pile1(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	theTest->INFO_PRINTF1(_L("Pile1"));

	RChunk chunk;

	CChunkPile::NewL(chunk);

	theTest->ERR_PRINTF1(_L("ERROR - NO PANIC"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0598

	@SYMTestCaseDesc

	Tests sending a close command to a connected

	server from a thread function.

	@SYMTestActions

	Connects to a FbsSession and sends a

	EFbsMessClose-command to the server. The thread

	returns with error code KErrNone.

	@SYMTestExpectedResults

	Test should pass

*/

TInt Session1(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	RFbsSession::Connect();

	RFbsSession::GetSession()->SendCommand(EFbsMessClose);

	theTest->INFO_PRINTF1(_L("Session1"));

	theTest->ERR_PRINTF1(_L("ERROR - NO PANIC"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0599

	@SYMTestCaseDesc

	Tests sending an init command to a connected

	server from a thread function.

	@SYMTestActions

	Connects to a FbsSession and sends a

	EFbsMessInit-command to the server. The thread

	returns with error code KErrNone.

	@SYMTestExpectedResults

	Test should pass

*/

TInt Session2(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	RFbsSession session;

	session.SendCommand(EFbsMessInit);

	theTest->INFO_PRINTF1(_L("Session2"));

	theTest->ERR_PRINTF1(_L("ERROR - NO PANIC"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0600

	@SYMTestCaseDesc

	Tests the creation of a CFbsTypefaceStore

	object on the heap in a thread function.

	@SYMTestActions

	Creates a CFbsTypefaceStore object on the heap

	in a thread function and returns with error code

	KErrNone.

	@SYMTestExpectedResults

	Test should pass

*/

TInt TypefaceStore1(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	CFbsTypefaceStore::NewL(NULL);

	theTest->INFO_PRINTF1(_L("TypefaceStore1"));

	theTest->ERR_PRINTF1(_L("ERROR - NO PANIC"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0601

	@SYMTestCaseDesc

	Tests sending an invalid message from a thread function

	to a connected FbsSession.

	@SYMTestActions

	Connects to a FbsSession. Gets a pointer to the session

	object. Sends an invalid command to the server. The thread

	returns with error code KErrNone.	

	@SYMTestExpectedResults

	Test should pass

*/

TInt BadMessage(TAny* aAny)

	{

	CTClean* theTest = static_cast <CTClean*> (aAny);

	CTrapCleanup::New();

	RFbsSession::Connect();

	RFbsSession* sess=RFbsSession::GetSession();

	sess->SendCommand(TFbsMessage(0x0fffffff));

	theTest->INFO_PRINTF1(_L("Bad Message Test Thread"));

	theTest->ERR_PRINTF1(_L("ERROR - BAD MESSAGE DID NOT PANIC THREAD"));

	return(KErrNone);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0602

	@SYMTestCaseDesc

	Launches different threads for testing.

	@SYMTestActions

	Creates a thread and gives it higher priority.

	Disables just-in-time and starts the thread and 

	waits for the it to finish. Closes the thead,

	enables just-in-time and checks the heap for

	memory leaks.	

	@SYMTestExpectedResults

	Test should pass

*/

void CTClean::LaunchThread(TTestType aType)

	{

	__UHEAP_MARK;

	RThread thrd;

	TRequestStatus stat;

	switch(aType)

		{

	case EFont1:

		thrd.Create(_L("Font1"),Font1,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case EFont2:

		thrd.Create(_L("Font2"),Font2,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case EBitmap1:

		thrd.Create(_L("Bitmap1"),Bitmap1,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case EPile1:

		thrd.Create(_L("Pile1"),Pile1,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case ESession1:

		thrd.Create(_L("Session1"),Session1,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case ESession2:

		thrd.Create(_L("Session2"),Session2,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case ETypefaceStore1:

		thrd.Create(_L("TypefaceStore1"),TypefaceStore1,KDefaultStackSize,0x2000,0x2000,this);

		break;

	case EBadMessage:

		thrd.Create(_L("BadMessage"),BadMessage,KDefaultStackSize,0x2000,0x2000,this);

		break;

	default:

		User::Panic(_L("TCLEAN"),KErrArgument);

		}

	thrd.SetPriority(EPriorityMuchMore);

	thrd.Logon(stat);

	User::SetJustInTime(EFalse);

	thrd.Resume();

	User::WaitForRequest(stat);

	thrd.Close();

	User::SetJustInTime(ETrue);

	__UHEAP_MARKEND;

	}

//--------------

__CONSTRUCT_STEP__(Clean)