diff -r 000000000000 -r bde4ae8d615e os/graphics/fbs/fontandbitmapserver/tfbs/textendedbitmaplegacy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/fbs/fontandbitmapserver/tfbs/textendedbitmaplegacy.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,830 @@ +// Copyright (c) 2008-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 "textendedbitmapcommon.h" +#include "textendedbitmaplegacy.h" +#include "tfbs.h" +#include +#include + +const TUint8 KTestData[] = "Extended bitmap test data 123456"; +const TInt KTestDataSize = sizeof(KTestData); +const TInt KTestWidth = 50; +const TInt KTestHeight = 50; +const TSize KSizeInPixels = TSize(KTestWidth,KTestHeight); +const TDisplayMode KDisplayMode = EColor64K; +const TInt KBpp = 2; // 2 bpp for EColor64K + +// Test mbm files used by CTExtendedBitmapLegacy::TestApisThatCallResetL(). +// These are used to check the operation of CFbsBitmap::Load() when used with +// extended bitmaps. +_LIT(KRomBmpFilename, "z:\\system\\data\\rf1.mbm"); +_LIT(KRamBitmapFilenameOnZ, "z:\\system\\data\\16RAM2.mbm"); +_LIT(KRamBitmapFilename, "c:\\textendedbitmaplegacy_16RAM2.mbm"); + +LOCAL_D RFs TheFs; + +CTExtendedBitmapLegacy::CTExtendedBitmapLegacy(CTestStep* aStep): + CTFbsBase(aStep, ETrue) + { + } + +CTExtendedBitmapLegacy::~CTExtendedBitmapLegacy() + { + ((CTExtendedBitmapLegacyStep*)iStep)->CloseTMSGraphicsStep(); + } + +void CTExtendedBitmapLegacy::RunFbsTestL(TInt aCurTestCase) + { + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0030")); + TestDuplicateL(); + break; + case 2: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0031")); + TestAccessDeniedL(); + break; + case 3: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0032")); + TestNotSupportedL(); + break; + case 4: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0033")); + TestTwipsL(); + break; + case 5: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0034")); + TestGettersL(); + break; + case 6: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0035")); + TestGetScanLineL(); + break; + case 7: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0036")); + TestApisThatCallResetL(); + break; + case 8: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0037")); + TestApisThatLeaveL(); + break; + case 9: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0038")); + TestNotSupportedNoReturnL(); + break; + case 10: + ((CTExtendedBitmapLegacyStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0039")); + TestGetPixelL(); + // Fall through as last test case + default: + SetLastTestCase(); + break; + } + ((CTExtendedBitmapLegacyStep*)iStep)->RecordTestResultL(); + } + + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0030 + +@SYMTestCaseDesc + Create an extended bitmap then duplicate it by calling CFbsBitmap::Duplicate() + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid. + Call Duplicate() on the extended bitmap. + Retrieves and validates the bitmap size, display mode, Uid, data and data size. + +@SYMTestExpectedResults + Extended bitmap created and duplicated and information should match exactly. +*/ +void CTExtendedBitmapLegacy::TestDuplicateL() + { + INFO_PRINTF1(_L("Duplicate - create a duplicate of an extended bitmap")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + CFbsBitmap* duplicateBmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(duplicateBmp); + err = duplicateBmp->Duplicate(bmp->Handle()); + TESTNOERRORL(err); + + // check that the size, display mode etc are all correct + TESTSIZEEQUALL(duplicateBmp->SizeInPixels(), KSizeInPixels); + TESTEQUALL(duplicateBmp->DisplayMode(), KDisplayMode); + TESTEQUALL(duplicateBmp->DisplayMode(), KDisplayMode); + TESTEQUALL(duplicateBmp->ExtendedBitmapType(), KUidTestExtendedBitmap); + + duplicateBmp->BeginDataAccess(); + + const TUint8* returnedDataAddress = reinterpret_cast(duplicateBmp->DataAddress()); + TESTNOTEQUALL(returnedDataAddress, NULL); + + // compare the size of the data in the duplicate bitmap with the size of the original data, they should be the same + TInt returnedDataSize = duplicateBmp->DataSize(); + TESTEQUALL(returnedDataSize, KTestDataSize); + + // compare the data returned from the duplicate bitmap with the original data, they should be the same + TInt res = Mem::Compare(returnedDataAddress, returnedDataSize, KTestData, KTestDataSize); + TESTEQUALL(res, 0); + + duplicateBmp->EndDataAccess(ETrue); + + CleanupStack::PopAndDestroy(2, bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0031 + +@SYMTestCaseDesc + Test that all the legacy CFbsBitmap APIs (i.e. APIs that existed before PREQ2096) + that should return KErrAccessDenied for an extended bitmap do so correctly. + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10856 + REQ10857 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid. + Call all the legacy APIs that should return KErrAccessDenied: + - Resize() + - Compress() + - CompressInBackground() + - SwapWidthAndHeight() + +@SYMTestExpectedResults + The legacy APIs tested should all return KErrAccessDenied. +*/ +void CTExtendedBitmapLegacy::TestAccessDeniedL() + { + INFO_PRINTF1(_L("AccessDenied - test legacy CFbsBitmap APIs that should return KErrAccessDenied when used with an extended bitmap")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + INFO_PRINTF1(_L("Resize()")); + err = bmp->Resize(TSize(100,100)); + TESTEXPECTEDERRORL(err, KErrAccessDenied); + + // This covers both versions of Compress() as one calls the other + INFO_PRINTF1(_L("Compress()")); + err = bmp->Compress(); + TESTEXPECTEDERRORL(err, KErrAccessDenied); + + // This covers both synchronous versions of CompressInBackground() as one calls the other + INFO_PRINTF1(_L("CompressInBackground()")); + err = bmp->CompressInBackground(); + TESTEXPECTEDERRORL(err, KErrAccessDenied); + + // This covers both asynchronous versions of CompressInBackground() as one calls the other + INFO_PRINTF1(_L("CompressInBackground() (asynchronous)")); + TRequestStatus requestStatus; + bmp->CompressInBackground(requestStatus); + User::WaitForRequest(requestStatus); + TESTEXPECTEDERRORL(requestStatus.Int(), KErrAccessDenied); + + INFO_PRINTF1(_L("SwapWidthAndHeight()")); + err = bmp->SwapWidthAndHeight(); + TESTEXPECTEDERRORL(err, KErrAccessDenied); + + CleanupStack::PopAndDestroy(bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0032 + +@SYMTestCaseDesc + Test that all the legacy CFbsBitmap APIs (i.e. APIs that existted before PREQ2096) + that should return KErrNotSupported for an extended bitmap do so correctly, or + if they have no return value and are not supported that they return cleanly. + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10856 + REQ10857 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid. + Call all the legacy APIs that should return KErrNotSupported: + - Save() + - GetPalette() + - SetDisplayMode() + +@SYMTestExpectedResults + The legacy APIs tested should all return KErrNotSupported where they have return + values, they should not cause errors where they are not supported but don't return + an error value. +*/ +void CTExtendedBitmapLegacy::TestNotSupportedL() + { + INFO_PRINTF1(_L("NotSupported - test legacy CFbsBitmap APIs that are not supported when used with an extended bitmap")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + // Methods that should return KErrNotSupported + INFO_PRINTF1(_L("Save() - filename")); + _LIT(KFilename, "C:\\temp.mbm"); + TESTEXPECTEDERRORL(bmp->Save(KFilename), KErrNotSupported); + + INFO_PRINTF1(_L("Save() - RFile")); + RFile file; + err = file.Open(TheFs, KFilename, EFileWrite); + TESTNOERRORL(err); + CleanupClosePushL(file); + TESTEXPECTEDERRORL(bmp->Save(file), KErrNotSupported); + CleanupStack::PopAndDestroy(&file); + + INFO_PRINTF1(_L("GetPalette()")); + CPalette* palette; + TESTEXPECTEDERRORL(bmp->GetPalette(palette), KErrNotSupported); + + INFO_PRINTF1(_L("SetDisplayMode()")); + err = bmp->SetDisplayMode(EColor16MU); + TESTEXPECTEDERRORL(err, KErrNotSupported); + + + CleanupStack::PopAndDestroy(bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0033 + +@SYMTestCaseDesc + Test that all CFbsBitmap methods that mention Twips work correctly with extended bitmaps. + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10857 + REQ10858 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid. + Call all the legacy APIs that mention Twips: + - SetSizeInTwips() + - SizeInTwips() + - HorizontalPixelsToTwips() + - HorizontalTwipsToPixels() + - VerticalPixelsToTwips() + - VerticalTwipsToPixels() + +@SYMTestExpectedResults + All methods should work correctly with extended bitmaps. +*/ +void CTExtendedBitmapLegacy::TestTwipsL() + { + INFO_PRINTF1(_L("Twips - test legacy CFbsBitmap Twips APIs work correctly when used with an extended bitmap")); + const TSize KSizeInTwips(20,30); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + INFO_PRINTF1(_L("SetSizeInTwips()")); + bmp->SetSizeInTwips(KSizeInTwips); + + INFO_PRINTF1(_L("SizeInTwips()")); + TESTSIZEEQUALL(bmp->SizeInTwips(), KSizeInTwips); + + INFO_PRINTF1(_L("HorizontalPixelsToTwips()")); + TESTEQUALL(bmp->HorizontalPixelsToTwips(KSizeInPixels.iWidth), KSizeInTwips.iWidth); + + INFO_PRINTF1(_L("HorizontalTwipsToPixels()")); + TESTEQUALL(bmp->HorizontalTwipsToPixels(KSizeInTwips.iWidth), KSizeInPixels.iWidth); + + INFO_PRINTF1(_L("VerticalPixelsToTwips()")); + TESTEQUALL(bmp->VerticalPixelsToTwips(KSizeInPixels.iHeight), KSizeInTwips.iHeight); + + INFO_PRINTF1(_L("VerticalTwipsToPixels()")); + TESTEQUALL(bmp->VerticalTwipsToPixels(KSizeInTwips.iHeight), KSizeInPixels.iHeight); + + const TDisplayMode displayMode[] = {EColor256, EColor4K, EColor16M, EColor16MU, EColor64K, + EGray256, EGray16, EGray4, EGray2, EColor16, EColor16MA, EColor16MAP}; + TInt ii = 0; + err = KErrNotSupported; + CFbsScreenDevice* scd = NULL; + for(;(iiSetSizeInTwips(scd); + + delete scd; + CleanupStack::PopAndDestroy(1, bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0034 + +@SYMTestCaseDesc + Test the simple getter CFbsBitmap APIs such as Handle(). + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10857 + REQ10858 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid. + Call the following simple getter APIs: + - InitialDisplayMode() + - IsRomBitmap() + - Handle() + - Header() + - IsLargeBitmap() + - DataStride() + - HardwareBitmapHandle() + - SerialNumber() + - IsCompressedInRAM() + - GetAllBitmapHandles() + +@SYMTestExpectedResults + No errors should occur. +*/ +void CTExtendedBitmapLegacy::TestGettersL() + { + INFO_PRINTF1(_L("Test simple getter APIs")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + INFO_PRINTF1(_L("InitialDisplayMode()")); + TESTEQUALL(bmp->InitialDisplayMode(), KDisplayMode); + + INFO_PRINTF1(_L("IsRomBitmap()")); + TESTTRUEL(bmp->IsRomBitmap()); + + INFO_PRINTF1(_L("Handle()")); + TESTNOTEQUALL(bmp->Handle(), 0); + + INFO_PRINTF1(_L("Header()")); + SEpocBitmapHeader header = bmp->Header(); + TESTSIZEEQUALL(header.iSizeInPixels, KSizeInPixels); + TESTSIZEEQUALL(header.iSizeInTwips, TSize(0,0)); + TESTEQUALL(header.iBitsPerPixel, 16); + TESTEQUALL(header.iColor, 1); + TESTEQUALL(header.iPaletteEntries, 0); + TESTEQUALL(header.iCompression, EProprietaryCompression); + + INFO_PRINTF1(_L("IsLargeBitmap()")); + TESTTRUEL(bmp->IsLargeBitmap()); + + INFO_PRINTF1(_L("DataStride()")); + TESTEQUALL(bmp->DataStride(), KSizeInPixels.iWidth*KBpp); + + INFO_PRINTF1(_L("HardwareBitmapHandle()")); + TESTEQUALL(bmp->HardwareBitmapHandle(), 0); + + INFO_PRINTF1(_L("SerialNumber()")); + TESTNOTEQUALL(bmp->SerialNumber(), 0); + + INFO_PRINTF1(_L("IsCompressedInRAM()")); + TESTEQUALL(bmp->IsCompressedInRAM(), EFalse); + + // The touch count changes for a bitmap (not a ROM bitmap) when it is resized etc, it should not change + // when Resize() is called on an extended bitmap + INFO_PRINTF1(_L("TouchCount()")); + TESTEQUALL(bmp->TouchCount(), 0); + bmp->Resize(TSize(100,100)); + TESTEQUALL(bmp->TouchCount(), 0); + + // Bitmaps (not ROM bitmaps) become volatile if DataAddress() is called outside BeginDataAccess() and EndDataAccess(), + // should never be set for extended bitmaps + INFO_PRINTF1(_L("IsVolatile()")); + TESTEQUALL(bmp->IsVolatile(), EFalse); + bmp->DataAddress(); + TESTEQUALL(bmp->IsVolatile(), EFalse); + + RArray handles; + CleanupClosePushL(handles); + INFO_PRINTF1(_L("GetAllBitmapHandles()")); + TESTNOERRORL(bmp->GetAllBitmapHandles(handles)); + TESTTRUEL(handles.Count() > 0); + + CleanupStack::PopAndDestroy(2, bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0035 + +@SYMTestCaseDesc + Test GetScanLine with extended bitmaps where no rasterizer is present. + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10857 + REQ10858 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid that is not supported by a rasterizer. + Call GetScanLine(). + +@SYMTestExpectedResults + GetScanLine() should return a white scanline of the length requested, no errors should occur. +*/ +void CTExtendedBitmapLegacy::TestGetScanLineL() + { + INFO_PRINTF1(_L("Test CFbsBitmap::GetScanLine() where there is no supported rasterizer for the passed extended bitmap Uid")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + const TInt KScanlineLength = KTestWidth*KBpp; + TBuf8 buf; + bmp->GetScanLine(buf, TPoint(0,0), KTestWidth, KDisplayMode); + TESTEQUALL(buf.Size(), KScanlineLength); + + // Check that the scanline has been set to white + for (TInt i = 0; i < KScanlineLength; i++) + { + TESTEQUALL(buf[i], 255); + } + + CleanupStack::PopAndDestroy(bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0036 + +@SYMTestCaseDesc + Test an extended bitmap with all of the CFbsBitmap APIs that call Reset(). + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + For each API: + - Create an extended bitmap using test data and test Uid that is not supported by a rasterizer. + - Call the API. + The following APIs are tested: + - Load() + - LoadAndCompress() + - Internalize() + - SetRomBitmapL() + +@SYMTestExpectedResults + All APIs tested should complete with no errors, the resultant CFbsBitmap + should not be an extended bitmap as it will have been reset. +*/ +void CTExtendedBitmapLegacy::TestApisThatCallResetL() + { + INFO_PRINTF1(_L("Test CFbsBitmap APIs that Call Reset()")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + TESTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); + + INFO_PRINTF1(_L("Load()")); + err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + TESTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should be an extended bitmap again + TESTNOERRORL(bmp->Load(KRamBitmapFilename)); + TESTNOTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should no longer be an extended bitmap + + INFO_PRINTF1(_L("LoadAndCompress()")); + err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + TESTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should be an extended bitmap again + TESTNOERRORL(bmp->LoadAndCompress(KRamBitmapFilename)); + TESTNOTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should no longer be an extended bitmap + + INFO_PRINTF1(_L("InternalizeL()")); + CBufFlat* buf = CBufFlat::NewL(512); + CleanupStack::PushL(buf); + RBufWriteStream writeStream(*buf,0); + bmp->ExternalizeL(writeStream); // externalize a normal bitmap + writeStream.Close(); + err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + TESTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should be an extended bitmap again + RBufReadStream readStream(*buf,0); + bmp->InternalizeL(readStream); + readStream.Close(); + TESTNOTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should no longer be an extended bitmap + + TUint32* romAddress = NULL; + if(!CFbsBitmap::IsFileInRom(KRomBmpFilename, romAddress)) //check any rom bitmap + { + INFO_PRINTF2(_L("Skipping tests of ROM bitmaps since file \"%S\" is reported to not be a ROM bitmap."), &KRomBmpFilename); + INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported.")); + } + else + { + INFO_PRINTF1(_L("SetRomBitmapL()")); + CFbsBitmapEx* romBitmap = new(ELeave) CFbsBitmapEx; + CleanupStack::PushL(romBitmap); + INFO_PRINTF2(_L("... attempting to load %S"), &KRomBmpFilename); + err = romBitmap->Load(KRomBmpFilename); + TESTNOERRORL(err); + TInt size = 0; + INFO_PRINTF1(_L("... calling SetRomBitmapL()")); + bmp->SetRomBitmapL(romBitmap->BitmapAddress(), size); + TESTNOTEQUALL(bmp->ExtendedBitmapType(), KUidTestExtendedBitmap); // should no longer be an extended bitmap + TEST(bmp->SerialNumber() == -TInt64(static_cast(bmp->Handle()))); // A ROM bitmap's handle is its address pointer, its serial number is -ve the address pointer + + CleanupStack::PopAndDestroy(1, romBitmap); + } + + CleanupStack::PopAndDestroy(2, bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0037 + +@SYMTestCaseDesc + Test the CFbsBitmap APIs that should leave when called by an extended bitmap. + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10856 + REQ10857 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + For each API: + - Create an extended bitmap using test data and test Uid that is not supported by a rasterizer. + - Call the API. + The following APIs are tested: + - ExternalizeL() + - ExternalizeRectangleL() + +@SYMTestExpectedResults + All APIs tested should leave with the error KErrNotSupported. +*/ +void CTExtendedBitmapLegacy::TestApisThatLeaveL() + { + INFO_PRINTF1(_L("ApisThatLeave - test legacy CFbsBitmap APIs that leave when used with an extended bitmap")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + INFO_PRINTF1(_L("ExternalizeL()")); + CBufFlat* buf = CBufFlat::NewL(512); + CleanupStack::PushL(buf); + RBufWriteStream writeStream(*buf,0); + CleanupClosePushL(writeStream); + TRAP(err, bmp->ExternalizeL(writeStream)); + TESTEXPECTEDERRORL(err, KErrNotSupported); + + INFO_PRINTF1(_L("ExternalizeRectangleL()")); + RBufWriteStream writeStream2(*buf,0); + CleanupClosePushL(writeStream2); + TRAP(err, bmp->ExternalizeRectangleL(writeStream2, TRect(10,10,100,100))); + TESTEXPECTEDERRORL(err, KErrNotSupported); + + CleanupStack::PopAndDestroy(4, bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0038 + +@SYMTestCaseDesc + Test that APIs that do not return an error value or leave, yet are not supported + for extended bitmaps, do not cause an error. + +@SYMPREQ + PREQ2096 + +@SYMREQ + REQ10847 + REQ10856 + REQ10857 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + For each API: + - Create an extended bitmap using test data and test Uid that is not supported by a rasterizer. + - Call the API. + The following APIs are tested: + - PaletteAttributes() + - SetPalette() + +@SYMTestExpectedResults + All APIs tested should complete with no errors. +*/ +void CTExtendedBitmapLegacy::TestNotSupportedNoReturnL() + { + INFO_PRINTF1(_L("NotSupportedNoReturn - test legacy CFbsBitmap APIs that are not supported when used with an extended bitmap but do not return errors")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + // Methods that are not supported and do not return errors values + INFO_PRINTF1(_L("PaletteAttributes()")); + TBool modifiable; + TInt numEntries; + bmp->PaletteAttributes(modifiable, numEntries); + + INFO_PRINTF1(_L("SetPalette()")); + bmp->SetPalette(NULL); + + CleanupStack::PopAndDestroy(bmp); + } + +/** +@SYMTestCaseID + GRAPHICS-FBSERV-EXTENDEDBITMAP-0039 + +@SYMTestCaseDesc + Test GetPixel with extended bitmaps where no rasterizer is present + that supports the extended bitmap type. + +@SYMCR + CR1804 + +@SYMREQ + REQ10858 + +@SYMTestPriority + High + +@SYMTestStatus + Implemented + +@SYMTestActions + Create an extended bitmap using test data and test Uid that is not supported by a rasterizer. + Call GetPixel(). + +@SYMTestExpectedResults + GetPixel() should return white pixels at the points requested, no errors should occur. +*/ +void CTExtendedBitmapLegacy::TestGetPixelL() + { + INFO_PRINTF1(_L("Test CFbsBitmap::GetPixel() where there is no supported rasterizer for the passed extended bitmap Uid")); + + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + TInt err = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize); + TESTNOERRORL(err); + + // Check that the absence of a rasteriser causes legacy off-screen rendering to + // treat the extended bitmap as if all pixels were white. + TRgb color; + for (TInt y = 0; y < KTestHeight; ++y) + { + for (TInt x = 0; x < KTestWidth; ++x) + { + bmp->GetPixel(color, TPoint(x,y)); + TESTTRUEL(color == KRgbWhite); + } + } + + CleanupStack::PopAndDestroy(bmp); + } + +__CONSTRUCT_STEP__(ExtendedBitmapLegacy) + +void CTExtendedBitmapLegacyStep::TestSetupL() + { + // Copy files needed by the tests to c: + TheFs.Connect(); + TInt err = BaflUtils::CopyFile(TheFs, KRamBitmapFilenameOnZ, KRamBitmapFilename); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Error copying test mbm file from rom to ram: %d"), err); + User::Leave(err); + } + } + +void CTExtendedBitmapLegacyStep::TestClose() + { + // Delete files used by the tests from c: + BaflUtils::DeleteFile(TheFs, KRamBitmapFilename); + TheFs.Close(); + }