diff -r 000000000000 -r 5d03bc08d59c fbs/fontandbitmapserver/tfbs/TCLEAN.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fbs/fontandbitmapserver/tfbs/TCLEAN.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,495 @@ +// 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 (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 (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 (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 (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 (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 (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 (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 (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) +