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