diff -r 000000000000 -r 5d03bc08d59c fbs/fontandbitmapserver/tfbs/trfile.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fbs/fontandbitmapserver/tfbs/trfile.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,584 @@ +// Copyright (c) 2005-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 +#include +#include +#include +#include +#include "../sfbs/UTILS.H" +#include "trfile.h" +#include "fbsmessage.h" +#include "fbsdefs.h" + +// Define FBSTEST_SCREENSHOT to save the screen to a .mbm file +//#define FBSTEST_SCREENSHOT + +const TInt KNumBitmap = 3; +const TDisplayMode KDisplayMode = EColor64K; +const TSize KLargeSize(128,128); +const TSize KMidSize(64,64); +const TSize KSmallSize(32,32); + + +_LIT(KRamFile1,"c:\\rf1.mbm"); +_LIT(KRamFile2,"c:\\rf2.mbm"); +_LIT(KRamFile3,"c:\\rf3.mbm"); +_LIT(KRamFile4,"c:\\rf123.mbm"); +_LIT(KRomFile1,"z:\\system\\data\\rf1.mbm"); +_LIT(KRomFile2,"z:\\system\\data\\rf2.mbm"); +_LIT(KRomFile3,"z:\\system\\data\\rf3.mbm"); +_LIT(KRomFile4,"z:\\system\\data\\rf123.mbm"); + + +CTFile::CTFile(CTestStep* aStep): + CTGraphicsBase(aStep), + iFbs(NULL), + iSource(KNumBitmap) + { + } + +CTFile::~CTFile() + { + CleanUp(); + if (iShutdownFbs) + iFbs->SendCommand(EFbsMessShutdown); + iFbs->Disconnect(); + } + + +void CTFile::ConstructL() + { + if(RFbsSession::Connect()==KErrNone) + { + RFbsSession::Disconnect(); + iShutdownFbs = EFalse; + } + else + { + FbsStartup(); + iShutdownFbs = ETrue; + } + + TInt ret = RFbsSession::Connect(); + TEST(ret==KErrNone); + iFbs = RFbsSession::GetSession(); + TEST(iFbs != NULL); + + ret = iFs.Connect(); + TEST(ret==KErrNone); + // required to allow file handle to be adopted by another process + iFs.ShareProtected(); + + TUint32* romAddress = NULL; + if(!CFbsBitmap::IsFileInRom(KRomFile1, romAddress)) //any ROM bitmap + { + INFO_PRINTF2(_L("Skipping ROM bitmap tests since file \"%S\" is reported to not be a ROM bitmap."), + &KRomFile1); + INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported.")); + iSkipRomBitmapTests = ETrue; + } + } + +void CTFile::CleanUp() + { + const TBufC<32> names[KNumBitmap] = + { + (const TDesC&)KRamFile1, + (const TDesC&)KRamFile2, + (const TDesC&)KRamFile3 + }; + TInt i; + for (i=0; iSetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: + ((CTFileStep*)iStep)->SetTestStepID(_L(" GRAPHICS-FBSERV-0588")); + CreateL(); + break; + case 2: + ((CTFileStep*)iStep)->SetTestStepID(_L(" GRAPHICS-FBSERV-0589")); + SaveL(); + break; + case 3: + ((CTFileStep*)iStep)->SetTestStepID(_L(" GRAPHICS-FBSERV-0590")); + StoreL(); + break; + case 4: + ((CTFileStep*)iStep)->SetTestStepID(_L(" GRAPHICS-FBSERV-0591")); + LoadL(); + break; + case 5: + ((CTFileStep*)iStep)->SetTestStepID(_L(" GRAPHICS-FBSERV-0592")); + LoadAndCompressL(); + break; + case 6: + ((CTFileStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTFileStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTFileStep*)iStep)->RecordTestResultL(); + } + + +/** + Draw union jack +*/ +void CTFile::Draw(CFbsBitGc* aGc, const TSize& aSize) + { + const TSize thick(aSize.iWidth/4,aSize.iWidth/4); + const TSize thin(thick.iWidth/2,thick.iWidth/2); + + // background + aGc->SetBrushColor(KRgbBlue); + aGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + aGc->SetPenStyle(CGraphicsContext::ESolidPen); + aGc->DrawRect(aSize); + + // corner to corner section + aGc->SetPenColor(KRgbWhite); + aGc->SetPenSize(thick); + aGc->DrawLine(TPoint(0,0),TPoint(aSize.iWidth,aSize.iHeight)); + aGc->DrawLine(TPoint(aSize.iWidth,0),TPoint(0,aSize.iHeight)); + aGc->SetPenColor(KRgbRed); + aGc->SetPenSize(thin); + aGc->DrawLine(TPoint(0,0),TPoint(aSize.iWidth,aSize.iHeight)); + aGc->DrawLine(TPoint(aSize.iWidth,0),TPoint(0,aSize.iHeight)); + + // cross section + aGc->SetPenColor(KRgbWhite); + aGc->SetPenSize(thick); + aGc->DrawLine(TPoint(aSize.iWidth/2,0),TPoint(aSize.iWidth/2,aSize.iHeight)); + aGc->DrawLine(TPoint(0,aSize.iHeight/2),TPoint(aSize.iWidth,aSize.iHeight/2)); + aGc->SetPenColor(KRgbRed); + aGc->SetPenSize(thin); + aGc->DrawLine(TPoint(aSize.iWidth/2,0),TPoint(aSize.iWidth/2,aSize.iHeight)); + aGc->DrawLine(TPoint(0,aSize.iHeight/2),TPoint(aSize.iWidth,aSize.iHeight/2)); + } + +/** + +*/ +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0588 + + @SYMTestCaseDesc + Create various size bitmap for testing (original bitmaps) + ie small (<4KB), mid (=4KB) and large (>4KB). + + @SYMTestActions + + @SYMTestExpectedResults + Test should pass +*/ +void CTFile::CreateL() + { + const TSize sizes[KNumBitmap] = + { + KSmallSize, + KMidSize, + KLargeSize + }; + TInt i; + for (i=0; iCreate(sizes[i],KDisplayMode)); + + CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(bmp); + CleanupStack::PushL(dev); + + CFbsBitGc* gc; + User::LeaveIfError(dev->CreateContext(gc)); + + Draw(gc,sizes[i]); + + delete gc; + CleanupStack::PopAndDestroy(dev); + + iSource.AppendL(bmp); + + CleanupStack::Pop(bmp); + } + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0589 + + @SYMTestCaseDesc + Save single bitmap to file using an opened file handle + + @SYMTestActions + Save original bitmap to file using file handle (saved bitmap) + Load saved bitmap using file name and compare against original + Leave saved bitmap files for next test (Load,LoadAndCompress) + + @SYMTestExpectedResults + Saved bitmap match original bitmap +*/ +void CTFile::SaveL() + { + const TBufC<32> names[KNumBitmap] = + { + (const TDesC&)KRamFile1, + (const TDesC&)KRamFile2, + (const TDesC&)KRamFile3 + }; + + INFO_PRINTF1(_L("Saving bitmap")); + TInt i; + for (i=0; iSave(f)==KErrNone); + f.Close(); + + CFbsBitmap bmp; + TEST(bmp.Load(names[i])==KErrNone); + + CFbsBitmap* orig = iSource[i]; + TSize size = orig->SizeInPixels(); + TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight; + orig->LockHeap(); + bmp.LockHeap(); + TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0); + orig->UnlockHeap(); + bmp.UnlockHeap(); + } + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0590 + + @SYMTestCaseDesc + Save multi bitmaps to file using an opened file handle. + + @SYMTestActions + Save original bitmaps to file (saved bitmaps). + Load saved bitmaps and compare it against originals. + + @SYMTestExpectedResults + Saved bitmaps match original bitmaps +*/ +void CTFile::StoreL() + { + const TBufC<32> names[KNumBitmap] = + { + (const TDesC&)KRamFile1, + (const TDesC&)KRamFile2, + (const TDesC&)KRamFile3 + }; + INFO_PRINTF1(_L("Storing bitmaps")); + RFile f; + TInt mode = EFileWrite; + TInt ret = f.Open(iFs,KRamFile4,mode); + if (ret==KErrNotFound) + ret = f.Create(iFs,KRamFile4,mode); + TEST(ret==KErrNone); + + const TDesC* bmps[] = {&names[0],&names[1],&names[2]}; + TInt32 ids[] = {0,0,0}; + TRAP(ret,CFbsBitmap::StoreL(f,KNumBitmap,bmps,ids)); + TEST(ret==KErrNone); + f.Close(); + + TInt id; + for (id=0; idSizeInPixels(); + TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight; + orig->LockHeap(); + bmp.LockHeap(); + TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0); + orig->UnlockHeap(); + bmp.UnlockHeap(); + } + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0591 + + @SYMTestCaseDesc + Load bitmap from file using an opened file handle. + + @SYMTestActions + Load bitmap using file handle. + Compare loaded bitmaps against original. + + @SYMTestExpectedResults + Loaded bitmap match original +*/ +void CTFile::LoadL() + { + // Load single bitmap file + const TBufC<32> names[2*KNumBitmap] = + { + (const TDesC&)KRamFile1, //keep ram files at the top to make it easier to skip rom bitmaps + (const TDesC&)KRamFile2, + (const TDesC&)KRamFile3, + (const TDesC&)KRomFile1, + (const TDesC&)KRomFile2, + (const TDesC&)KRomFile3 + }; + INFO_PRINTF1(_L("Loading bitmaps")); + TInt i; + TInt maxIndex = (iSkipRomBitmapTests ? KNumBitmap - 1 : 2 * KNumBitmap - 1); + for (i=0; i <= maxIndex; ++i) + { + RFile f; + TInt mode = EFileShareReadersOnly; + TInt ret = f.Open(iFs,names[i],mode); + TEST(ret==KErrNone); + CFbsBitmap bmp; + TEST(bmp.Load(f)==KErrNone); + f.Close(); + + CFbsBitmap* orig = iSource[i%KNumBitmap]; + TSize size = orig->SizeInPixels(); + TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight; + orig->LockHeap(); + bmp.LockHeap(); + TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0); + orig->UnlockHeap(); + bmp.UnlockHeap(); + } + + // Load multi bitmap file + const TBufC<32> mbm[] = + { + (const TDesC&)KRamFile4, //keep ram files at the top to make it easier to skip rom bitmaps + (const TDesC&)KRomFile4 + }; + maxIndex = (iSkipRomBitmapTests ? 0 : 1); + for (i=0; i <= maxIndex; ++i) + { + RFile f; + TInt mode = EFileShareReadersOnly; + TInt ret = f.Open(iFs,mbm[i],mode); + TEST(ret==KErrNone); + TInt id; + for (id=0; idSizeInPixels(); + TInt bytes = orig->ScanLineLength(size.iWidth,KDisplayMode)*size.iHeight; + orig->LockHeap(); + bmp.LockHeap(); + TEST(Mem::Compare((TUint8*)orig->DataAddress(),bytes,(TUint8*)bmp.DataAddress(),bytes)==0); + orig->UnlockHeap(); + bmp.UnlockHeap(); + } + f.Close(); + } + } + +/** + @SYMTestCaseID + GRAPHICS-FBSERV-0592 + + @SYMTestCaseDesc + Load and compress bitmap from file using an opened file handle. + + @SYMTestActions + Compress original bitmap. + Load and compress bitmap using file handle. + Blit loaded+compressed bitmaps and compressed original to screen. + Compare screen area. + + @SYMTestExpectedResults + LoadAndCompress ROM file return KErrAccessDenied. + Drawn bitmap on screen match. +*/ +void CTFile::LoadAndCompressL() + { + INFO_PRINTF1(_L("Loading and compressing bitmaps")); + + RFile f; + TInt ret = KErrNone; + if(!iSkipRomBitmapTests) + { + // load and compress ROM file + ret = f.Open(iFs,KRomFile1,EFileShareReadersOnly); + TEST(ret==KErrNone); + CFbsBitmap bmp; + TEST(bmp.LoadAndCompress(f)==KErrAccessDenied); + f.Close(); + } + + // load single bitmap file + const TBufC<32> names[KNumBitmap] = + { + (const TDesC&)KRamFile1, + (const TDesC&)KRamFile2, + (const TDesC&)KRamFile3 + }; + TInt i; + for (i=0; iCompress()==KErrNone); + TEST(orig->IsCompressedInRAM()); + + TRAP(ret,BlitAndCompareL(orig,&bmp,orig->SizeInPixels())); + TEST(ret==KErrNone); + } + // Load multi bitmap KRamFile4 + ret = f.Open(iFs,KRamFile4,EFileShareReadersOnly); + TEST(ret==KErrNone); + TInt id; + for (id=0; idCompress()==KErrNone); + TEST(orig->IsCompressedInRAM()); + + TRAP(ret,BlitAndCompareL(orig,&bmp,orig->SizeInPixels())); + TEST(ret==KErrNone); + } + f.Close(); + } + +/** + Blit two bitmap to screen device and compare if both match +*/ +void CTFile::BlitAndCompareL(CFbsBitmap* aBmpOrig,CFbsBitmap* aBmpTest,const TSize& aBmpSize) + { + CFbsScreenDevice* scd=NULL; + TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,KDisplayMode)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to create screen device for mode %S err=%d"); + INFO_PRINTF3(KLog,&ColorModeName(KDisplayMode),err); + } + if (err==KErrNotSupported) + { + TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,EColor256)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to create Color256 screen device err=%d"); + INFO_PRINTF2(KLog,err); + } + } + if (err==KErrNotSupported) + { + TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,EColor16MA)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to create Color16MA screen device err=%d"); + INFO_PRINTF2(KLog,err); + } + } + if (err==KErrNotSupported) + { + TRAPD(err,scd=CFbsScreenDevice::NewL(KDefaultScreenNo,EColor16MAP)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to create Color16MA screen device err=%d"); + INFO_PRINTF2(KLog,err); + } + } + _LIT(KLog,"Create screen device with mode %S"); + INFO_PRINTF2(KLog,&ColorModeName(scd->DisplayMode())); + CleanupStack::PushL(scd); + scd->ChangeScreenDevice(NULL); + CFbsBitGc* sgc; + User::LeaveIfError(scd->CreateContext((CGraphicsContext*&)sgc)); + CleanupStack::PushL(sgc); + + TSize scrSize = scd->SizeInPixels(); + TPoint left(0,0); + TPoint right(scrSize.iWidth/2,0); + TRect bmpRect(TPoint(0,0),aBmpSize); + + // if bitmap width is greater than half screen width, + // try positioning right bitmap below original. + if (scrSize.iWidth < aBmpSize.iWidth*2) + { + if (scrSize.iHeight < aBmpSize.iHeight/2) + { + //That still doesn't work out, so restrict size of rect + // being blitted to half screen size. + INFO_PRINTF1(_L("Warning: the whole of the test images may not be compared")); + bmpRect = TRect(TPoint(0,0),TSize(scrSize.iWidth/2,aBmpSize.iHeight)); + } + else + { + right = TPoint(0, scrSize.iHeight/2); + } + } + + sgc->BitBlt(left, aBmpOrig, bmpRect); + sgc->BitBlt(right, aBmpTest, bmpRect); + scd->Update(); + +#ifdef FBSTEST_SCREENSHOT + SaveScreenShotL(scd); +#endif //FBSTEST_SCREENSHOT + + TBool match=scd->RectCompare(TRect(left,bmpRect.Size()),*scd,TRect(right,bmpRect.Size())); + if (!match) + { + _LIT(KLog,"Two areas of the screen don't match"); + INFO_PRINTF1(KLog); + } + TEST(match); + + CleanupStack::PopAndDestroy(2,scd); + } + +//-------------- +__CONSTRUCT_STEP__(File)