diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/tbit/TDefect.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/bitgdi/tbit/TDefect.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,3374 @@ +// Copyright (c) 2003-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 "TDefect.h" +#include +#include + +_LIT(KRamBitmapOnZ, "z:\\system\\data\\16RAM.mbm"); +_LIT(KRamCBitmapOnZ, "z:\\system\\data\\16RAMC.mbm"); + +_LIT(KRamBitmap, "c:\\16RAM.mbm"); +_LIT(KRamCBitmap, "c:\\16RAMC.mbm"); + +_LIT(KZeroSizeMbmRam, "c:\\ZeroSizeRam.mbm"); +_LIT(KZeroSizeMbmZ, "z:\\system\\data\\ZeroSizeRam.mbm"); + +_LIT(KRomBitmap, "z:\\system\\data\\16ROM.mbm"); +_LIT(KRomCBitmap, "z:\\system\\data\\16ROMC.mbm"); + +_LIT(KRomRsc_RomMbm, "z:\\system\\data\\RomRsc_RomMbm.rsc"); +_LIT(KRomRsc_RomMbm2, "z:\\system\\data\\RomRsc_RomMbm2.rsc"); +_LIT(KRamRsc_RamMbmOnZ, "z:\\system\\data\\RamRsc_RamMbm.rsc"); +_LIT(KRamRsc_RamMbm2OnZ, "z:\\system\\data\\RamRsc_RamMbm2.rsc"); +_LIT(KRamRsc_RamMbm, "c:\\RamRsc_RamMbm.rsc"); +_LIT(KRamRsc_RamMbm2, "c:\\RamRsc_RamMbm2.rsc"); +_LIT(KRscFileHeader, "z:\\system\\data\\RscHeader2.bin"); +_LIT(KRscFileData, "z:\\system\\data\\DummyRscFile.rsc"); +_LIT(KRomRsc_RamMbm, "z:\\system\\data\\RomRsc_RamMbm.rsc"); +_LIT(KRamRsc_RomMbmOnZ, "z:\\system\\data\\RamRsc_RomMbm.rsc"); +_LIT(KRamRsc_RomMbm, "c:\\RamRsc_RomMbm.rsc"); +_LIT(KRamRsc_RomMbm2OnZ, "z:\\system\\data\\RamRsc_RomMbm2.rsc"); +_LIT(KRamRsc_RomMbm2, "c:\\RamRsc_RomMbm2.rsc"); +_LIT(KRomRsc_RamMbm2, "z:\\system\\data\\RomRsc_RamMbm2.rsc"); + +_LIT(KComprRamBitmap16, "z:\\system\\data\\paint16ramc.mbm"); +_LIT(KComprRomBitmap16, "z:\\system\\data\\paint16romc.mbm"); +_LIT(KComprRamBitmap24, "z:\\system\\data\\paint24ramc.mbm"); +_LIT(KComprRomBitmap24, "z:\\system\\data\\paint24romc.mbm"); + +_LIT(KComprRamBitmap8, "z:\\system\\data\\8ramc.mbm"); +_LIT(KComprRomBitmap8, "z:\\system\\data\\8romc.mbm"); +_LIT(KComprRamBitmap12, "z:\\system\\data\\12ramc.mbm"); +_LIT(KComprRomBitmap12, "z:\\system\\data\\12romc.mbm"); + +_LIT(KTestBmp, "z:\\system\\data\\BmCTest.mbm"); + +_LIT(KBitBltSrcBmp, "z:\\system\\data\\BitBltSrc.mbm"); +_LIT(KBitBltMaskedBmp, "z:\\system\\data\\BitBltMasked.mbm"); + +_LIT(KBmpCompr12, "z:\\system\\data\\compr12_2.mbm"); +_LIT(KBmpCompr16, "z:\\system\\data\\compr16_2.mbm"); +_LIT(KBmpZCompr12, "z:\\system\\data\\racompr12_2.mbm"); +_LIT(KBmpZCompr16, "z:\\system\\data\\racompr16_2.mbm"); +_LIT(KBmpCCompr12, "c:\\racompr12_2.mbm"); +_LIT(KBmpCCompr16, "c:\\racompr16_2.mbm"); + +_LIT(KBmp16_1, "c:\\Mbm16_1.mbm"); +_LIT(KBmp16_2, "c:\\Mbm16_2.mbm"); +_LIT(KBmp16_3, "c:\\Mbm16_3.mbm"); + +_LIT(KRam24BitmapOnZ, "z:\\system\\data\\24RAM.mbm"); +_LIT(KRamC24BitmapOnZ, "z:\\system\\data\\24RAMC.mbm"); + +_LIT(KRam24Bitmap, "c:\\24RAM.mbm"); +_LIT(KRamC24Bitmap, "c:\\24RAMC.mbm"); + +_LIT(KRom24Bitmap, "z:\\system\\data\\24ROM.mbm"); +_LIT(KRomC24Bitmap, "z:\\system\\data\\24ROMC.mbm"); + +//Note: Do not name functions with Defect numbers, instead give a meaningful name. + +// +// +//Note: Some display modes will be scaled - see +//CTDefect::CreateScreenDeviceL(TDisplayMode aDisplayMode, TAllowScaling aScaling), +//SetScalingFactor() call + +// +// +//If we have to handle RAM located file with an embedded ROM mbm file section - +//KRomMBMInRamRSC should be ETrue. +//If it is not allowed to do that - KRomMBMInRamRSC should be EFalse. +//#pragma warning(disable : 4127) //conditional expression is constant +//Constant KRomMBMInRamRSc removed temporarily due to invalid test scenario +//LOCAL_D const TBool KRomMBMInRamRSC = EFalse; + +// +// + +// +// +//Globals +LOCAL_D RFs TheFs; +//Delay time in microseconds, used at the end of some test methods +const TInt KDelayTime = 1;//1500000; + +// +// +//Create/Destroy test environment global functions + +//Delete "aFullName" file. +LOCAL_C void DeleteDataFile(const TDesC& aFullName) + { + RFs fsSession; + TInt err = fsSession.Connect(); + if(err == KErrNone) + { + TEntry entry; + if(fsSession.Entry(aFullName, entry) == KErrNone) + { + RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName); + err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly); + if(err != KErrNone) + { + RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName); + } + err = fsSession.Delete(aFullName); + if(err != KErrNone) + { + RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName); + } + } + fsSession.Close(); + } + else + { + RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName); + } + } + +//Copy test bitmaps from Z: to C: drive. RFs::Connect() had to be called already +//on "TheFs" object. +LOCAL_C void CopyDataFiles() + { + BaflUtils::CopyFile(TheFs, KRamBitmapOnZ, KRamBitmap); + BaflUtils::CopyFile(TheFs, KRamCBitmapOnZ, KRamCBitmap); + BaflUtils::CopyFile(TheFs, KRamRsc_RamMbmOnZ, KRamRsc_RamMbm); + BaflUtils::CopyFile(TheFs, KRamRsc_RamMbm2OnZ, KRamRsc_RamMbm2); + BaflUtils::CopyFile(TheFs, KRamRsc_RomMbmOnZ, KRamRsc_RomMbm); + BaflUtils::CopyFile(TheFs, KRamRsc_RomMbm2OnZ, KRamRsc_RomMbm2); + BaflUtils::CopyFile(TheFs, KZeroSizeMbmZ, KZeroSizeMbmRam); + BaflUtils::CopyFile(TheFs, KBmpZCompr12, KBmpCCompr12); + BaflUtils::CopyFile(TheFs, KBmpZCompr16, KBmpCCompr16); + BaflUtils::CopyFile(TheFs, KRamBitmap, KBmp16_1); + BaflUtils::CopyFile(TheFs, KRamBitmap, KBmp16_2); + BaflUtils::CopyFile(TheFs, KRamBitmap, KBmp16_3); + BaflUtils::CopyFile(TheFs, KRam24BitmapOnZ, KRam24Bitmap); + BaflUtils::CopyFile(TheFs, KRamC24BitmapOnZ, KRamC24Bitmap); + } + +//Delete data files used by the test +LOCAL_C void DeleteDataFiles() + { + DeleteDataFile(KRamBitmap); + DeleteDataFile(KRamCBitmap); + DeleteDataFile(KRamRsc_RamMbm); + DeleteDataFile(KRamRsc_RamMbm2); + DeleteDataFile(KRamRsc_RomMbm); + DeleteDataFile(KRamRsc_RomMbm2); + DeleteDataFile(KRam24Bitmap); + DeleteDataFile(KRamC24Bitmap); + DeleteDataFile(_L("c:\\temp.mbm")); + DeleteDataFile(_L("c:\\temp2.mbm")); + DeleteDataFile(KZeroSizeMbmRam ); + DeleteDataFile(KBmpCCompr12); + DeleteDataFile(KBmpCCompr16); + DeleteDataFile(KBmp16_1); + DeleteDataFile(KBmp16_2); + DeleteDataFile(KBmp16_3); + } + +// +// +//Global functions + +//Return file size in bytes of "aFileName" file. +LOCAL_C TInt FileSizeL(const TDesC& aFileName) + { + RFile file; + User::LeaveIfError(file.Open(TheFs, aFileName, EFileRead)); + CleanupClosePushL(file); + TInt size = 0; + User::LeaveIfError(file.Size(size)); + CleanupStack::PopAndDestroy(&file); + return size; + } + +//Creates CFbsBitGcBitmap instance and loads it with bitmap N#0 from "aFileName" file. +//CFbsBitGcBitmap instance will be pushed in the cleanup stack. +CFbsBitGcBitmap* LoadBitmapLC(const TDesC& aFileName) + { + CFbsBitGcBitmap* bmp = new (ELeave) CFbsBitGcBitmap; + CleanupStack::PushL(bmp); + User::LeaveIfError(bmp->Load(aFileName, 0)); + return bmp; + } + +//Creates "SIZE" CFbsBitGcBitmap instance and loads them with bitmap N#0 from "aBmpFiles" +//files. CFbsBitGcBitmap instances will be pushed in the cleanup stack. +template void LoadBitmapsLC(CFbsBitGcBitmap* (*aBmp)[SIZE], TPtrC aBmpFiles[]) + { + for(TInt ii=0;ii void DisplayBitmaps(CFbsBitGcBitmap* (*aBmp)[SIZE], + CFbsScreenDevice* aDevice, + CFbsBitGc* aGc) + { + for(TInt ii=0;iiSizeInPixels(); + aGc->Clear(); + aGc->DrawBitmap(TRect(size), (*aBmp)[ii]); + aDevice->Update(); + User::After(KDelayTime); + } + } + +//Destroys "aBmp" array of bitmaps. +template void DestroyBitmaps(CFbsBitGcBitmap* (*aBmp)[SIZE]) + { + for(TInt ii=(SIZE-1);ii>-1;ii--) + { + CleanupStack::PopAndDestroy((*aBmp)[ii]); + } + } + +//Compares 2 bitmaps from "aBmp" array. +//The first bitmap index is aBmp1, the second bitmap index is aBmp2. +//The function compares bitmaps line by line and asserts their pixel values. +template void CompareBitmaps(CFbsBitGcBitmap* (*aBmp)[SIZE], + TDisplayMode aDispMode, + TInt aBmp1, + TInt aBmp2, + CTGraphicsBase *aTest) + { + TUint8 line1[MAXLEN]; + TUint8 line2[MAXLEN]; + TPtr8 p1(line1, MAXLEN, MAXLEN); + TPtr8 p2(line2, MAXLEN, MAXLEN); + TSize size1 = (*aBmp)[aBmp1]->SizeInPixels(); + TSize size2 = (*aBmp)[aBmp2]->SizeInPixels(); + TInt minHeight = Min(size1.iHeight, size2.iHeight); + TInt minWidth = Min(size1.iWidth, size2.iWidth); + for(TInt ii=0;iiGetScanLine(p1, TPoint(0,ii), minWidth, aDispMode); + (*aBmp)[aBmp2]->GetScanLine(p2, TPoint(0,ii), minWidth, aDispMode); + aTest->TEST(p1.Length() == p2.Length()); + for(TInt j=0;jTEST(line1[j] == line2[j]); + } + } + } + +//Compares the Alpha Channel Values of the First Pixel in the two bitmaps. +//The pixel value is obtained from DataAddress(). +TBool CompareFirstPixelAlphaChannel(CFbsBitmap* aBmp1, CFbsBitmap* aBmp2) + { + return ( (*aBmp1->DataAddress() & 0xff000000) == (*aBmp2->DataAddress() & 0xff000000) ); + } + +// +// + +CTDefect::CTDefect(CTestStep* aStep) : + CTGraphicsBase(aStep), + iDevice(NULL), + iBmpDevice(NULL), + iGc(NULL), + iBitmap(NULL), + iSize(0, 0), + iCurrentMode(ENone) + { + } + +CTDefect::~CTDefect() + { + DestroyFont(); + DeleteBitmap(); + DeleteGraphicsContext(); + DeleteBitmapDevice(); + DeleteScreenDevice(); + } + +void CTDefect::ConstructL() + { + INFO_PRINTF1(_L("Create screen device")); + CreateScreenDeviceL(); + + TUint32* romAddress = NULL; + if(!CFbsBitmap::IsFileInRom(KRomBitmap, romAddress)) //check any rom bitmap + { + INFO_PRINTF2(_L("Skipping tests of ROM bitmaps since file \"%S\" is reported to not be a ROM bitmap."), + &KRomBitmap); + INFO_PRINTF1(_L("This should only occur on non-XIP ROMs, e.g. NAND ROMs, where ROM bitmaps aren't supported.")); + iSkipRomBitmapTests = ETrue; + } + } + +void CTDefect::CreateScreenDeviceL(TAllowScaling aScaling) + { + DeleteGraphicsContext(); + DeleteScreenDevice(); + TDisplayMode mode[] = {EColor256, EColor4K, EColor16M, EColor16MU, EColor64K, + EGray256, EGray16, EGray4, EGray2, EColor16, EColor16MA, EColor16MAP}; + TInt ii; + TInt err = KErrNotSupported; + for(ii=0;(iiCreateContext((CGraphicsContext*&)iGc); + TEST(err == KErrNone); + if(aScaling == EScalingAllowed) + { + iDevice->SetScalingFactor(TPoint(31, 11), 2, 2, 1, 1); + iGc->Activate(iDevice); + } + iGc->SetUserDisplayMode(aDisplayMode); + iDevice->ChangeScreenDevice(NULL); + iDevice->SetAutoUpdate(EFalse); + iSize = iDevice->SizeInPixels(); + iCurrentMode = aDisplayMode; + return err; + } + +void CTDefect::RunTestCaseL(TInt aCurTestCase) + { + ((CTDefectStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0045")); + INFO_PRINTF1(_L("DEF014364")); + DEF014364L(); + INFO_PRINTF1(_L("Cleared DEF014364\n")); + break; + case 2: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0046")); + INFO_PRINTF1(_L("DEF017758")); + DEF017758(); + INFO_PRINTF1(_L("Cleared DEF017758\n")); + break; + case 3: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0047")); + INFO_PRINTF1(_L("16 bpp bitmap comperssion")); + BitmapCompressionL(E16BppBmpType); + break; + case 4: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0047")); + INFO_PRINTF1(_L("24 bpp bitmap comperssion")); + BitmapCompressionL(E24BppBmpType); + break; + case 5: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0048")); + INFO_PRINTF1(_L("New RSC file format")); + NewRscFormatL(); + break; + case 6: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0049")); + INFO_PRINTF1(_L("INC031920 - 16 bpp bitmaps")); + INC031920L(E16BppBmpType, ETrue); + INC031920L(E16BppBmpType, EFalse); + break; + case 7: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0049")); + INFO_PRINTF1(_L("INC031920 - 24 bpp bitmaps")); + INC031920L(E24BppBmpType, ETrue); + INC031920L(E24BppBmpType, EFalse); + break; + case 8: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0050")); + INFO_PRINTF1(_L("8 bit bitmap compression - ROM")); + Test8bitBmpComressionL(); + break; + case 9: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0051")); + INFO_PRINTF1(_L("12 bit bitmap compression - ROM")); + Test12bitBmpComressionL(); + break; + case 10: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0044")); + INFO_PRINTF1(_L("ZeroSizeBitmap")); + ZeroSizeBitmap(); + break; + case 11: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0052")); + INFO_PRINTF1(_L("DEF034134")); + DEF034134L(); + break; + case 12: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0053")); + INFO_PRINTF1(_L("Test tiling occurs correctly")); + TestTilingHorizontalAndVerticalL(); + break; + case 13: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0054")); + INFO_PRINTF1(_L("Borderline cases for DrawPie")); + DrawPieBorderlineCasesL(); + break; + case 14: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0055")); + INFO_PRINTF1(_L("INC037380")); + INC037380L(); + break; + case 15: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0056")); + INFO_PRINTF1(_L("INC037474")); + INC037474L(); + break; + case 16: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0058")); + INFO_PRINTF1(_L("CFbsBitmap::SetDisplayMode() test")); + TestSettingDisplayModeL(); + break; + case 17: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0059")); + INFO_PRINTF1(_L("CFbsBitmap::SetDisplayMode() test 2")); + TestSettingDisplayMode2L(); + break; + case 18: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0060")); + INFO_PRINTF1(_L("CFbsBitmap::SwappingWidthAndHeight() test")); + TestSwappingWidthAndHeightL(); + break; + case 19: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0057")); + INFO_PRINTF1(_L("INC037370")); + INC037370L(); + break; + case 20: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0061")); + INFO_PRINTF1(_L("DEF038774")); + DEF038774L(); + break; + case 21: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0062")); + INFO_PRINTF1(_L("INC070043L")); + INC070043L(); + break; + case 22: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0043")); + INFO_PRINTF1(_L("OOM test")); + TestOom(); + break; + case 23: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0063")); + INFO_PRINTF1(_L("Bitmaps Swapping Test")); + BitmapsSwappingTest(); + break; + case 24: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0064")); + INFO_PRINTF1(_L("INC093055")); + INC093055L(); + break; + case 25: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0016")); + INFO_PRINTF1(_L("PDEF103809")); + PDEF103809L(); + break; + case 26: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0018 + +@SYMDEF DEF104856 + +@SYMTestCaseDesc Test that the bitmap and mask are drawn correctly testing + CFbsBitGc::DoBitBltMaskedFlicker in order to test the DEF104856 fix + introduced in CFbsBitGc::DoBitBltMaskedFlicker method + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor64K bitmap and mask and draw bitmap calling + CFbsBitGc::BitBltMasked with an offscreen bitmap device + +@SYMTestExpectedResults The resulting bitmap is not altered or corrupted by the code module +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0018")); + INFO_PRINTF1(_L("BitBltMasked Flicker Test - DEF104856")); + TestDoBltMaskedL(EColor64K, EColor64K, EColor64K, TSize(16,16), EFalse, ETrue); + break; + case 27: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0019 + +@SYMDEF DEF104856 + +@SYMTestCaseDesc Test that the bitmap and mask are drawn correctly testing + CFbsBitGc::DoBitBltMaskedNonFlicker in order to test the DEF104856 fix + introduced in CFbsBitGc::DoBitBltMaskedNonFlicker method + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor64K bitmap and mask and draw bitmap calling + CFbsBitGc::BitBltMasked with a screen device and brush style EVerticalHatchBrush + +@SYMTestExpectedResults The resulting bitmap is not altered or corrupted by the code module +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0019")); + INFO_PRINTF1(_L("BitBltMasked non Flicker Test - DEF104856")); + TestDoBltMaskedL(EColor64K, EColor64K, EColor64K, TSize(16,16), ETrue, ETrue); + break; + case 28: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0092 + +@SYMDEF DEF108338 + +@SYMTestCaseDesc Test that the bitmap is drawn correctly by testing + that the correct area of the mask is used for masking. + CFbsBitGc::DoBitBltMaskedFlicker is called in this case. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor64K bitmap and EGray2 mask and draw bitmap calling + CFbsBitGc::BitBltMasked with a screen device. The drawing is done in a loop + to simulate the scrolling effect as in a browser. + +@SYMTestExpectedResults All the stripes should pass the integrity check. +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0092")); + INFO_PRINTF1(_L("BitBltMasked Flicker - DEF108338")); + TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), EFalse, EFalse); + break; + case 29: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0093 + +@SYMDEF DEF108338 + +@SYMTestCaseDesc Test that the bitmap is drawn correctly by testing + that the correct area of the mask is used for masking. + CFbsBitGc::DoBitBltMaskedNonFlicker is called in this case. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor64K bitmap and EGray2 mask and draw bitmap calling + CFbsBitGc::BitBltMasked with a screen device. The drawing is done in a loop + to simulate the scrolling effect as in a browser. + +@SYMTestExpectedResults All the stripes should pass the integrity check. +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0093")); + INFO_PRINTF1(_L("BitBltMasked Non Flicker - DEF108338")); + //skip the test if the screen does not have a fast blit interface. + if(CFbsDrawDevice::DisplayMode16M() == ENone) + { + INFO_PRINTF1(_L("Test skipped - The screen does not have a fast blit interface!")); + break; + } + TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), ETrue, EFalse); + break; + case 30: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0020 + +@SYMDEF DEF103736 + +@SYMTestCaseDesc Test to check that EColor16MAP mode correctly draws bitmaps when using a EColor16MAP mask + +@SYMTestPriority Normal + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor16MAP bitmap and mask and draw bitmap calling + CFbsBitGc::BitBltMasked with an offscreen bitmap device + +@SYMTestExpectedResults The resulting bitmap is not altered or corrupted by the code module +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0020")); + INFO_PRINTF1(_L("BitBltMasked non Flicker Test ECOLOR16MAP - DEF103736")); + TestDoBltMaskedL(EColor16MAP, EColor16MAP, EColor16MAP, TSize(16,16), EFalse, ETrue); + break; + case 31: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0094 + +@SYMDEF PDEF108863 + +@SYMTestCaseDesc Test that CFbsBitGc::DoBitBltAlpha() function behaves correctly + when source is EColor16MU, mask is EGray256, both source and mask are compressed + and the screen driver has no MFastBlit interface. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor16MU bitmap and EGray256 mask and draw bitmap calling + CFbsBitGc::BitBltMasked with a screen device. Where screen driver has no MFastBlit interface. + +@SYMTestExpectedResults All the stripes should pass the integrity check. +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0094")); + INFO_PRINTF1(_L("PDEF108863 - DoBitBltAlpha for EColor16MU source, EGray256 mask and no MFastBlit interface")); + TestDoBltMaskedL(EColor16MU, EGray256, EColor16MA, TSize(96,96), EFalse, EFalse); + break; + case 32: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0095")); + INFO_PRINTF1(_L("PDEF110934 - DoBitBltMasked for mask height is less/greater than the bitmap height")); + TestDoBitBltMaskedSizeL(); + break; + case 33: +/** +@SYMTestCaseID GRAPHICS-BITGDI-0096 + +@SYMDEF PDEF114309 + +@SYMTestCaseDesc Test to check that EColor16MU mode correctly BitBltMasks when source and mask are of EColor16MA + +@SYMTestPriority Normal + +@SYMTestStatus Implemented + +@SYMTestActions Create source, mask and destination bitmaps of EColor16MA, EColor16MA and EColor16MU respectively + Call BitBltMaksed on the destination device and check the output + +@SYMTestExpectedResults The resulting bitmap contents should match the calculated value +**/ + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0096")); + INFO_PRINTF1(_L("BitBltMasked for EColor16MU with source and mask of EColor16MA - PDEF114309")); + TestBitBltMaskedEColor16MUL(); + break; + case 34: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0102")); + INFO_PRINTF1(_L("Externalize()/Internalize() of CFbsBitGcExtraData in CFbsBitmap - DEF120360")); + ExternalizeInternalizeCFbsBitGCExtraData(); + break; + case 35: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0086")); + INFO_PRINTF1(_L("Test BitBlt with 16MU source & target copies rather than overwrites alpha channel - DEF121299")); + TestBitBltOperationsOn16muUndefinedByteL(); + break; + case 36: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0107")); + INFO_PRINTF1(_L("Test DrawBitmap() with clipping and scaling - DEF126160")); + TestClippedScaledBitmapL(); + break; + case 37: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0109")); + INFO_PRINTF1(_L("Test TestDrawBitmapTwipsNotSet() - DEF128522")); + TestDrawBitmapTwipsNotSet(); + break; + case 38: + ((CTDefectStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0119")); + INFO_PRINTF1(_L("Test DrawBitmapMasked() with compressed bitmaps")); + TestDrawBitmapMaskedL(); + break; + case 39: + ((CTDefectStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTDefectStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTDefectStep*)iStep)->RecordTestResultL(); + } + +void CTDefect::TestBitBltMaskedEColor16MUL() + { + TInt width = 128; + TInt height = 178; + + TSize size(width, height); + TInt transpFactor = 100; + + // Create a destination bitmap of EColro16MU and fill some color in it + CFbsBitmap* destBitmap = new CFbsBitmap(); + CleanupStack::PushL(destBitmap); + User::LeaveIfError(destBitmap->Create(size, EColor16MU)); + CFbsBitmapDevice* destDev = CFbsBitmapDevice::NewL(destBitmap); + CleanupStack::PushL(destDev); + CFbsBitGc* destGc = NULL; + User::LeaveIfError(destDev->CreateContext(destGc)); + CleanupStack::PushL(destGc); + + destGc->SetPenStyle(CGraphicsContext::ENullPen); + destGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + destGc->SetBrushColor(KRgbRed); + destGc->DrawRect(TRect(TPoint(), size)); + + // Create a source bitmap fill it with some color and then draw it with some color with transparency on it + CFbsBitmap* srcBitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(srcBitmap); + User::LeaveIfError(srcBitmap->Create(size, EColor16MA)); + CFbsBitmapDevice* srcDev = CFbsBitmapDevice::NewL(srcBitmap); + CleanupStack::PushL(srcDev); + CFbsBitGc* srcGc = NULL; + User::LeaveIfError(srcDev->CreateContext(srcGc)); + CleanupStack::PushL(srcGc); + + srcGc->SetPenStyle(CGraphicsContext::ENullPen); + srcGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + srcGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + srcGc->SetBrushColor(TRgb(0xff,0xff,0xff,transpFactor)); + srcGc->DrawRect(TRect(TPoint(), size)); + + // Create a mask bitmap and fill with TRgb(30,30,30) + CFbsBitmap* maskBitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(maskBitmap); + User::LeaveIfError(maskBitmap->Create(size, EColor16MA)); + CFbsBitmapDevice* maskDev = CFbsBitmapDevice::NewL(maskBitmap); + CleanupStack::PushL(maskDev); + CFbsBitGc* maskGc = NULL; + User::LeaveIfError(maskDev->CreateContext(maskGc)); + CleanupStack::PushL(maskGc); + + maskGc->SetPenStyle(CGraphicsContext::ENullPen); + maskGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + maskGc->SetBrushColor(TRgb( 30, 30, 30 )); + maskGc->DrawRect(size); + + // Then call BitBltMaksed() on it + destGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + destGc->SetBrushStyle(CGraphicsContext::ENullBrush); + destGc->BitBltMasked(TPoint(), srcBitmap, TRect(size), maskBitmap, ETrue); + + // These are the values that we gave for source bitmaps + TUint32 srcPixel = 0x64FFFFFF; // i,e TRgb(0xff,0xff,0xff,transpFactor) + TUint8 srcMask = 0x64; // transpFactor + TUint32 destPixel = 0xFFFFFFFF; // White becasue nothing has drawn on it + + // When we draw source bitmap with transparency, it actually alpha blends + // with the above parameters + srcPixel = AlphaBlendWithDestAlphaFF(srcPixel, srcMask, destPixel); + + // For displaymode which has alpha, mask is inverted i,e 255-30 = 225 or 0xE1 + srcMask = 0xE1; // mask bitmap's TRgb( 30, 30, 30 ) + destPixel = 0xFFFF0000; // KRgbRed of destination bitmap + destPixel = AlphaBlendWithDestAlphaFF(srcPixel, srcMask, destPixel); + + // Function to check the contents of the destination bitmap, + // if the INC111510 fix is not applied then this function will fail + CheckBitmapContents(destDev, width, height, destPixel); + + CleanupStack::PopAndDestroy(9, destBitmap); + } + +// This function is for alpha blending when the destination alpha is FF +TUint32 CTDefect::AlphaBlendWithDestAlphaFF(const TUint32 aSrcPixel, const TUint8 aMask, TUint32 aDestPixel) + { + if(aMask) + { + if(aMask == 0xFF) + return 0xff000000|aSrcPixel; + + // This is the formula used for alpha blending + // (a) (mask * src + (255 - mask) * dest) / 255 This is the ideal formula + // (b) ((mask * (src - dest)) >> 8) + dest A faster approximation to (a) + // (c) ((mask * (256 + src - dest) >> 8) + dest - mask Equivalent to (b) but can be used on multiple colors at a time + + const TUint32 s_rb = aSrcPixel & 0x00FF00FF; + const TUint32 d_rb = aDestPixel & 0x00FF00FF; + const TUint32 mask2 = aMask | (aMask << 16); + const TUint32 rb = ((((aMask * ((0x01000100 + s_rb) - d_rb)) >> 8) + d_rb) - mask2) & 0x00FF00FF; + + const TInt s_g = (aSrcPixel & 0xFF00) >> 8; + const TInt d_g = (aDestPixel & 0xFF00) >> 8; + const TInt g = ((aMask * (s_g - d_g)) >> 8) + d_g; + + return(rb | (g<<8) | 0xff000000); + } + + return aDestPixel; + } + +// This function is to check each pixel of the given bitmap +void CTDefect::CheckBitmapContents(CFbsDevice* aDevice, TInt aWidth, TInt aHeight, TUint32 aExpectedValue) + { + TRgb color; + for(TInt y = 0; y < aHeight; ++y) + { + for(TInt x = 0; x < aWidth; ++x) + { + aDevice->GetPixel(color, TPoint(x, y)); + if(aExpectedValue != color.Internal()) + { + TEST(EFalse); + return; + } + } + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0043 + + @SYMDEF INC042156L + + @SYMTestCaseDesc Out of memory test + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Sets the next heap allocation to fail before attempting various bitmaps operations + + @SYMTestExpectedResults Allocation should fail gracefullly +*/ +void CTDefect::TestOom() + { + TInt err, tryCount = 0; + + INFO_PRINTF1(_L("INC042156L")); + + do + { + User::__DbgSetAllocFail(RHeap::EUser, RHeap::EFailNext, ++tryCount); + User::__DbgMarkStart(RHeap::EUser); + { + TRAP(err, INC042156L()); + } + User::__DbgMarkEnd(RHeap::EUser, 0); + } + while(err == KErrNoMemory); + + if(err == KErrNone) + { + // Reset + User::__DbgSetAllocFail(RHeap::EUser,RHeap::ENone,1); + } + else + { + TEST(err == KErrNone); + } + + INFO_PRINTF2(_L("- server succeeded at heap failure rate of %i"), tryCount); + User::After(3000000); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0044 + + @SYMDEF + + @SYMTestCaseDesc tests that CBitwiseBitmap::SizeOfByteDataCompressed, SizeOfTwelveBitDataCompressed, SizeOfSixteenBitDataCompressed & + SizeOfTwentyFourBitDataCompressed can handle zero size bitmaps + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Loads a zerosize bitmap the compresses it + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::ZeroSizeBitmap() +{ + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + + TInt err = iBitmap->Load(KZeroSizeMbmRam); + TEST(err == KErrCorrupt); + if(err != KErrCorrupt) + { + err =iBitmap->Compress(); + TEST(err == KErrNone); + } +} + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0045 + + @SYMDEF DEF014364 + + @SYMTestCaseDesc Tests opening of a corrupt bitmap and resizing to (0,0) + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions tries to open a corrupt bitmap then attempts to resize a new bitmap to (0,0) size + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::DEF014364L() + { + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + TInt err = iBitmap->Load(_L("z:\\system\\data\\Corrupt000.wbmp")); + //It should not be possible to open corrupted bitmap file. + if (err!=KErrNotSupported) + { + _LIT(KLog,"Corrupt bitmap Corrupt000.wbmp gave wrong error code when opening err=%d"); + INFO_PRINTF2(KLog,err); + } + TEST(err == KErrNotSupported); + err = iBitmap->Create(TSize(20, 20), iCurrentMode); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to create bitmap err=%d"); + INFO_PRINTF2(KLog,err); + } + TEST(err == KErrNone); + DeleteBitmapDevice(); + TRAP(err, iBmpDevice = CFbsBitmapDevice::NewL(iBitmap)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to create bitmap device err=%d"); + INFO_PRINTF2(KLog,err); + } + TEST(err == KErrNone); + //It should not be possible to resize bitmap device to (0, 0) size. + //Yes it should, setting size to 0,0 is necessary to maintain + //6.1 application compatibility with 7.0s. + err = iBmpDevice->Resize(TSize(0, 0)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to resize bitmap err=%d"); + INFO_PRINTF2(KLog,err); + } + TEST(err == KErrNone); + //It should be possible to resize bitmap to (0, 0) size. + err = iBitmap->Resize(TSize(0, 0)); + if (err!=KErrNone) + { + _LIT(KLog,"Failed to resize bitmap2 err=%d"); + INFO_PRINTF2(KLog,err); + } + TEST(err == KErrNone); + //The next call should not fail with "Divide by Zero" exception on WINS platform. + iGc->DrawBitmap(TRect(0, 0, 10, 10), iBitmap, TRect(0, 0, 10, 10)); + } + +//DEF023605 - Panic when bmp file is opened using Paint. +void CTDefect::DEF023605L() + { + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + TInt err = iBitmap->Create(iSize, iCurrentMode); + TEST(err == KErrNone); + //It should not be possible to resize bitmap to (max_int, ...) size. + err = iBitmap->Resize(TSize(0x7FFFFFFF, 16)); + TEST(err == KErrNone); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0046 + + @SYMDEF DEF017758 + + @SYMTestCaseDesc Memory leak detected on target when using DirectScreenAccess + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + + // + //The statement between __UHEAP_MARK and __UHEAP_END can cause memory leak! + //Obviously we have some kind of first time memory allocation when the + //method is called for the first time. Exactly the same method is called from + //CFbsScreenDevice::ConstructL() method. + // + //To see the problem: + //1. Comment HAL::Get() call into E32Main(). + //2. Build ARM4 UDEB version of TDefect and make sure it is used into rom image build + //3. Build textshell rom image: + // buildrom assabet textshell_70s graphics_70s.iby graphicstests_70s.iby + //4. Run TDefect app on the assabet. + // You will see a memory leak. If you uncomment HAL::Get() call into E32Main() and repeat + // steps 1..4 - everything is OK. + //PS: If you don't want to build all graphics test app, you may have to comment + // some IBY file includes into graphicstests_70s.iby file. + // If there is a memory leak - the test will still report status "OK", but you + // can see the memory leak message on the assabet. That's happening because + // the memory leak appears after the last __UHEAP_MARKEND macro in E32Main(). + // + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::DEF017758() + { + TRAPD(err, DEF017758L()); + TEST(err == KErrNone); + } + +void CTDefect::DEF017758L() + { + RDebug::Print(_L("Getting video memory address\r\n")); + RDebug::Print(_L("Start\r\n")); + TInt address = 0; + + __UHEAP_MARK; + User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress, address)); + __UHEAP_MARKEND; + RDebug::Print(_L("End\n")); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0047 + + @SYMDEF + + @SYMTestCaseDesc The main purpose of this method is to test RAM/ROM bitmap compression. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + + - loads and displays ROM compressed bitmap. + - loads and displays ROM bitmap - no compression. + - loads and displays RAM compressed bitmap. + - loads and displays RAM bitmap - no compression. + - loads, compress and displays RAM bitmap. + - stretches, moves and resizes RAM compressed bitmap. + - compares byte by byte compressed and uncompressed bitmap images. + Note: if you want to have better visibility of the bitmaps shown on + the screen - change "KDelayTime" constant to be 1500000. + @param TBitmapType aBitmapType - tested bitmaps type - 16 bpp, 24 bpp, ... + @return None + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::BitmapCompressionL(TBitmapType aBitmapType) + { + CreateScreenDeviceL(); + CreateFontL(); + + TRect rc(10, 20, 610, 220); + TBuf<100> text; + TInt mbm_offset = 0; + TInt err; + TPtrC BitmapTypeName[ELastBmpType] = {_L("16 bpp"), _L("24 bpp")}; + typedef enum {ERAMFileType, ERAMCFileType, EROMFileType, EROMCFileType, ELastBmpFileType} TBitmapFileType; + TPtrC BitmapFile[ELastBmpFileType][ELastBmpType] = + { + {KRamBitmap(), KRam24Bitmap()}, + {KRamCBitmap(), KRamC24Bitmap()}, + {KRomBitmap(), KRom24Bitmap()}, + {KRomCBitmap(), KRomC24Bitmap()} + }; + + if(!iSkipRomBitmapTests) + { + //ROM compressed bitmap. + text = BitmapTypeName[aBitmapType]; + text += _L(" ROM compressed bitmap."); + DisplayBitmapL(BitmapFile[EROMCFileType][aBitmapType], 0, mbm_offset, text, rc); + + //ROM bitmap - no compression. + text = BitmapTypeName[aBitmapType]; + text += _L(" ROM bitmap - no compression."); + DisplayBitmapL(BitmapFile[EROMFileType][aBitmapType], 0, mbm_offset, text, rc); + } + + //RAM compressed bitmap. + text = BitmapTypeName[aBitmapType]; + text += _L(" RAM compressed bitmap."); + DisplayBitmapL(BitmapFile[ERAMCFileType][aBitmapType], 0, mbm_offset, text, rc); + + //RAM bitmap - no compression. + text = BitmapTypeName[aBitmapType]; + text += _L(" RAM bitmap - no compression."); + DisplayBitmapL(BitmapFile[ERAMFileType][aBitmapType], 0, mbm_offset, text, rc); + + //RAM bitmap - no compression. Compress it! + err = iBitmap->Compress(); + TEST(err == KErrNone); + TEST(iBitmap->IsCompressedInRAM()); + text = BitmapTypeName[aBitmapType]; + text += _L(" RAM bitmap - compressed now."); + DisplayBitmap(text, rc); + err = iBitmap->Save(_L("c:\\temp.mbm")); + TEST(err == KErrNone); + + //RAM compressed bitmap - stretch the bitmap. + text = BitmapTypeName[aBitmapType]; + text += _L(" RAM compressed bitmap - stretch the bitmap."); + TRect rc2(10, 20, 410, 150); + DisplayBitmap(text, rc2); + + //RAM compressed bitmap - move the bitmap. + text = BitmapTypeName[aBitmapType]; + text += _L(" RAM compressed bitmap - move the bitmap."); + for(TInt j=0;j<10;j++) + { + TRect rc2(10 + j * 10, 20 + j * 5, 410 + j * 10, 150 + j * 5); + DisplayBitmap(text, rc2); + } + + //RAM compressed bitmap - resize the bitmap. + iGc->Clear(); + err = iBitmap->Save(_L("c:\\temp2.mbm")); + TEST(err == KErrNone); + CFbsBitmap* resizedBitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(resizedBitmap); + err = resizedBitmap->Load(_L("c:\\temp2.mbm")); + TEST(err == KErrNone); + err = resizedBitmap->Resize(TSize(300, 100)); + TEST(err == KErrNone); + iGc->DrawBitmap(TRect(10, 20, 310, 120), resizedBitmap); + text = BitmapTypeName[aBitmapType]; + text += _L(" RAM compressed bitmap - resize the bitmap."); + iGc->DrawText(text, TPoint(10, 15)); + iDevice->Update(); + User::After(KDelayTime); + CleanupStack::PopAndDestroy(resizedBitmap); + + iGc->Clear(); + iGc->DrawText(_L("Compare compressed and uncompressed bitmap data."), TPoint(10, 15)); + iDevice->Update(); + + DestroyFont(); + + CFbsBitmap* compressedBitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(compressedBitmap); + err = compressedBitmap->Load(_L("c:\\temp.mbm")); + TEST(err == KErrNone); + + CFbsBitmap* uncompressedBitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(uncompressedBitmap); + err = uncompressedBitmap->Load(BitmapFile[ERAMFileType][aBitmapType]); + TEST(err == KErrNone); + + //Compare compressed and uncompressed bitmaps. + TEST(compressedBitmap->SizeInPixels() == uncompressedBitmap->SizeInPixels()); + TSize sizeInPixels = compressedBitmap->SizeInPixels(); + TInt BitmapBytesPerPixel[ELastBmpType] = {2, 3}; + HBufC8* compressedLine = HBufC8::NewLC(sizeInPixels.iWidth * BitmapBytesPerPixel[aBitmapType]); + TPtr8 p1 = compressedLine->Des(); + HBufC8* uncompressedLine = HBufC8::NewLC(sizeInPixels.iWidth * BitmapBytesPerPixel[aBitmapType]); + TPtr8 p2 = uncompressedLine->Des(); + TDisplayMode BitmapScreenMode[ELastBmpType] = {EColor64K, EColor16M}; + for(TInt ii=0;iiGetScanLine(p1, TPoint(0,ii), sizeInPixels.iWidth, BitmapScreenMode[aBitmapType]); + uncompressedBitmap->GetScanLine(p2, TPoint(0,ii), sizeInPixels.iWidth, BitmapScreenMode[aBitmapType]); + TEST(p1 == p2); + } + + CleanupStack::PopAndDestroy(uncompressedLine); + CleanupStack::PopAndDestroy(compressedLine); + CleanupStack::PopAndDestroy(uncompressedBitmap); + CleanupStack::PopAndDestroy(compressedBitmap); + + User::After(KDelayTime); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0048 + + @SYMDEF + + @SYMTestCaseDesc The main purpose of this method is to test new resource files format. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions The new resoure files format is: RSC file header + RSC file section + MBM file section. + The method consequently does: + - loads and displays new RSC file format: RSC file in ROM. MBM file in ROM. + - loads and displays new RSC file format: RSC file in RAM. MBM file in RAM. + - loads and displays new RSC file format: RSC file in ROM. MBM file in ROM. 2 bitmaps. + - loads and displays new RSC file format: RSC file in RAM. MBM file in RAM. 2 bitmaps. + - loads and displays new RSC file format: RSC file in ROM. MBM file in RAM. + Note: if you want to have better visibility of the bitmaps shown on + the screen - change "KDelayTime" constant to be 1500000. + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::NewRscFormatL() + { + CreateScreenDeviceL(); + CreateFontL(); + + TRect rc(10, 20, 610, 220); + TPtrC text(_L("RSC file in ROM. MBM file in ROM.")); + TInt mbm_offset = ::FileSizeL(KRscFileHeader) + ::FileSizeL(KRscFileData); + + //RSC file in ROM. MBM file in ROM. + if(!iSkipRomBitmapTests) + DisplayBitmapL(KRomRsc_RomMbm, 0, mbm_offset, text, rc); + + //RSC file in RAM. MBM file in RAM. + text.Set(_L("RSC file in RAM. MBM file in RAM.")); + DisplayBitmapL(KRamRsc_RamMbm, 0, mbm_offset, text, rc); + + TInt ii; + TRect rect[] = {TRect(10, 20, 170, 100), TRect(10, 20, 35, 94)}; + + //RSC file in ROM. MBM file in ROM. Multiple bitmaps. + if(!iSkipRomBitmapTests) + { + text.Set(_L("RSC file in ROM. MBM file in ROM. Multiple bitmaps.")); + for(ii=0;iiLoad(filename, 10); + TEST(err == KErrNone); + iGc->UseBrushPattern(brush_bitmap); + + TInt brush_style = CGraphicsContext::ENullBrush; + for(TInt ii=0;ii<25;ii++) + { + if(++brush_style == CGraphicsContext::EDiamondCrossHatchBrush) + { + brush_style = CGraphicsContext::ESolidBrush; + } + iGc->SetBrushStyle(static_cast (brush_style)); + + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + err = iBitmap->Load(filename, ii); + TEST(err == KErrNone); + TSize size = iBitmap->SizeInPixels(); + + CFbsBitmap* mask_bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(mask_bitmap); + err = mask_bitmap->Load(filename, (ii+3)<25 ? (ii+3) : (ii-3)); + TEST(err == KErrNone); + + TPoint pt(0, 0); + TRect rc(0, 0, size.iWidth, size.iHeight); + //If there is a problem with BitBltMasked - it can fail with "Access violation" + //exception on the emulator. + iGc->BitBltMasked(pt, iBitmap, rc, mask_bitmap, ETrue); + iGc->DrawRect(rc); + iDevice->Update(); + User::After(KDelayTime); + + CleanupStack::PopAndDestroy(mask_bitmap); + } + + CleanupStack::PopAndDestroy(brush_bitmap); + DestroyFont(); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0050 + + @SYMDEF + + @SYMTestCaseDesc 8 bit bitmap compression - ROM + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates and draws to an 8bbp compressed bitmap + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::Test8bitBmpComressionL() + { + CreateScreenDeviceL(); + CreateFontL(); + + TRect rc(10, 20, 610, 220); + TPtrC text(_L("8 bpp RAM compressed bitmap.")); + DisplayBitmapL(KComprRamBitmap8, 0, 0, text, rc); + + if(!iSkipRomBitmapTests) + { + text.Set(_L("8 bpp ROM compressed bitmap.")); + DisplayBitmapL(KComprRomBitmap8, 0, 0, text, rc); + } + + DestroyFont(); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0051 + + @SYMDEF + + @SYMTestCaseDesc 12 bpp ROM compressed bitmap + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates and draws to an 12bbp compressed bitmap + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::Test12bitBmpComressionL() + { + CreateScreenDeviceL(); + CreateFontL(); + + TRect rc(10, 20, 610, 220); + TPtrC text(_L("12 bpp RAM compressed bitmap.")); + DisplayBitmapL(KComprRamBitmap12, 0, 0, text, rc); + + if(!iSkipRomBitmapTests) + { + text.Set(_L("12 bpp ROM compressed bitmap.")); + DisplayBitmapL(KComprRomBitmap12, 0, 0, text, rc); + } + + DestroyFont(); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0052 + + @SYMDEF DEF034134 + + @SYMTestCaseDesc BMCONV has a limitation on the number of bitmaps it can use. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Loads up a mbm contaiing 8 bitmaps and draws them + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ + void CTDefect::DEF034134L() + { + CreateScreenDeviceL(); + CreateFontL(); + + TBuf<64> text; + for(TInt ii=0;ii<8;ii++) + //8 - it is the number of bitmaps in mbm file - see GenBitmaps.mk where this mbm file is generated + { + text.Format(_L("Bitmap %d"), ii+1); + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + TInt err = iBitmap->Load(KTestBmp, ii); + TEST(err == KErrNone); + TSize size = iBitmap->SizeInPixels(); + DisplayBitmap(text, TRect(20, 20, 20 + size.iWidth, 20 + size.iHeight)); + } + + DestroyFont(); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0053 + + @SYMDEF DEF036156 + + @SYMTestCaseDesc When using a mask that's smaller than the bitmap being blitted, + the mask should be tiled horizontally and vertically until it's the correct size and then applied to the bitmap. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates bitmap, mask and brush and tests that tiling occurs correctly + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::TestTilingHorizontalAndVerticalL() + { + TDisplayMode mode[] = {EColor256, EColor4K, EColor16M, EColor16MU, EColor64K, + EGray256, EGray16, EGray4, EGray2, EColor16, EColor16MA, EColor16MAP}; + TInt err; + + //Create&load source bitmap + CFbsBitmap* srcBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(srcBmp); + err = srcBmp->Load(KBitBltSrcBmp, 0); + TEST(err == KErrNone); + TSize size1 = srcBmp->SizeInPixels(); + TPoint pt1(10, 20); + TRect rc1(pt1.iX, pt1.iY, pt1.iX + size1.iWidth, pt1.iY + size1.iHeight); + + //Create&load mask bitmap + CFbsBitmap* maskBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(maskBmp); + err = maskBmp->Load(KBitBltMaskedBmp, 0); + TEST(err == KErrNone); + TSize size2 = maskBmp->SizeInPixels(); + TInt offset = 40; + TPoint pt2(pt1.iX, pt1.iY + size1.iHeight + offset); + TRect rc2(pt2.iX, pt2.iY, pt2.iX + size2.iWidth, pt2.iY + size2.iHeight); + + //Create&load brush bitmap + CFbsBitmap* brush_bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(brush_bitmap); + err = brush_bitmap->Load(KComprRamBitmap16, 10); + TEST(err == KErrNone); + + for(TInt ii=0;iiClear(); + + iGc->DrawText(_L("Src bitmap"), TPoint(pt1.iX, pt1.iY - 2)); + iGc->DrawBitmap(rc1, srcBmp); + + iGc->DrawText(_L("Mask bitmap"), TPoint(pt2.iX, pt2.iY - 2)); + iGc->DrawBitmap(rc2, maskBmp); + + TBuf<64> text2; + _LIT(KMaskMode,"BitBltMasked, Mode: E%S"); + text2.Format(KMaskMode, &ColorModeName(ii)); + iGc->DrawText(text2, TPoint(150, pt2.iY-2)); + + TPoint pt(pt1.iX + size1.iWidth + offset, pt1.iY); + TRect rc(0, 0, size1.iWidth, size1.iHeight); + + CGraphicsContext::TBrushStyle brushStyle[] = + { + CGraphicsContext::ENullBrush, + CGraphicsContext::ESolidBrush, + CGraphicsContext::EPatternedBrush + }; + + TBuf<32> text[sizeof(brushStyle)/sizeof(brushStyle[0])] = + { + _L("NonFlicker"), + _L("NonFlickerSolid"), + _L("NonFlickerPatterned") + }; + + iGc->UseBrushPattern(brush_bitmap); + + for(TInt j=0;jDrawText(text[j], TPoint(pt.iX, pt.iY - 2)); + iGc->SetBrushStyle(brushStyle[j]); + iGc->BitBltMasked(pt, srcBmp, rc, maskBmp, ETrue); + } + + iDevice->Update(); + User::After(500000); + + DestroyFont(); + }//end of - for(TInt ii=0;ii= 0; y--) + { + DrawPie(_L("DEF081298"), TRect(0, 0, rectLength, rectWidth), TPoint(0, 0), TPoint(rectLength, y)); + } + for (TInt x = rectLength; x >= 0; x--) + { + DrawPie(_L("DEF081298"), TRect(0, 0, rectLength, rectWidth), TPoint(0, 0), TPoint(x, 0)); + } + + DestroyFont(); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0055 + + @SYMDEF Panic in bitgdi in Typhoon 30. + + @SYMTestCaseDesc INC037380 + + @SYMTestPriority normal + + @SYMTestStatus Implemented + + @SYMTestActions Test BitBltMasked works correctly with 64K bitmaps and EGray256 masks + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::INC037380L() + { + TInt ii; + TInt err; + //Create the screen device + err = CreateScreenDeviceL(EColor64K); + if (err == KErrNotSupported) + err = CreateScreenDeviceL(EColor16MA); + if (err == KErrNotSupported) + err = CreateScreenDeviceL(EColor16MAP); + if (err == KErrNotSupported) + return; + User::LeaveIfError(err); + //Create source bitmap + CFbsBitmap* srcBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(srcBmp); + User::LeaveIfError(srcBmp->Create(TSize(500, 1), EColor16M)); + TBitmapUtil bmpUtil1(srcBmp); + bmpUtil1.Begin(TPoint(0, 0)); + for(ii=0;ii<500;ii++) + { + bmpUtil1.SetPos(TPoint(ii,0)); + bmpUtil1.SetPixel(ii); + } + bmpUtil1.End(); + //Create mask bitmap + CFbsBitmap* maskBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(maskBmp); + User::LeaveIfError(maskBmp->Create(TSize(20, 1), EGray256)); + TBitmapUtil bmpUtil2(maskBmp); + bmpUtil2.Begin(TPoint(0, 0)); + for(ii=0;ii<20;ii++) + { + bmpUtil1.SetPos(TPoint(ii,0)); + bmpUtil2.SetPixel(100 + ii); + } + bmpUtil2.End(); + //Create brush bitmap + CFbsBitmap* brush_bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(brush_bitmap); + User::LeaveIfError(brush_bitmap->Create(TSize(20, 1), EColor64K)); + TBitmapUtil bmpUtil3(brush_bitmap); + bmpUtil3.Begin(TPoint(0, 0)); + for(ii=0;ii<20;ii++) + { + bmpUtil1.SetPos(TPoint(ii,0)); + bmpUtil3.SetPixel(200 + ii); + } + bmpUtil3.End(); + + iGc->Clear(); + iGc->DrawBitmap(TRect(0, 20, 500, 21), srcBmp); + iGc->DrawBitmap(TRect(0, 22, 20, 23), maskBmp); + iGc->UseBrushPattern(brush_bitmap); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + + //The following call panics if the fix doesn't exist. + iGc->BitBltMasked(TPoint(0, 0), srcBmp, TRect(0, 0, 500, 1), maskBmp, ETrue); + + iDevice->Update(); + + CleanupStack::PopAndDestroy(brush_bitmap); + CleanupStack::PopAndDestroy(maskBmp); + CleanupStack::PopAndDestroy(srcBmp); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0056 + + @SYMDEF INC037474 + + @SYMTestCaseDesc CBitwiseBitmap::GenerateLineFromCompressedSixteenBitData() is very slow + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions measures the time the GenerateLineFromCompressedSixteenBitData method takes with different target modes + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::INC037474L() + { + TPtrC bmpFile[] = + { + KBmpCompr12(), + KBmpCompr16(), + KBmpCCompr12(), + KBmpCCompr16() + }; + TPtrC tt[] = {_L("rom"), _L("rom"), _L("ram"), _L("ram")}; + TBool inRam[] = {EFalse, EFalse, ETrue, ETrue}; + TInt bpp[] = {12, 16, 12, 16}; + TDisplayMode targetMode[] = {EColor4K, EColor64K, EColor4K, EColor64K}; + const TInt KMaxScanLineLen = 800; + TBuf8 scanLineBuf; + for(TInt ii=0;iiCompress()); + } + // + TDesC& des = tt[ii]; + INFO_PRINTF3(_L("%d bpp %S compressed bitmap, GetScanLine test"), bpp[ii], &des); + TSize size = bmp->SizeInPixels(); + TEST(TInt(size.iWidth * sizeof(TInt16)) <= KMaxScanLineLen); + bmp->LockHeap(); + CBitwiseBitmap* bmp2 = bmp->Address(); + TUint32* dataAddr = bmp->DataAddress(); + TLineScanningPosition scanLinePos(dataAddr); + TPoint pt00(0, 0); + TUint timeStart = User::TickCount(); + for(TInt j=0;j<100;j++) + { + TPoint startPixel(0, 0); + for(TInt k=0;kGetScanLine(scanLineBuf, startPixel, size.iWidth, + EFalse, pt00, targetMode[ii], + dataAddr, scanLinePos); + } + } + TUint timeEnd = User::TickCount(); + INFO_PRINTF4(_L("%d bpp %S compressed bitmap, time = %d"), bpp[ii], &des, timeEnd - timeStart); + bmp->UnlockHeap(); + // + CleanupStack::PopAndDestroy(bmp); + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0057 + + @SYMDEF INC037370 + + @SYMTestCaseDesc Corrupted compressed images + + @SYMTestPriority normal + + @SYMTestStatus Implemented + + @SYMTestActions Creates some compressed bitmaps, resizes them and compares results + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +//INC037370 - Corrupted compressed images +void CTDefect::INC037370L() + { + CreateScreenDeviceL(); + TPtrC bmpFile[] = {KBmp16_1(), KBmp16_2(), KBmp16_3()}; + CFbsBitGcBitmap* bmp[] = {NULL, NULL, NULL}; + const TInt bmpArrSize = sizeof(bmp) / sizeof(bmp[0]); + //Load the bitmaps + ::LoadBitmapsLC(&bmp, bmpFile); + TInt ii; + //Compress the bitmaps + for(ii=0;iiCompress(); + } + //Display the bitmaps + ::DisplayBitmaps(&bmp, iDevice, iGc); + //Resize bitmap[0] + const TInt KResize = 100; + TSize size = bmp[0]->SizeInPixels(); + size.iWidth -= KResize; + size.iHeight -= KResize; + bmp[0]->Resize(size); + //Display the bitmaps again. If the defect is not fixed - bmp[0] image is corrupted! + ::DisplayBitmaps(&bmp, iDevice, iGc); + //Compare bmp[0] and bmp[1]. If the defect is not fixed - the test will fail! + ::CompareBitmaps(&bmp, EColor64K, 0, 1, this); + //Resize bitmap[1] + size = bmp[1]->SizeInPixels(); + size.iWidth += KResize; + size.iHeight += KResize; + bmp[1]->Resize(size); + //Display the bitmaps again. If the defect is not fixed - bmp[1] image is corrupted! + ::DisplayBitmaps(&bmp, iDevice, iGc); + //Compare bmp[1] and bmp[2]. If the defect is not fixed - the test will fail! + ::CompareBitmaps(&bmp, EColor64K, 1, 2, this); + //Destroy the bitmaps + ::DestroyBitmaps(&bmp); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0058 + + @SYMDEF + + @SYMTestCaseDesc Tests setting of various display modes + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Sets display modes then displays bitmaps + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +//Test CFbsBitmap::SetDisplayMode() +void CTDefect::TestSettingDisplayModeL() + { + TDisplayMode mode[] = {ENone, EGray2, EGray4, EGray16, EGray256, EColor16, EColor256, + EColor64K, EColor16M, ERgb, EColor4K, EColor16MU, EColor16MA, EColor16MAP}; + _LIT(KLog,"Running test with display mode %S (index=%d)"); + for(TInt ii=0;iiLoad(KRamBitmap, 0); + TEST(err == KErrNone); + TDisplayMode initialDisplayMode = iBitmap->InitialDisplayMode(); + TInt bmpMode; + //From the initial display mode to EGray2 mode. + for(bmpMode=initialDisplayMode;bmpMode!=ENone;bmpMode--) + { + DisplayBitmap(rc, mode[ii], TDisplayMode(bmpMode)); + } + //From EGray2 mode to the initial display mode + for(bmpMode=EGray2;bmpMode<=initialDisplayMode;bmpMode++) + { + DisplayBitmap(rc, mode[ii], TDisplayMode(bmpMode)); + } + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0059 + + @SYMDEF + + @SYMTestCaseDesc Tests setting of various display modes + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions tests display modes are set correctly by checking scanline data wlan + + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::TestSettingDisplayMode2L() + { + // Try color mode 64K, 256 and 16MA + TInt err=CreateScreenDeviceL(EColor64K); + if (err!=KErrNone) + err=CreateScreenDeviceL(EColor256); + if (err!=KErrNone) + err=CreateScreenDeviceL(EColor16MA); + if (err!=KErrNone) + err=CreateScreenDeviceL(EColor16MAP); + User::LeaveIfError(err); + DeleteBitmap(); + const TInt KBmpWidth = 100; + //The bitmap data - for EColor16MU - the pixel with the largest width in bits + const TInt bytePerPixel = 4; + TUint8 srcBmpData[KBmpWidth * bytePerPixel]; + Mem::Fill(srcBmpData, sizeof(srcBmpData) / 2, 0xFF); //First half is white colored + Mem::Fill(srcBmpData + sizeof(srcBmpData) / 2, sizeof(srcBmpData) / 2, 0x00);//Second half is black colored + //The bitmap + iBitmap = new (ELeave) CFbsBitmap; + User::LeaveIfError(iBitmap->Create(TSize(KBmpWidth, 1), EColor16MU)); + const TSize KSize = iBitmap->SizeInPixels(); + TPtr8 p(srcBmpData, KBmpWidth * bytePerPixel, KBmpWidth * bytePerPixel); + iBitmap->SetScanLine(p, 0); + TDisplayMode mode[] = {EColor16MAP, EColor16MA, EColor16MU, EColor16M, EColor64K, + EColor4K, EColor256, EGray256, EColor16, + EGray16, EGray4, EGray2}; + TInt ii; + for(ii=0;iiSetDisplayMode(aMode); + TEST(err == KErrNone); + TSize size = iBitmap->SizeInPixels(); + TEST(aInitialSize == size); + TEST(iBitmap->DisplayMode() == aMode); + INFO_PRINTF2(_L("Check scanline in display mode: %d"), aMode); + CheckScanLine(); + } + +void CTDefect::CheckScanLine() + { + TSize size = iBitmap->SizeInPixels(); + TInt j; + TRgb whiteColor(0xFF, 0xFF, 0xFF); + TPoint pt(0, 0); + for(j=0;j<(size.iWidth/2);j++) + { + TRgb color; + pt.iX = j; + iBitmap->GetPixel(color, pt); + TEST(color == whiteColor); + } + TRgb blackColor(0x00, 0x00, 0x00); + for(j=(size.iWidth/2);jGetPixel(color, pt); + if(color != blackColor) + { + ERR_PRINTF1(_L("Scan line error")); + } + TEST(color == blackColor); + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0060 + + @SYMDEF + + @SYMTestCaseDesc tests swapping a bitmaps width and height + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates a bitmap, swaps its width and height and tests for correct size + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::TestSwappingWidthAndHeightL() + { + // Try color mode 64K, 256 and 16MA + TInt err=CreateScreenDeviceL(EColor64K); + if (err!=KErrNone) + err=CreateScreenDeviceL(EColor256); + if (err!=KErrNone) + err = CreateScreenDeviceL(EColor16MA); + if (err!=KErrNone) + err = CreateScreenDeviceL(EColor16MAP); + User::LeaveIfError(err); + DestroyFont(); + CreateFontL(); + + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + err = iBitmap->Load(KRamBitmap, 0); + TEST(err == KErrNone); + + TSize size1_1 = iBitmap->SizeInPixels(); + TSize size1_2 = iBitmap->SizeInTwips(); + TRect rc(10, 20, 610, 220); + TPtrC text(_L("Before swapping")); + DisplayBitmap(text, rc); + + iBitmap->SwapWidthAndHeight(); + TSize size2_1 = iBitmap->SizeInPixels(); + TSize size2_2 = iBitmap->SizeInTwips(); + TEST(size1_1.iWidth == size2_1.iHeight && size1_1.iHeight == size2_1.iWidth); + TEST(size1_2.iWidth == size2_2.iHeight && size1_2.iHeight == size2_2.iWidth); + + text.Set(_L("After swapping")); + DisplayBitmap(text, rc); + rc = TRect(10, 20, 210, 620); + DisplayBitmap(text, rc); + + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + iBitmap->Create(TSize(17, 1), EGray2); + + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + iBitmap->Create(TSize(1, 17), EGray2); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0061 + + @SYMDEF DEF038774 + + @SYMTestCaseDesc Buffer overflow when using CFbsBitmapDevice::GetScanLine and EGray2 disp.mode + EGray4, EGray16, EColor16 modes also tested. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates bitmap of various width depending on the colour mode and checks that its buffer + does not get an overflow when written to + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::DEF038774L() + { + enum {KHeight = 1};//Bitmaps height - in pixels + TDisplayMode testMode[] = {EGray2, EGray4, EGray16, EColor16, EColor4K, EColor64K, EColor16M, EColor16MU, EColor16MA, EColor16MAP};//tested display modes + const TInt pixelPerByte[] ={8, 4, 2, 2, 0, 0, 0, 0, 0}; + const TInt bytePerPixel[] ={0, 0, 0, 0, 2, 2, 3, 4, 4}; + const TInt bitmapWidth[] = {22, 7, 11, 11, 3, 3, 1, 1, 1};//bitmaps width + const TUint8 KTestVal1 = 0xA3;//test value + const TUint8 KTestVal2 = 0xF7;//test value + TUint8 scanLineData[100];//100 should be enough for all possible modes which are tested + for(TInt ii=0;iiSetScanLine(p, 0); + //Create bitmap device (KWidth, KHeight) size + DeleteBitmapDevice(); + iBmpDevice = CFbsBitmapDevice::NewL(iBitmap); + //Fill the scanLineData with control values + Mem::Fill(scanLineData, sizeof(scanLineData), KTestVal2); + //GetScanLine test - check the (scanLineLen + 1) byte + iBmpDevice->GetScanLine(p, TPoint(), bitmapWidth[ii], testMode[ii]); + TEST(scanLineData[scanLineLen + 1] == KTestVal2); + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0086 + + @SYMDEF DEF121299 + + @SYMTestCaseDesc Ensure alpha channel is not overwritten in 16MU BitBlt/DrawBitmap Operations. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates 1x1 or 2x2 pixel Bitmaps with non 0x00/0xFF alpha channel to test BitBlt/DrawBitmap operations. + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::TestBitBltOperationsOn16muUndefinedByteL() + { + //Create a source bitmap and set the Alpha channel to a Non 0xFF/0x00 value. + CFbsBitmap* srcbmp = new(ELeave) CFbsBitmap(); + CleanupStack::PushL(srcbmp); + User::LeaveIfError(srcbmp->Create(TSize(1,1), EColor16MU)); + + *(srcbmp->DataAddress()) = 0x55000000; + + CFbsBitmap* destbmp = new(ELeave) CFbsBitmap(); + CleanupStack::PushL(destbmp); + //Create this one as 2x2 so DrawBitmap tests will work. + User::LeaveIfError(destbmp->Create(TSize(2,2), EColor16MU)); + + //Create Bitmap Device & Gc to perform BitBlt/DrawBmp operations. + CFbsBitmapDevice* bmpdev = CFbsBitmapDevice::NewL(destbmp); + CleanupStack::PushL(bmpdev); + CFbsBitGc* bmpgc; + User::LeaveIfError(bmpdev->CreateContext(bmpgc)); + CleanupStack::PushL(bmpgc); + bmpgc->Activate(bmpdev); + + //Create Extra Mask Bitmap + CFbsBitmap* bmpmask16mu = new(ELeave)CFbsBitmap(); + CleanupStack::PushL(bmpmask16mu); + User::LeaveIfError(bmpmask16mu->Create(TSize(2,2), EColor16MU)); + + //BitBlt + INFO_PRINTF1(_L("Performing BitBlt() Test")); + bmpgc->BitBlt(TPoint(0,0), srcbmp); + TEST(CompareFirstPixelAlphaChannel(srcbmp, destbmp)); + + //BitBltMasked + INFO_PRINTF1(_L("Performing BitBltMasked() Test")); + bmpgc->BitBltMasked(TPoint(0,0), srcbmp, TRect(TPoint(0,0), TSize(1,1)), srcbmp, EFalse); + TEST(CompareFirstPixelAlphaChannel(srcbmp, destbmp)); + + CleanupStack::PopAndDestroy(5, srcbmp); + } + + +void CTDefect::DeleteBitmap() + { + if(iBitmap) + { + iBitmap->Reset(); + } + delete iBitmap; + iBitmap = NULL; + } + +void CTDefect::DeleteBitmapDevice() + { + delete iBmpDevice; + iBmpDevice = NULL; + } + +void CTDefect::DeleteScreenDevice() + { + delete iDevice; + iDevice = NULL; + } + +void CTDefect::DeleteGraphicsContext() + { + delete iGc; + iGc = NULL; + } + +void CTDefect::DisplayBitmapL(const TDesC& aFileName, TInt aBitmapNo, TInt aBitmapOffset, const TDesC& aText, const TRect& aRc) + { + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + TInt err = iBitmap->Load(aFileName, aBitmapNo, EFalse, aBitmapOffset); + if(err) + INFO_PRINTF3(_L("Error (%d) while loading bitmap (%S)"), err, &aFileName); + TEST(err == KErrNone); + DisplayBitmap(aText, aRc); + } + +void CTDefect::DisplayBitmap(const TDesC& aText, const TRect& aRc) + { + iGc->Clear(); + iGc->DrawBitmap(aRc, iBitmap); + iGc->DrawText(aText, TPoint(10, 15)); + iDevice->Update(); + User::After(KDelayTime); + } + +void CTDefect::DisplayBitmap(const TRect& aRc, TDisplayMode aScreenMode, TDisplayMode aBmpMode) + { + if (aBmpMode==ENone || aBmpMode==ERgb) + { + return; + } + _LIT(KLog,"ScreenMode: %S, SetDisplayMode: %S"); + TBuf<128> text; + text.Format(KLog,&ColorModeName(aScreenMode),&ColorModeName(aBmpMode)); + INFO_PRINTF1(text); + TInt err = iBitmap->SetDisplayMode(aBmpMode); + TEST(err == KErrNone); + DisplayBitmap(text, aRc); + } + +void CTDefect::CreateFontL() + { + CFbsFont* font = NULL; + TFontSpec fs(_L("Swiss"), 12); + User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInPixels(font, fs)); + iGc->UseFont(font); + } + +void CTDefect::DestroyFont() + { + if(iGc) + { + iGc->DiscardFont(); + } + } + +void CTDefect::DrawPie(const TDesC& aText, const TRect& aRc, const TPoint& aPtStart, const TPoint& aPtEnd) + { + const TRgb green(0x00, 0xFF, 0x00); + const TRgb red(0xFF, 0x00, 0x00); + const TRgb blue(0x00, 0x00, 0xFF); + const TRgb white(0xFF, 0xFF, 0xFF); + + iGc->SetBrushColor(white); + iGc->Clear(); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(green); + iGc->DrawRect(aRc); + iGc->SetPenColor(blue); + iGc->SetBrushColor(red); + iGc->DrawPie(aRc, aPtStart, aPtEnd); + iGc->SetBrushColor(blue); + iGc->DrawLine( + TPoint(aRc.iTl.iX, aRc.iTl.iY + aRc.Height() / 2), + TPoint(aRc.iTl.iX + aRc.Width(), aRc.iTl.iY + aRc.Height() / 2)); + iGc->DrawLine( + TPoint(aRc.iTl.iX + aRc.Width() / 2, aRc.iTl.iY), + TPoint(aRc.iTl.iX + aRc.Width() / 2, aRc.iTl.iY + aRc.Height())); + iGc->DrawText( + aText, + TPoint(aRc.iTl.iX, aRc.iTl.iY + aRc.Height() + 15)); + iDevice->Update(); + User::After(10000); + } + +void CTDefect::CreateBitmapL(const TSize& aSize, TDisplayMode aMode) + { + DeleteBitmap(); + iBitmap = new (ELeave) CFbsBitmap; + User::LeaveIfError(iBitmap->Create(aSize, aMode)); + } + + +static void DisconnectFbsSession(TAny*) + { + RFbsSession::Disconnect(); + } + +void CTDefect::INC042156L() + { + User::LeaveIfError(RFbsSession::Connect()); + CleanupStack::PushL(TCleanupItem(DisconnectFbsSession, NULL)); + + TInt mbm_offset = 0; + TBuf<100> text; + TPtrC BitmapTypeName[ELastBmpType] = {_L("16 bpp"), _L("24 bpp")}; + typedef enum {ERAMFileType, ERAMCFileType, EROMFileType, EROMCFileType, ELastBmpFileType} TBitmapFileType; + TPtrC BitmapFile[ELastBmpFileType][ELastBmpType] = + { + {KRamBitmap(), KRam24Bitmap()}, + {KRamCBitmap(), KRamC24Bitmap()}, + {KRomBitmap(), KRom24Bitmap()}, + {KRomCBitmap(), KRomC24Bitmap()} + }; + + text = BitmapTypeName[E24BppBmpType]; + text += _L(" ROM compressed bitmap."); + + const TInt KWidth = 20; + const TInt KHeight = 20; + const TInt KAddLength = 10; + CFbsBitmap* fbsBmp = NULL; + + //Create and compress RAM bitmap + //The compression allows us to use the scanline buffer + fbsBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(fbsBmp); + User::LeaveIfError(fbsBmp->Create(TSize(KWidth, KHeight), EColor64K)); + User::LeaveIfError(fbsBmp->Compress()); + TSize size = fbsBmp->SizeInPixels(); + + TUint32* slptr=NULL; + TPoint coord(0,0); + TLineScanningPosition lineScanPos(fbsBmp->DataAddress()); + CFbsBitGcBitmap* srce = (CFbsBitGcBitmap*) fbsBmp; // CFbsBitmap + CBitwiseBitmap* bmp = srce->Address(); + + //Test GetScanLinePtr() + User::LeaveIfError(bmp->GetScanLinePtr(slptr, size.iWidth, coord, fbsBmp->DataAddress(), lineScanPos)); + + //Resize the RAM bitmap + //The scanline buffer will be reallocated + User::LeaveIfError(fbsBmp->Resize(TSize(KWidth + KAddLength, KHeight + KAddLength))); + size = fbsBmp->SizeInPixels(); + + slptr = NULL; + lineScanPos.iSrcDataPtr = (TUint8*)fbsBmp->DataAddress(); + lineScanPos.iCursorPos = 0; + lineScanPos.iScanLineBuffer = 0; + srce = (CFbsBitGcBitmap*) fbsBmp; // CFbsBitmap + bmp = srce->Address(); + + //Test GetScanLinePtr() + User::LeaveIfError(bmp->GetScanLinePtr(slptr, size.iWidth, coord, fbsBmp->DataAddress(), lineScanPos)); + //Destroy RAM bitmap internal data + fbsBmp->Reset(); + + //Load RAM compressed bitmap + //The RAM bitmap is bigger than the previous one, so + //the scanline buffer will be reallocated + User::LeaveIfError(fbsBmp->Load(BitmapFile[ERAMCFileType][E24BppBmpType], 0, EFalse, mbm_offset)); + size = fbsBmp->SizeInPixels(); + TEST(size.iWidth > (KWidth + KAddLength)); + + slptr = NULL; + lineScanPos.iSrcDataPtr = (TUint8*)fbsBmp->DataAddress(); + lineScanPos.iCursorPos = 0; + lineScanPos.iScanLineBuffer = 0; + srce = (CFbsBitGcBitmap*) fbsBmp; // CFbsBitmap + bmp = srce->Address(); + + //Test GetScanLinePtr() + User::LeaveIfError(bmp->GetScanLinePtr(slptr, size.iWidth, coord, fbsBmp->DataAddress(), lineScanPos)); + + CleanupStack::PopAndDestroy(fbsBmp); + CleanupStack::PopAndDestroy();//cleanupItem + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0062 + + @SYMDEF INC070043 + + @SYMTestCaseDesc DrawBitmap() assumes always that source is of type EColor16MA + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Tests that drawing 16MU to 16MU uses the correct alpha values when required and not assume a transparent alpha + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::INC070043L() + { + const TInt KWidth = 100; + const TInt KHeight = 100; + const TInt KWidth11 = KWidth + 20; + const TInt KHeight11 = KHeight + 20; + + //source bitmap + CFbsBitmap* fbsSourceBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(fbsSourceBmp); + User::LeaveIfError(fbsSourceBmp->Create(TSize(KWidth, KHeight), EColor16MU)); + fbsSourceBmp->SetSizeInTwips(TSize(KWidth, KHeight)); + + CFbsBitGc* theBitmapContextSrc = NULL; + CFbsBitmapDevice* theBitmapDeviceSrc = CFbsBitmapDevice::NewL(fbsSourceBmp); + CleanupStack::PushL(theBitmapDeviceSrc); + theBitmapDeviceSrc->CreateContext(theBitmapContextSrc); + CleanupStack::PushL(theBitmapContextSrc); + + //make a drawing + theBitmapContextSrc -> SetBrushStyle(CGraphicsContext::ESolidBrush); + theBitmapContextSrc -> SetPenColor(TRgb(0, 0, 255)); + theBitmapContextSrc -> DrawRect(TRect(0, 0, KWidth, KHeight)); + + //destination bitmap + CFbsBitmap* fbsDestBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(fbsDestBmp); + User::LeaveIfError(fbsDestBmp->Create(TSize(KWidth, KHeight), EColor16MU)); + fbsDestBmp->SetSizeInTwips(TSize(KWidth, KHeight)); + + CFbsBitGc* theBitmapContextDest = NULL; + CFbsBitmapDevice* theBitmapDeviceDest = CFbsBitmapDevice::NewL(fbsDestBmp); + CleanupStack::PushL(theBitmapDeviceDest); + theBitmapDeviceDest->CreateContext(theBitmapContextDest); + CleanupStack::PushL(theBitmapContextDest); + + //bigger destination bitmap + CFbsBitmap* fbsDestBmp1 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(fbsDestBmp1); + User::LeaveIfError(fbsDestBmp1->Create(TSize(KWidth11, KHeight11), EColor16MU)); + fbsDestBmp1->SetSizeInTwips(TSize(KWidth11, KHeight11)); + + CFbsBitGc* theBitmapContextDest1 = NULL; + CFbsBitmapDevice* theBitmapDeviceDest1 = CFbsBitmapDevice::NewL(fbsDestBmp1); + CleanupStack::PushL(theBitmapDeviceDest1); + theBitmapDeviceDest1->CreateContext(theBitmapContextDest1); + CleanupStack::PushL(theBitmapContextDest1); + + + //make a drawing + INFO_PRINTF1(_L("Drawing from 16MU to 16MU memory bitmap")); + theBitmapContextDest-> SetBrushStyle(CGraphicsContext::ESolidBrush); + theBitmapContextDest -> SetPenColor(TRgb(0, 255, 0)); + theBitmapContextDest -> DrawRect(TRect(0, 0, KWidth, KHeight)); + + + theBitmapContextDest->DrawBitmap(TPoint(0, 0), fbsSourceBmp); + + CFbsBitGcBitmap* bmp1 = (CFbsBitGcBitmap*)fbsDestBmp; + CFbsBitGcBitmap* bmp2 = (CFbsBitGcBitmap*)fbsSourceBmp; + CFbsBitGcBitmap* bmp[] = {bmp1, bmp2}; + const TInt bmpArrSize = sizeof(bmp) / sizeof(bmp[0]); + ::CompareBitmaps(&bmp, EColor16MU, 0, 1, this); + +// load from the file + CFbsBitmap* fbsSourceBmp1 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(fbsSourceBmp1); + TInt err = fbsSourceBmp1->Load(_L("z:\\system\\data\\DrawBitmap16MU.MBM")); + fbsSourceBmp1->SetSizeInTwips(TSize(KWidth, KHeight)); + + //with compression + CFbsBitmap* fbsSourceBmp2 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(fbsSourceBmp2); + err = fbsSourceBmp2->Load(_L("z:\\system\\data\\DrawBitmapComp16MU.MBM")); + fbsSourceBmp2->SetSizeInTwips(TSize(KWidth, KHeight)); + + INFO_PRINTF1(_L("Drawing from 16MU to 16MU bitmap")); + theBitmapContextDest->DrawBitmap(TPoint(0, 0), fbsSourceBmp1); + bmp1 = (CFbsBitGcBitmap*)fbsDestBmp; + bmp2 = (CFbsBitGcBitmap*)fbsSourceBmp1; + CFbsBitGcBitmap* bmp11[] = {bmp1, bmp2}; + const TInt bmpArrSize1 = sizeof(bmp11) / sizeof(bmp11[0]); + ::CompareBitmaps(&bmp11, EColor16MU, 0, 1, this); + +// drawing to the bigger destination + INFO_PRINTF1(_L("Drawing from 16MU to 16MU bitmap, where source and distination bitmaps have a different size")); + theBitmapContextDest1-> SetBrushStyle(CGraphicsContext::ESolidBrush); + theBitmapContextDest1 -> SetPenColor(TRgb(0, 255, 0)); + theBitmapContextDest1 -> DrawRect(TRect(0, 0, KWidth11, KHeight11)); + theBitmapContextDest1->DrawBitmap(TPoint(0, 0), fbsSourceBmp1); + bmp1 = (CFbsBitGcBitmap*)fbsDestBmp1; + bmp2 = (CFbsBitGcBitmap*)fbsSourceBmp1; + CFbsBitGcBitmap* bmp22[] = {bmp1, bmp2}; + const TInt bmpArrSize2 = sizeof(bmp22) / sizeof(bmp22[0]); + ::CompareBitmaps(&bmp22, EColor16MU, 0, 1, this); + + // drawing to the compressed bitmap + INFO_PRINTF1(_L("Drawing from 16MU to 16MU bitmap, where source bitmap is compressed")); + theBitmapContextDest -> DrawRect(TRect(0, 0, KWidth, KHeight)); + theBitmapContextDest->DrawBitmap(TPoint(0, 0), fbsSourceBmp2); + bmp1 = (CFbsBitGcBitmap*)fbsDestBmp; + bmp2 = (CFbsBitGcBitmap*)fbsSourceBmp2; + CFbsBitGcBitmap* bmp33[] = {bmp1, bmp2}; + const TInt bmpArrSize3 = sizeof(bmp33) / sizeof(bmp33[0]); + ::CompareBitmaps(&bmp33, EColor16MU, 0, 1, this); + + + CleanupStack::PopAndDestroy(fbsSourceBmp2); + CleanupStack::PopAndDestroy(fbsSourceBmp1); + + CleanupStack::PopAndDestroy(theBitmapContextDest1); + CleanupStack::PopAndDestroy(theBitmapDeviceDest1); + CleanupStack::PopAndDestroy(fbsDestBmp1); + + CleanupStack::PopAndDestroy(theBitmapContextDest); + CleanupStack::PopAndDestroy(theBitmapDeviceDest); + CleanupStack::PopAndDestroy(fbsDestBmp); + + CleanupStack::PopAndDestroy(theBitmapContextSrc); + CleanupStack::PopAndDestroy(theBitmapDeviceSrc); + CleanupStack::PopAndDestroy(fbsSourceBmp); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0063 + + @SYMDEF + + @SYMTestCaseDesc The behaviour of SwapWidthAndHeight() is different for both Create() + and Load() functions. This might be a defect but needs no bother unless + a solution is requested by clients. + + Lets suppose we have a bitmap of size (40, 12) and a CFbsBitmap object + contructed to hold it. When we use Create() and EColor16 for color depth + as in the following: + iBitmap = new (ELeave) CFbsBitmap; + iBitmap->Create(iSize, EColor16); + the size of the bitmap internally will be 240bytes for EColor16. THE SIZE WILL + BE DIFFERENT FOR EACH COLOR DEPTH. + + When applying SwapWidthAndHeight() the function finds that the size available + (240Bytes) is less than the one needed after the swap (360Byes). This applies + to EColor16, EGray16, EGray4, EGray2 colors modes always and to the rest when + the dimenssions of the bitmap are irrelative (width too much bigger than height). + Before the fix is added SwapWidthAndHeight() used to leave without applying the + swapping. The fix however reallocates memory to fit the new swapped bitmap. + + Now if we use Load() without Create() as in the following: + iBitmap = new (ELeave) CFbsBitmap; + iBitmap->Load(KBmp16_2, 0); + the color depth of the system that best matches the bitmap's will be used. In + our case here it is EColor64K.So the size of the bitmap will be 960Bytes.Changing + the color depth via SetDisplayMode(...) will limit the modification to color + depths that are less than the one used for the bitmap, ie EColor64K. ONLY THE + COLOR DEPTH WILL CHANGE BUT THE SIZE OF THE BITMAP WILL NOT BE RECALCULATED. + This means that the size of the new swapped bitmap will always be less than the + original one with 960Bytes. That why SwapWidthAndHeight() will always pass with + Load() function, unlike using Create() which recalulates the new size. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Creates bitmaps in various colour modes and blits + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ +void CTDefect::BitmapsSwappingTest() + { + CreateScreenDeviceL(); + // All color depths are to be tested. Before the fix EColor16, EGray16, EGray4, EGray2 + // used to fail the swapping. + TDisplayMode testMode[] = {EColor4K, EColor64K, EColor16M, EColor16MU, EColor256, EGray256, + /**/ EColor16, EGray16, EGray4, EGray2 /**/}; + + for(TInt ii=0;iiCreate(iSize, testMode[ii])); + + iGc->Clear(); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(TRgb(0x00, 0x00, 0x00)); + // Apply the swap for the created bitmap with the specified color depth + User::LeaveIfError(iBitmap->SwapWidthAndHeight()); + iGc->BitBlt(TPoint(0, 0), iBitmap); + iDevice->Update(); + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0064 + + @SYMDEF INC093055 + + @SYMTestCaseDesc BitGdi causes buffer overflow in WServ + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions tests the rotation of the screen and bitbltmasked. + + @SYMTestExpectedResults Test should perform graphics operations succesfully and no overflow should occur. +*/ + +void CTDefect::INC093055L() + { + TInt si; + TInt sj; + TInt err; + //Create the screen device + err = CreateScreenDeviceL(EColor64K); + if(err == KErrNotSupported) + { + return; + } + TSize bmpSize(700,700); + User::LeaveIfError(err); + //Create source bitmap + CFbsBitmap* srcBmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(srcBmp); + User::LeaveIfError(srcBmp->Create(bmpSize, EColor16M)); + TBitmapUtil bmpUtil1(srcBmp); + bmpUtil1.Begin(TPoint(0, 0)); + for(si=0;siCreate(bmpSize, EGray256)); + TBitmapUtil bmpUtil2(maskBmp); + bmpUtil2.Begin(TPoint(0, 0)); + for(si=0;siInitScreen(); + TRect rect(TPoint(20,20), srcBmp->SizeInPixels()); + iGc->Clear(); + iGc->SetClippingRect(rect); + iGc->BitBltMasked(rect.iTl, srcBmp, bmpSize, maskBmp, ETrue); + iGc->CancelClippingRect(); + iDevice->Update(); + User::After(2000000); + pDev->SetOrientation(CFbsDrawDevice::EOrientationRotated90); + iGc->Clear(); + iGc->SetClippingRect(rect); + iGc->BitBltMasked(rect.iTl, srcBmp, bmpSize, srcBmp, ETrue); + iGc->CancelClippingRect(); + iDevice->Update(); + User::After(2000000); + pDev->SetOrientation(CFbsDrawDevice::EOrientationRotated180); + iGc->Clear(); + iGc->SetClippingRect(rect); + iGc->BitBltMasked(rect.iTl, srcBmp, bmpSize, maskBmp, ETrue); + iGc->CancelClippingRect(); + iDevice->Update(); + User::After(2000000); + pDev->SetOrientation(CFbsDrawDevice::EOrientationRotated270); + iGc->Clear(); + iGc->SetClippingRect(rect); + iGc->BitBltMasked(rect.iTl, srcBmp, bmpSize, maskBmp, ETrue); + iGc->CancelClippingRect(); + iDevice->Update(); + User::After(2000000); + pDev->SetOrientation(CFbsDrawDevice::EOrientationNormal); + CleanupStack::PopAndDestroy(pDev); + CleanupStack::PopAndDestroy(maskBmp); + CleanupStack::PopAndDestroy(srcBmp); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0016 + + @SYMDEF PDEF103809 + + @SYMTestCaseDesc Test externalize/internalize of CFbsBitGc + + @SYMTestPriority Medium + + @SYMTestStatus Implemented + + @SYMTestActions Create CFbsBitGc but do not associate a font with it - externalize it - internalize it - check whether font has been created +@SYMTestExpectedResults no font created + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ + +void CTDefect::PDEF103809L() + { + RFbsSession::Connect(); + + CFbsScreenDevice* scr=NULL; //To stop a warning + TDisplayMode mode[] = {EColor64K, EColor16MA, EColor16MAP}; + TInt ii; + TInt err = KErrNotSupported; + for(ii=0;(iiSetAutoUpdate(ETrue); + CleanupStack::PushL(scr); + + CFbsBitGc* gc = NULL; + User::LeaveIfError(scr->CreateContext(gc)); + CleanupStack::PushL(gc); + + // before + TBool before = gc->IsFontUsed(); + INFO_PRINTF2(_L("before: %d"),before); + TEST(before==EFalse); + + // create buffer for save/restore + CBufFlat* buf = CBufFlat::NewL(256); + CleanupStack::PushL(buf); + + // save and then restore + RBufWriteStream ws(*buf,0); + gc->ExternalizeL(ws); + ws.Close(); + RBufReadStream rs(*buf,0); + gc->InternalizeL(rs); + rs.Close(); + + // after + TBool after = gc->IsFontUsed(); + INFO_PRINTF2(_L("after: %d"),after); + TEST(after==EFalse); + + CleanupStack::PopAndDestroy(3, scr); + RFbsSession::Disconnect(); + } + +//Method Initialising src and mask bitmap for DEF104856, DEF108338, DEF103736, PDEF108863 and PDEF110934 +void CTDefect::InitialiseSourceAndMaskLC(CFbsBitmap*& aSrc, TDisplayMode aSrcDispMode, CFbsBitmap*& aMask, TDisplayMode aMaskDispMode, TSize aPicSize, TInt aNumMaskBars, TInt aMaskBarHeight, TSize* aMaskSize) + { + TInt err; + // create src bitmap object + aSrc = new(ELeave) CFbsBitmap; + CleanupStack::PushL(aSrc); + err = aSrc->Create(aPicSize, aSrcDispMode); + + // create mask bitmap object + aMask = new(ELeave) CFbsBitmap; + CleanupStack::PushL(aMask); + if(aMaskSize == NULL ) + { + err = aMask->Create(aPicSize, aMaskDispMode); + } + else + { + err = aMask->Create(*aMaskSize, aMaskDispMode); + } + TEST(err == KErrNone); + + // initialise source + TBitmapUtil srcUtil(aSrc); + srcUtil.Begin(TPoint(0, 0)); + for(TInt y = 0; y < aPicSize.iHeight; ++y) + { + for(TInt x = 0; x < aPicSize.iWidth; ++x) + { + srcUtil.SetPos(TPoint(x, y)); + srcUtil.SetPixel(Color(KRgbRed, aSrcDispMode)); + } + } + srcUtil.End(); + err = aSrc->Compress(); + TEST(err == KErrNone); + + // initialise mask + TBitmapUtil maskUtil(aMask); + maskUtil.Begin(TPoint(0, 0)); + TUint32 maskColor; + if(aMaskSize != NULL) + { + aPicSize = *aMaskSize; + } + for(TInt y = 0; y < aPicSize.iHeight; ++y) + { + for(TInt x = 0; x < aPicSize.iWidth; ++x) + { + maskUtil.SetPos(TPoint(x, y)); + if (((x / (aPicSize.iWidth / aNumMaskBars)) & 1) ^ ((y / aMaskBarHeight) & 1)) + { + maskColor = Color(KRgbWhite, aMaskDispMode); + } + else + { + maskColor = Color(KRgbBlack, aMaskDispMode); + } + maskUtil.SetPixel(maskColor); + } + } + maskUtil.End(); + err = aMask->Compress(); + TEST(err == KErrNone); + } + +/** +Method to check images drawn for TestDoDrawBitmapMaskedL() and TestDoBitBltMaskedL() against expected images drawn. +This method will start checking from point (0,0) of the device drawn to. +@param aDevice Device drawn to +@param aWidth Width of area to check +@param aHeight Height of area to check +@param aPattern Pattern to determine which colour to start checking against +@param aBarHeight Expected height of alternating bars in pixels +*/ +void CTDefect::CheckResults(CFbsDevice* aDevice, TInt aWidth, TInt aHeight, TInt aPattern, TInt aBarHeight) + { + TRgb color; + TRgb checkColor = aPattern == 1? KRgbGreen : KRgbRed; + + for(TInt y = 0; y < aHeight; ++y) + { + for(TInt x = 0; x < aWidth; ++x) + { + aDevice->GetPixel(color, TPoint(x, y)); + if(color != checkColor) + { + TEST(EFalse); + return; + } + } + if (y % aBarHeight == aBarHeight - 1) + { + checkColor = checkColor == KRgbGreen ? KRgbRed : KRgbGreen; + } + } + } + +void CTDefect::TestDoBltMaskedL(TDisplayMode aSrcDispMode, TDisplayMode aMaskDispMode, TDisplayMode aDeviceDispMode, TSize aPicSize, TBool aUseScreenDevice, TBool aInvertMask, TSize* aMaskSize) + { + // create and initialise source and mask bitmap + CFbsBitmap* src = NULL; + CFbsBitmap* mask = NULL; + // Number of vertical changes to mask colour in a row + const TInt KNumMaskBars = 4; + // Height of each bar in pixels + const TInt KMaskBarHeight = 1; + + InitialiseSourceAndMaskLC(src, aSrcDispMode, mask, aMaskDispMode, aPicSize, KNumMaskBars, KMaskBarHeight, aMaskSize); + TInt err; + CFbsDevice* fbsDevice = NULL; + if (aUseScreenDevice) + { + // create screen device + TRAPD(err, fbsDevice = CFbsScreenDevice::NewL(KNullDesC, aDeviceDispMode)); + if (err == KErrNotSupported) + { + INFO_PRINTF1(_L("Display mode is not supported by scdv")); + CleanupStack::PopAndDestroy(2, src); + return; + } + } + else + { + // create device bitmap + CFbsBitmap* deviceBitmap = new(ELeave) CFbsBitmap; + err = deviceBitmap->Create(aPicSize, aDeviceDispMode); + TEST(err == KErrNone); + CleanupStack::PushL(deviceBitmap); + // create bitmap device + fbsDevice = CFbsBitmapDevice::NewL(deviceBitmap); + } + CleanupStack::PushL(fbsDevice); + // create graphics context + CFbsBitGc* gcContext = NULL; + err = fbsDevice->CreateContext(gcContext); + TEST(err == KErrNone); + TEST(gcContext != NULL); + CleanupStack::PushL(gcContext); + gcContext->SetBrushColor(KRgbGreen); + + TInt barwidth = aPicSize.iWidth/KNumMaskBars; + TSize barSize(barwidth, aPicSize.iHeight); + TInt currentPattern = aInvertMask ? 0 : 1; + for(TInt x = 0; x < aPicSize.iWidth; x += barwidth) + { + gcContext->Clear(); + gcContext->BitBltMasked(TPoint(0, 0), src, TRect(TPoint(x, 0), barSize), mask, aInvertMask); + CheckResults(fbsDevice, barwidth, aPicSize.iHeight, currentPattern, KMaskBarHeight); + currentPattern ^= 1; + } + if (aUseScreenDevice) + { + CleanupStack::PopAndDestroy(4, src); // gcContext, fbsDevice, mask, src + } + else + { + CleanupStack::PopAndDestroy(5, src); // gcContext, fbsDevice, deviceBitmap, mask, src + } + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-0095 + +@SYMDEF PDEF110934 + +@SYMTestCaseDesc Test that the bitmap is drawn correctly by testing + mask size less or greater than the bitmap size. Three optimized calls tested for this + CFbsBitGc::DoBitBltMaskedNonFlicker + CFbsBitGc::DoBitBltMaskedFlicker + CFbsBitGc::DoBitBltAlpha + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Create compressed EColor64K bitmap and EGray2 mask and draw bitmap calling + CFbsBitGc::BitBltMasked with a screen device. The drawing is done in a loop + to simulate the scrolling effect as in a browser. + +@SYMTestExpectedResults All the stripes should pass the integrity check. +**/ +void CTDefect::TestDoBitBltMaskedSizeL() + { + TSize maskSize(96,48); + + // Tests DoBitBltMaskedFlicker for which mask height is less than the source bitmap height + TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), EFalse, EFalse, &maskSize); + + if(CFbsDrawDevice::DisplayMode16M() != ENone) + { + // Tests DoBitBltMaskedNonFlicker for which mask height is less than the source bitmap height + TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), ETrue, EFalse, &maskSize); + } + + // Tests DoBitBltAlpha for which mask height is less than the source bitmap height + TestDoBltMaskedL(EColor16MU, EGray256, EColor16MU, TSize(96,96), EFalse, EFalse, &maskSize); + + //Change the mask height and check the optimization for maximum height of the source bitmap + maskSize.SetSize(96,144); + // Tests DoBitBltMaskedFlicker for which mask height is greater than the source bitmap height + TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), EFalse, EFalse, &maskSize); + + if(CFbsDrawDevice::DisplayMode16M() != ENone) + { + // Tests DoBitBltMaskedNonFlicker for which mask height is greater than the source bitmap height + TestDoBltMaskedL(EColor64K, EGray2, EColor16MU, TSize(96,96), ETrue, EFalse, &maskSize); + } + + // Tests DoBitBltAlpha for which mask height is greater than the source bitmap height + TestDoBltMaskedL(EColor16MU, EGray256, EColor16MU, TSize(96,96), EFalse, EFalse, &maskSize); + } + +TUint32 CTDefect::Color(const TRgb& aColor, const TDisplayMode& aDisplayMode) + { + switch (aDisplayMode) + { + case EGray2: + return aColor.Gray2(); + case EGray4: + return aColor.Gray4(); + case EGray16: + return aColor.Gray16(); + case EGray256: + return aColor.Gray256(); + case EColor16: + return aColor.Color16(); + case EColor256: + return aColor.Color256(); + case EColor64K: + return aColor.Color64K(); + case EColor16M: + return aColor.Color16M(); + case EColor16MU: + return aColor.Color16MU(); + case EColor16MA: + return aColor.Color16MA(); + case EColor16MAP: + return aColor.Color16MAP(); + default: + __ASSERT_DEBUG(EFalse, User::Invariant()); + return 0; + } + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0102 + + @SYMDEF ExternalizeInternalizeCFbsBitGCExtraData + + @SYMTestCaseDesc Test externalize/internalize of shadow color in CFbsBitGc + + @SYMTestPriority Medium + + @SYMTestStatus Implemented + + @SYMTestActions Create CFbsBitGc and set the shadow color by calling SetShadowColor(). + Now - externalize it - internalize it - check the shadow color value matches the one that was set + before externalize/internalize. + +@SYMTestExpectedResults Shadow color value should be same after externalize/internalize. + + @SYMTestExpectedResults Test should perform graphics operations succesfully. +*/ + +void CTDefect::ExternalizeInternalizeCFbsBitGCExtraData() + { + RFbsSession::Connect(); + + TInt err; + err = CreateScreenDeviceL(EColor64K); + if (err == KErrNotSupported) + err = CreateScreenDeviceL(EColor16MA); + if (err == KErrNotSupported) + err = CreateScreenDeviceL(EColor16MAP); + if (err == KErrNotSupported) + return; + User::LeaveIfError(err); + _LIT(KLog1,"Created %S Screen Device"); + INFO_PRINTF2(KLog1,&ColorModeName(iDevice->DisplayMode())); + iDevice->SetAutoUpdate(ETrue); + + CFbsBitGc* gc = NULL; + User::LeaveIfError(iDevice->CreateContext(gc)); + CleanupStack::PushL(gc); + + // before + const TRgb color = TRgb(10,20,30); + gc->SetShadowColor(color); + + // create buffer for save/restore + CBufFlat* buf = CBufFlat::NewL(256); + CleanupStack::PushL(buf); + + // save and then restore + RBufWriteStream ws(*buf,0); + gc->ExternalizeL(ws); + ws.Close(); + gc->SetShadowColor(TRgb(0,0,0)); + RBufReadStream rs(*buf,0); + gc->InternalizeL(rs); + + // after + TRgb shadowColor; + gc->GetShadowColor(shadowColor); + TEST(color == shadowColor); + rs.Close(); + + CleanupStack::PopAndDestroy(2,gc); + RFbsSession::Disconnect(); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0107 + + @SYMDEF DEF126160 Clipped scaled-down bitmaps drawn incorrectly using CFbsBitmap::DrawBitmap() + + @SYMTestCaseDesc Test bitmap scaling when drawn with a clip rect applied. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions - Create a CFbsBitmap and draw three horozontal stripes to it. + - Draw the bitmap scaled down on the left of the screen using DrawBitmap(), and scaled down in the + same way but with a clip rect applied on the right of the screen. + - Compare what is drawn on the left with what is drawn on the right (in the appropraite clip rect area only). + - Repeat but with the bitmap scaled up. + - Repeat with no scaling. + + @SYMTestExpectedResults What is drawn on the left should match what is drawn on the right + (in the appropraite clip rect area only). + If this test was run without the fix for DEF126160, what is drawn clipped on the right when the bitmap is + scaled down would not match what is drawn on the left. +*/ +void CTDefect::TestClippedScaledBitmapL() + { + const TDisplayMode KBitmapMode = EColor64K; + const TDisplayMode KDisplayMode[] = {EColor256, EColor4K, EColor16M, EColor16MU, EColor64K, + EGray256, EGray16, EGray4, EGray2, EColor16, EColor16MA, EColor16MAP}; + // Create a screen device and gc for drawing the test bitmap to + TInt ii = 0; + TInt err = KErrNotSupported; + CFbsScreenDevice* scrDev = NULL; + for(;(iiSetAutoUpdate(EFalse); + CleanupStack::PushL(scrDev); + + // Set the bitmap size as one quarter of the screen + TSize bmpSize(scrDev->SizeInPixels().iWidth/2, scrDev->SizeInPixels().iHeight/2); + + CFbsBitGc* scrGc = NULL; + User::LeaveIfError(scrDev->CreateContext(scrGc)); + CleanupStack::PushL(scrGc); + + // Create the test bitmap + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + User::LeaveIfError(bmp->Create(bmpSize, KBitmapMode)); + + CFbsBitmapDevice* bmpDev = CFbsBitmapDevice::NewL(bmp); + User::LeaveIfNull(bmpDev); + CleanupStack::PushL(bmpDev); + + CFbsBitGc* bmpGc; + User::LeaveIfError(bmpDev->CreateContext(bmpGc)); + CleanupStack::PushL(bmpGc); + + // Draw a series of diagonal lines across the bitmap + const TInt KNumTestColors = 7; + const TRgb KTestColors[KNumTestColors] = {KRgbRed, KRgbBlue, KRgbGreen, KRgbYellow, KRgbMagenta, KRgbDarkGreen, KRgbDarkYellow}; + const TInt KPenSize = 20; + bmpGc->SetPenSize(TSize(KPenSize,KPenSize)); + for (TInt i = -KPenSize; i < bmpSize.iWidth+bmpSize.iHeight; i += KPenSize) + { + bmpGc->SetPenColor(KTestColors[i%KNumTestColors]); + bmpGc->DrawLine(TPoint(i,0), TPoint(0,i)); + } + + TRect lhsRect; + TRect rhsRect; + TRect lhsCompareRect; + TRect rhsClipRect; + scrGc->Clear(); + + // Scale down - this is the case that would fail without the fix for DEF126160 + INFO_PRINTF1(_L("- Scaling Down")); + lhsRect.SetRect(TPoint(0,0), TSize(bmpSize.iWidth, bmpSize.iHeight/2)); + rhsRect = lhsRect; + rhsRect.Move(scrDev->SizeInPixels().iWidth/2, 0); + lhsCompareRect.SetRect(TPoint(0,lhsRect.Height()/2), TSize(lhsRect.Width(), lhsRect.Height()/2)); + rhsClipRect = lhsCompareRect; + rhsClipRect.Move(scrDev->SizeInPixels().iWidth/2, 0); + scrGc->DrawBitmap(lhsRect, bmp); + scrGc->SetClippingRect(rhsClipRect); + scrGc->DrawBitmap(rhsRect, bmp); + scrDev->Update(); + TEST(scrDev->RectCompare(lhsCompareRect, *scrDev, rhsClipRect)); + + scrGc->CancelClippingRect(); + scrGc->Clear(); + + // Scale up + INFO_PRINTF1(_L("- Scaling Up")); + lhsRect.SetRect(TPoint(0,0), TSize(bmpSize.iWidth, bmpSize.iHeight*2)); + rhsRect = lhsRect; + rhsRect.Move(scrDev->SizeInPixels().iWidth/2, 0); + lhsCompareRect.SetRect(TPoint(0,lhsRect.Height()/2), TSize(lhsRect.Width(), lhsRect.Height()/2)); + rhsClipRect = lhsCompareRect; + rhsClipRect.Move(scrDev->SizeInPixels().iWidth/2, 0); + scrGc->DrawBitmap(lhsRect, bmp); + scrGc->SetClippingRect(rhsClipRect); + scrGc->DrawBitmap(rhsRect, bmp); + scrDev->Update(); + TEST(scrDev->RectCompare(lhsCompareRect, *scrDev, rhsClipRect)); + + scrGc->CancelClippingRect(); + scrGc->Clear(); + + // No scaling + INFO_PRINTF1(_L("- No Scaling")); + lhsRect.SetRect(TPoint(0,0), bmpSize); + rhsRect = lhsRect; + rhsRect.Move(scrDev->SizeInPixels().iWidth/2, 0); + lhsCompareRect.SetRect(TPoint(0,lhsRect.Height()/2), TSize(lhsRect.Width(), lhsRect.Height()/2)); + rhsClipRect = lhsCompareRect; + rhsClipRect.Move(scrDev->SizeInPixels().iWidth/2, 0); + scrGc->DrawBitmap(lhsRect, bmp); + scrGc->SetClippingRect(rhsClipRect); + scrGc->DrawBitmap(rhsRect, bmp); + scrDev->Update(); + TEST(scrDev->RectCompare(lhsCompareRect, *scrDev, rhsClipRect)); + + CleanupStack::PopAndDestroy(5, scrDev); + } + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0109 + + @SYMDEF DEF128522 EndDataAccess() not called when CFbsBitGc::DrawBitmap() returns + + @SYMTestCaseDesc Test that EndDataAccess() is called correctly when a bitmap is drawn + using CFbsBitGc::DrawBitmap(const TPoint&, const CFbsBitmap*) with twips not set. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + - Create a CFbsBitmap. + - Draw using CFbsBitGc::DrawBitmap(const TPoint&, const CFbsBitmap*) without setting the twips. + - Call CFbsBitmap::DataAddress() on the bitmap, this should mark the bitmap + as volatile as DataAddress() was called outside a BeginDataAccess()/EndDataAccess() pair. + - Call CFbsBitmap::IsVolatile() and check the result. + + @SYMTestExpectedResults + CFbsBitmap::IsVolatile() should return ETrue +*/ +void CTDefect::TestDrawBitmapTwipsNotSet() + { + const TDisplayMode KBitmapMode = EColor64K; + + // Create a screen device and gc for drawing the test bitmap to + const TDisplayMode KDisplayMode[] = {EColor256, EColor4K, EColor16M, EColor16MU, EColor64K, + EGray256, EGray16, EGray4, EGray2, EColor16, EColor16MA, EColor16MAP}; + // Create a screen device and gc for drawing the test bitmap to + TInt ii = 0; + TInt err = KErrNotSupported; + CFbsScreenDevice* scrDev = NULL; + for(;(iiCreateContext(scrGc)); + CleanupStack::PushL(scrGc); + + // Create a test bitmap + CFbsBitmap* bmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + User::LeaveIfError(bmp->Create(TSize(100,100), KBitmapMode)); + + // Draw the bitmap, note that twips have not been set so that DrawBitmap() returns + // directly after the check for twips being set + scrGc->DrawBitmap(TPoint(0,0), bmp); + + // Get the data address of the bitmap. If EndDataAccess() was called correctly + // when DrawBitmap() returned, the bitmap will now be marked as volatile as DataAddress() + // has been called outside a BeginDataAccess()/EndDataAccess() pair. If the bitmap is not + // marked as volatile then EndDataAccess() was not called correctly in DrawBitmap() when + // it returned. + TUint32* data = bmp->DataAddress(); + TBool isVolatile = bmp->IsVolatile(); + TEST(isVolatile); + + CleanupStack::PopAndDestroy(3, scrDev); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0119 + + @SYMDEF INC138992 + + @SYMTestCaseDesc Test CFbsBitGC:: DrawBitmapMasked() with compressed source and mask bitmaps, + where the target area is larger or smaller than source bitmap's size. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions For each configuration: + Create a compressed source and a compressed mask bitmap. + Draw the bitmaps to the device, once with the target area smaller than the size of the source bitmap, + once with the target area larger than the source bitmap. + Compare the actual image drawn with that expected. + + All combinations of following configurations tested : + Mask with display modes EGray2 and EGray256 + Device with display modes EColor64K and EColor16MAP + Mask with sizes same as source bitmap and smaller than source bitmap + + @SYMTestExpectedResults Images drawn should be as expected. +*/ +void CTDefect::TestDrawBitmapMaskedL() + { + // Mask size is same as source bitmap size. This covers same code paths as those using a larger mask size. + INFO_PRINTF1(_L(" - with EGray2 mask, EColor64K source and EColor64K display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray2, EColor64K, TSize(96,48)); + + INFO_PRINTF1(_L(" - with EGray256 mask, EColor64K source and EColor64K display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray256, EColor64K, TSize(96,48)); + + INFO_PRINTF1(_L(" - with EGray2 mask, EColor64K source and EColor16MAP display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray2, EColor16MAP, TSize(96,48)); + + INFO_PRINTF1(_L(" - with EGray256 mask, EColor64K source and EColor16MAP display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray256, EColor16MAP, TSize(96,48)); + + // Mask size is smaller than source bitmap size. + // This covers different code paths to above. + TSize maskSize(48,24); + + INFO_PRINTF1(_L(" - with small EGray2 mask, EColor64K source and EColor64K display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray2, EColor64K, TSize(96,48), &maskSize); + + INFO_PRINTF1(_L(" - with small EGray256 mask, EColor64K source and EColor64K display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray256, EColor64K, TSize(96,48), &maskSize); + + INFO_PRINTF1(_L(" - with small EGray2 mask, EColor64K source and EColor16MAP display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray2, EColor16MAP, TSize(96,48), &maskSize); + + INFO_PRINTF1(_L(" - with small EGray256 mask, EColor64K source and EColor16MAP display")); + TestDoDrawBitmapMaskedL(EColor64K, EGray256, EColor16MAP, TSize(96,48), &maskSize); + } + +/** +Tests drawing masked bitmaps with both stretched (twice original size) and squashed (half original size) destination rectangles +*/ +void CTDefect::TestDoDrawBitmapMaskedL(TDisplayMode aSrcDispMode, TDisplayMode aMaskDispMode, TDisplayMode aDeviceDispMode, TSize aPicSize, TSize* aMaskSize) + { + // create and initialise source and mask bitmap + CFbsBitmap* src = NULL; + CFbsBitmap* mask = NULL; + // Number of vertical changes to mask colour in a row + const TInt KNumMaskBars = 2; + // Height of each bar in pixels + const TInt KMaskBarHeight = 2; + + InitialiseSourceAndMaskLC(src, aSrcDispMode, mask, aMaskDispMode, aPicSize, KNumMaskBars, KMaskBarHeight, aMaskSize); + + TInt err; + CFbsScreenDevice* fbsDevice = NULL; + // create screen device + TRAP(err, fbsDevice = CFbsScreenDevice::NewL(KNullDesC, aDeviceDispMode)); + if (err == KErrNotSupported) + { + WARN_PRINTF1(_L("Display mode is not supported by scdv")); + CleanupStack::PopAndDestroy(2, src); + return; + } + CleanupStack::PushL(fbsDevice); + // create graphics context + CFbsBitGc* gcContext = NULL; + err = fbsDevice->CreateContext(gcContext); + TEST(err == KErrNone); + TEST(gcContext != NULL); + CleanupStack::PushL(gcContext); + gcContext->SetBrushColor(KRgbGreen); + + const TInt KNumScales = 2; + // Scale ratios for destination rects. + const TReal32 KScale[KNumScales] = {0.5, 2.0}; + + TInt barwidth = (aMaskSize ? aMaskSize->iWidth : aPicSize.iWidth)/KNumMaskBars; + TSize barSize(barwidth, aPicSize.iHeight); + + for (TInt ii = 0; ii < KNumScales; ++ii) + { + TSize scaledBarSize(barwidth*KScale[ii], aPicSize.iHeight*KScale[ii]); + TInt currentPattern = 1; //i.e. mask not inverted + TRect scaledDestRect(TPoint(0,0),scaledBarSize); + for(TInt x = 0; x < aPicSize.iWidth; x += barwidth) + { + gcContext->Clear(); + gcContext->DrawBitmapMasked(scaledDestRect,src,TRect(TPoint(x, 0), barSize), mask, EFalse); + fbsDevice->Update(); + CheckResults(fbsDevice, scaledBarSize.iWidth, scaledBarSize.iHeight, currentPattern, KMaskBarHeight*KScale[ii]); + currentPattern ^= 1; + } + } + + CleanupStack::PopAndDestroy(4, src); // gcContext, fbsDevice, mask, src + } + +//-------------- +__CONSTRUCT_STEP__(Defect) + +void CTDefectStep::TestSetupL() + { + TheFs.Connect(); + ::CopyDataFiles(); + } + +void CTDefectStep::TestClose() + { + ::DeleteDataFiles(); + TheFs.Close(); + }