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

//

/**

 @file

 @internalComponent - Internal Symbian test code

*/

#include "TFBS.H"

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

#include "../sfbs/fbshelper.h"

#include <shapeinfo.h>

#include <graphics/openfontrasterizer.h>

#include <graphics/openfontconstants.h>

#include "fbsdefs.h"

#include "fbsmessage.h"

TInt buffer[2];

_LIT(KFBSERVFontFileDir, "\\resource\\fonts\\");

_LIT(KTypefaceName, "DejaVu Sans Condensed");

// TLS Handle for TestFlushCallback test, from tfbsserver.mmp

const TInt KTlsHandle = 0x10273364;

#ifdef __WINS__

template<class C> XTCallCounter<C>::XTCallCounter(CTGraphicsBase& aTestBase)

	: iTestBase(aTestBase), iVFCallsOutsideFBServ(0)

	{}

template<class C> void XTCallCounter<C>::ExecuteShellcode(TInt aFromFunction)

	{

	const TUint32 KFBServId = 0x10003A16;

	const TUint32 KTFbsServerId = 0x10273364;

	TSecureId id = RProcess().SecureId();

	if (id != KFBServId)

		{

		User::LockedInc(iVFCallsOutsideFBServ);

		if (id == KTFbsServerId)

			{

			TBuf<128> name;

			XVtableInjector<C>::GetVirtualFunctionName(aFromFunction, name);

			iTestBase.INFO_PRINTF2(_L("Virtual function call to %S from outside FBServ"), &name);

			}

		}

	}

#endif

void CTFbs::DeleteScanLineBuffer()

	{

	delete iFbs->iScanLineBuffer;

	iFbs->iScanLineBuffer = 0;

	};

CTFbs::CTFbs(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iHandle(0),

	iFbs(NULL),

	iTs(NULL),

	iHeap(NULL),

	iFs(NULL),

	iResourceCount(0),

	iAllocs(0)

#ifdef __WINS__

	, iFontCallCounter(*this), iOpenFontCallCounter(*this)

#endif

	{

	}

void CTFbs::ConstructL()

	{

	ExpandCleanupStackL();

	TestConstruction();

	AllocScanLineBuf();

	INFO_PRINTF1(_L("FBSERV testing"));

	}

CTFbs::~CTFbs()

	{

	delete iTs;

	}

void CTFbs::RunTestCaseL(TInt aCurTestCase)

	{

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

	switch(aCurTestCase)

		{

	case 1:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0555"));

		TestConnection();

		break;

	case 2:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0558"));

		TestInvalidFiles();

		break;

	case 3:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0556"));

		TestFlushCallBack();

		break;

	case 4:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0568"));

		TestMultiThread();

		break;

	case 5:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0559"));

		TestGetFont();

		break;

	case 6:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0560"));

		TestFontStore();

		break;

	case 7:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-PREQ807_1_Load_all_fonts-0001"));

		TestAllFontsLoaded();

		break;

	case 8:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0561"));

		TestFontNameAlias();

		break;

	case 9:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0557"));

		TestAddFontFile();

		break;

	case 10:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0562"));

		TestBufferedFont();

		break;

	case 11:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0563"));

		TestMultipleFont();

		break;

	case 12:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0564"));

		TestCreateBitmap();

		break;

	case 13:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0565"));

		TestLoadBitmap();

		break;

	case 14:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0566"));

		TestQueryBitmap();

		TRAPD(errCode, TestRomBitmapL());

		if(errCode==KErrNone)

			{

			TestHeapCompression();

			}

		break;

	case 15:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0570"));

		TestDefaultLanguageForMetrics();		

		break;

	case 16:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-CTFbs-TestDuplicateFontFileEntries-0001"));

		TestDuplicateFontFileEntries();

		break;

	//COMMENTED OUT FOR NOW BECAUSE DEF084095 FIX MAKES THIS TEST REDUNDANT

	/*case 17:

		TestShapeHeaderMemoryLeakAtClientDeath();

		break;*/

	case 17:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0506"));

		TestBitmapHandleImmutable();

		break;

	case 18:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0507"));

		TestBitmapBeginEnd();

		break;

	case 19:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0508"));

		TestSingletonServer();

		break;

	case 21:

		TestFontSessionCacheLookupL();

		break;

	case 22:

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0650"));

		TestInvalidHandlesInIpcCallsL();

		break;

	case 23:

		// this one should always be the last test, since it checks the final virtual function call count

		((CTFbsStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0619"));

		TestNoVFCallsToGlobalObjects();

		break;

	case 24:

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

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

		TestComplete();		

		break;

		}

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

	}

CFbsFontEx* CTFbs::SelectFont()

	{

	CFbsFontEx* font=NULL;

	TInt ret=iTs->GetNearestFontToDesignHeightInPixels((CFont*&)font, TFontSpec(KTypefaceName, 15));

	TEST(ret==KErrNone);

#ifdef __WINS__

	CBitmapFont* bitmapFont = font->Address();

	iFontCallCounter.iInjector.InjectShellcode(bitmapFont, &iFontCallCounter);

	if (bitmapFont->IsOpenFont())

		{

		iOpenFontCallCounter.iInjector.InjectShellcode(bitmapFont->OpenFont(), &iOpenFontCallCounter);

		}

#endif

	TEST(font->MaxCharWidthInPixels()>0);

	TEST(font->MaxNormalCharWidthInPixels()>0);

	return(font);

	}

CFbsFontEx* CTFbs::SelectOpenTypeFont()

	{

	CFbsFontEx* font=NULL;

	TFontSpec fsp;

	fsp.iTypeface.iName=_L("Series 60 Sans");

	fsp.iHeight=15;

	TInt ret=iTs->GetNearestFontToDesignHeightInPixels((CFont*&)font,fsp);

	TEST(ret==KErrNone);

#ifdef __WINS__

	CBitmapFont* bitmapFont = font->Address();

	iFontCallCounter.iInjector.InjectShellcode(bitmapFont, &iFontCallCounter);

	if (bitmapFont->IsOpenFont())

		{

		iOpenFontCallCounter.iInjector.InjectShellcode(bitmapFont->OpenFont(), &iOpenFontCallCounter);

		}

#endif

	TEST(font->MaxCharWidthInPixels()>0);

	TEST(font->MaxNormalCharWidthInPixels()>0);

	return(font);

	}

void CTFbs::TestConstruction()

	{

	CFbsBitmap bmp;

	iTestBitmapName = KTestBitmapOnZ;

	TInt ret=bmp.Load(iTestBitmapName,ETfbs,NULL);

	if (ret != KErrNone)

		User::Panic(_L("Could not load bitmap"),ret);

	bmp.Reset();

	iFbs = RFbsSession::GetSession();

	TRAP(ret,iTs = (CFbsTypefaceStore*)CFbsTypefaceStore::NewL(NULL));

	TEST(iTs != NULL);

	CFbsFontEx* font = SelectFont();

	iTs->ReleaseFont(font);

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0555

	@SYMTestCaseDesc

	Tests the connections to the FbsSession

	@SYMTestActions

	Allocates a 100 RFbsSession objects and

	connects to the server and checks if

	all connections succeeded. Frees the memory

	and checks the heap memory.

	@SYMTestExpectedResults

	Test should pass

*/

void CTFbs::TestConnection()

	{

	INFO_PRINTF1(_L("class RFbsSession"));

	__UHEAP_MARK;

	const TInt numconnects=100;

	RFbsSession* connections=(RFbsSession*)User::Alloc(sizeof(RFbsSession)*numconnects);

	TEST(connections!=NULL);

	TInt count=0;

	for(;count<numconnects;count++)

		new(&connections[count]) RFbsSession;

	TEST(iFbs->ResourceCount()==0);

	for(count=0;count<numconnects;count++)

		{

		TInt ret=connections[count].Connect();

		if(ret!=KErrNone)

			break;

		}

	INFO_PRINTF2(_L("    %d connections created.\n"),count);

	TEST(iFbs->ResourceCount()==0);

	for(TInt count2=0;count2<count;count2++)

		connections[count2].Disconnect();

	TEST(iFbs->ResourceCount()==0);

	User::Free(connections);

	User::Heap().Check();

	__UHEAP_MARKEND;

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0556

	@SYMTestCaseDesc

	Tests if the flush callback function

	is called properly.

	@SYMTestActions

	Sets the flush callback, fills the cache with different

	fonts until the cache is full.

	Create one more font which forces an eviction of a font

	in the cache.

	Check call back is called.

	Reset the flush callback, create another new font,

	check that the callback was not called.

	Check for memory and resource leaks.

	@SYMTestExpectedResults

	Callback function should be called once at end of loop.

*/

void CTFbs::TestFlushCallBack()

	{

	INFO_PRINTF1(_L("Test Flush CallBack"));

	__UHEAP_MARK;

	CFbsTypefaceStore* tfs=NULL;

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

	TEST(ret==KErrNone);

	TEST(tfs!=NULL);

	UserSvr::DllSetTls(KTlsHandle, this);

	INFO_PRINTF1(_L("Testing Flush CallBack mechanism..."));

	iFbs->SetCallBack(TCallBack(FlushCallBack, NULL));

	CFbsFontEx* font=NULL;

	// Fill up the fontcache so that on the final iteration, the first 

	// font is evicted, thereby destroying it server-side and executing the 

	// callback.

	iFlushCallbackReceived = EFalse;

	TInt fontSize = 10;

	for (TInt fontEntries = 0; fontEntries < KMaxFontCacheEntries+1; fontEntries++)

		{

		ret=tfs->GetNearestFontToDesignHeightInTwips((CFont*&)font, TFontSpec(KTypefaceName, fontSize));

		TEST(ret==KErrNone);

		iResourceCount++;

		CheckResourceCount();

		tfs->ReleaseFont(font);

		fontSize += 15;

		}

	TEST(iFlushCallbackReceived);

	// Now check callback is correctly reset and callback function is not executed

	// when another font is evicted from the cache.

	// Resource count wont increase as although a new font is being created, another

	// will be evicted from the cache.

	iFlushCallbackReceived = EFalse;

	iFbs->ResetCallBack();

	ret=tfs->GetNearestFontToDesignHeightInTwips((CFont*&)font, TFontSpec(KTypefaceName, fontSize));

	TEST(ret==KErrNone);

	tfs->ReleaseFont(font);

	TEST(!iFlushCallbackReceived);

	CheckResourceCount();

	UserSvr::DllFreeTls(KTlsHandle);

	delete tfs;

	iResourceCount = 0;

	CheckResourceCount();

	__UHEAP_MARKEND;

	}

TInt CTFbs::FlushCallBack(TAny* /*aPtr*/)

	{

	CTFbs* tfbs = static_cast<CTFbs*>(UserSvr::DllTls(KTlsHandle));

	tfbs->INFO_PRINTF1(_L("    ...Flush CallBack called successfully"));

	tfbs->iFlushCallbackReceived = ETrue;

	--tfbs->iResourceCount;

	return(0);

	}

#ifdef __WINS__

_LIT(KCTFbsTestFont,"z:\\resource\\fonts\\eon14.gdr");

#else

_LIT(KCTFbsTestFont,"z:\\resource\\fonts\\eon.gdr");

#endif

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0557

	@SYMTestCaseDesc

	Tests adding of a font file

	to the font store

	@SYMTestActions

	Creates a type face store and adds

	font files to it. Checks if adding

	the files succeeded. Removes the files

	from the store. Checks if succeeded.

	@SYMTestExpectedResults

	Test should pass

*/

void CTFbs::TestAddFontFile()

	{

	INFO_PRINTF1(_L("Test Add File"));

	__UHEAP_MARK;

	CFbsTypefaceStore* tfs=NULL;

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

	TEST(ret==KErrNone);

	TEST(tfs!=NULL);

	TInt id1=0;

	TInt id2=0;

	TInt id3=0;

	TInt id4=0;

	ret=tfs->AddFile(KCTFbsTestFont,id1);

	TEST(ret==KErrNone);

	TEST(id1!=0);

	ret=tfs->AddFile(KCTFbsTestFont,id2);

	TEST(ret==KErrNone);

	TEST(id2==id1);

	ret=tfs->AddFile(KCTFbsTestFont,id3);

	TEST(ret==KErrNone);

	TEST(id3==id2);

	tfs->RemoveFile(id1);

	tfs->RemoveFile(id2);

	tfs->RemoveFile(id3);

	ret=tfs->AddFile(KCTFbsTestFont,id4);

	TEST(ret==KErrNone);

	TEST(id4==id1);

	tfs->RemoveFile(id4);

	delete tfs;

	__UHEAP_MARKEND;

	//test the sequence AddFile, GetNearestFont, ReleaseFont, RemoveFile

	CFbsTypefaceStore* tfs1=NULL;

    TRAPD(ret1,tfs1=CFbsTypefaceStore::NewL(NULL));

    TEST(ret1==KErrNone);

    TEST(tfs1!=NULL);

    TInt id5=0;

    ret1=tfs1->AddFile(_L("z:\\resource\\fonts\\DejaVuSerifCondensed.ttf"),id5);

    TEST(ret1==KErrNone);

    TEST(id5!=0);

    TInt id6=0;

    ret1=tfs1->AddFile(_L("z:\\resource\\fonts\\DejaVuSansCondensed.ttf"), id6);

    TEST(ret1==KErrNone);

    TEST(id6!=0);    

    TFontSpec fsp1;

    fsp1.iTypeface.iName=_L("DejaVu Serif Condensed");

    fsp1.iHeight=15;

    CFont* font1;

    ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font1,fsp1);

    TEST(ret1==KErrNone);

    TFontSpec fsp2;

    fsp2.iTypeface.iName=_L("DejaVu Serif Condensed");

    fsp2.iHeight=30;

    CFont *font2;

    ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font2,fsp2);

    TEST(ret1==KErrNone);

    TFontSpec fsp3;

    fsp3.iTypeface.iName=_L("DejaVu Sans Condensed");

    fsp3.iHeight=20;

    CFont *font3;

    ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font3,fsp3);

    TEST(ret1==KErrNone);

    TFontSpec fsp4;

    fsp4.iTypeface.iName=_L("DejaVu Serif Condensed");

    fsp4.iHeight=35;

    CFont *font4;

    ret1=tfs1->GetNearestFontToDesignHeightInTwips((CFont*&)font4,fsp4);

    TEST(ret1==KErrNone);

    if (font1)

        tfs1->ReleaseFont(font1);

    if (font2)

        tfs1->ReleaseFont(font2);

    if (font4)

        tfs1->ReleaseFont(font4);

    if (id6)

        tfs1->RemoveFile(id6);

    if (id5)

        tfs1->RemoveFile(id5);

    delete tfs1;

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0558

	@SYMTestCaseDesc

	Tries to add and load a nonexisting 

	file to the FbsTypeFaceStore and checks

	if it fails.

	@SYMTestActions

	@SYMTestExpectedResults

	Test should pass

*/

void CTFbs::TestInvalidFiles()

	{

	INFO_PRINTF1(_L("Test Invalid Files"));

	__UHEAP_MARK;

	CFbsTypefaceStore* tfs=NULL;

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

	TEST(ret==KErrNone);

	TEST(tfs!=NULL);

	TInt id=0;

	ret=tfs->AddFile(_L("\\nonexist.gdr"),id);

	TEST(ret!=KErrNone);

	delete tfs;

	CFbsBitmapEx bmp;

	ret=bmp.Load(_L("\\nonexist.mbm"),0);