diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/tbit/TAUTO.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/bitgdi/tbit/TAUTO.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,1140 @@ +// Copyright (c) 1997-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 "TAUTO.H" +#include + + +TInt PanicTestThread(TAny* aOption); + +enum TPanicOption + { + EFirst, + EPolygonFiller, + EBitmapDevice, + EDrawBmp1, + EDrawBmp2, + EDrawBmp3, + EGcDevice1, + EGcDevice2, + EGcRegion1, + EGcRegion2, + EUseBrush1, + EUseBrush2, + EUseBrush3, + EUseFont, + EDrawText1, + EDrawText2, + EDrawText3, + ELast + }; + + +CTAuto::CTAuto(CTestStep* aStep): + CTGraphicsBase(aStep), + iScreenDevice(NULL), + iHalfScreen() + { + iTestRect[0].SetRect(21,10,22,50); + iTestRect[1].SetRect(10,21,50,22); + iTestRect[2].SetRect(11,20,90,30); + iTestRect[3].SetRect(10,71,90,80); + iTestRect[4].SetRect(20,10,31,90); + iTestRect[5].SetRect(70,10,80,91); + iTestRect[6].SetRect(10,10,90,90); + iTestRect[7].SetRect(32,32,96,96); + + INFO_PRINTF1(_L(" ")); + } + +CTAuto::~CTAuto() + { + + } + +void CTAuto::RunTestCaseL(const TInt aCurTestCase) + { + ((CTAutoStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EGray2); + break; + case 2: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EGray4); + break; + case 3: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EGray16); + break; + case 4: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EGray256); + break; + case 5: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor16); + break; + case 6: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor256); + break; + case 7: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor4K); + break; + case 8: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor64K); + break; + case 9: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor16M); + break; + case 10: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor16MU); + break; + case 11: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EGray2,15); + break; + case 12: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EGray4,5); + break; + case 13: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EGray16,5); + break; + case 14: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EGray256,5); + break; + case 15: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor16,5); + break; + case 16: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor256,3); + break; + case 17: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor4K,5); + break; + case 18: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor64K,4); + break; + case 19: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor16M,4); + break; + case 20: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor16MU,4); + break; + case 21: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EGray2); + break; + case 22: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EGray4); + break; + case 23: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EGray16); + break; + case 24: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EGray256); + break; + case 25: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor16); + break; + case 26: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor256); + break; + case 27: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor4K); + break; + case 28: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor64K); + break; + case 29: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor16M); + break; + case 30: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor16MU); + break; + case 31: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor16MA); + break; + case 32: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor16MA); + break; + case 33: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor16MA,4); + break; + case 34: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027")); + TestBmpL(EColor16MAP); + break; + case 35: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025")); + TestMem(EColor16MAP); + break; + case 36: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026")); + TestMapL(EColor16MAP,4); + break; + case 37: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0029")); + TestFadingL(); + INFO_PRINTF2(_L("TestCase %d - Passed Fading Test\r\n"),aCurTestCase); + break; + case 38: + ((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0028")); + TestPanics(); + break; + case 39: //exit + ((CTAutoStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTAutoStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTAutoStep*)iStep)->RecordTestResultL(); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0025 + + @SYMDEF + + @SYMTestCaseDesc Tests the memory allocation cleanup after allocations fails + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions sets memory allocation to fail then checks it is cleaned up correctly + + @SYMTestExpectedResults Memory should be successfully cleaned up +*/ +void CTAuto::TestMem(TDisplayMode aDispMode) + { + LowLevelDevice(aDispMode,EFalse); + BitmapDevice(aDispMode); + LowLevelDevice(aDispMode,ETrue); + ScreenDevice(aDispMode); + + INFO_PRINTF2(_L("Mode %d passed memory test\r\n"),aDispMode); + } + +void CTAuto::ScreenDevice(TDisplayMode aDispMode) + { + CFbsScreenDevice* device = NULL; + for (TInt count = 1; ; count++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic,count); + __UHEAP_MARK; + TRAPD(err,device = CFbsScreenDevice::NewL(_L("scdv"),aDispMode)); + if (err == KErrNotSupported) + { + __UHEAP_MARKEND; + break; + } + else if(err == KErrNoMemory) + { + __UHEAP_MARKEND; + } + else if (err == KErrNone) + { + delete device; + __UHEAP_MARKEND; + break; + } + else + { + __UHEAP_MARKEND; + User::Panic(_L("CFbsScreenDevice test failed "),err); + } + } + + __UHEAP_RESET; + } + +void CTAuto::BitmapDevice(TDisplayMode aDispMode) + { + CFbsBitmap bmp; + TInt ret = bmp.Create(TSize(1,1),aDispMode); + if (ret != KErrNone) + User::Panic(_L("Failed to create bitmap"),ret); + + CFbsBitmapDevice* device = NULL; + for (TInt count = 1; ; count++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic,count); + __UHEAP_MARK; + TRAPD(err,device = CFbsBitmapDevice::NewL(&bmp)); + if(err == KErrNotSupported) + { + __UHEAP_MARKEND; + break; + } + else if(err == KErrNoMemory) + { + __UHEAP_MARKEND; + } + else if (err == KErrNone) + { + delete device; + __UHEAP_MARKEND; + break; + } + else + { + __UHEAP_MARKEND; + User::Panic(_L("CFbsBitmapDevice test failed "),err); + } + } + + __UHEAP_RESET; + } + +void CTAuto::LowLevelDevice(TDisplayMode aDispMode,TBool aScreen) + { + TInt address = NULL; + TSize size(0,0); + TInt ret = HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress,address); + if (ret == KErrNone) + ret = HAL::Get(KDefaultScreenNo, HALData::EDisplayXPixels,size.iWidth); + if (ret == KErrNone) + ret = HAL::Get(KDefaultScreenNo, HALData::EDisplayYPixels,size.iHeight); + if (ret != KErrNone) + User::Panic(_L("CFbsDrawDevice test failed "),ret); + + TPckgBuf s; + s().iScreenAddressValid = ETrue; + s().iScreenAddress = REINTERPRET_CAST(TAny*,address); + s().iScreenSize = size; + + CFbsDrawDevice* fdd = NULL; + + for(TInt count = 1; ; count++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic,count); + __UHEAP_MARK; + + if (aScreen) + { + TRAP(ret,fdd = CFbsDrawDevice::NewScreenDeviceL(s(),aDispMode)); + } + else + { + TRAP(ret, fdd = CFbsDrawDevice::NewBitmapDeviceL(s(), aDispMode, CFbsBitmap::ScanLineLength(size.iWidth, aDispMode))); + } + + if (ret == KErrNotSupported) + { + __UHEAP_MARKEND; + break; + } + else if (ret == KErrNoMemory) + { + __UHEAP_MARKEND; + } + else if (ret == KErrNone) + { + delete fdd; + __UHEAP_MARKEND; + break; + } + else + { + __UHEAP_MARKEND; + User::Panic(_L("CFbsDrawDevice test failed "),ret); + } + } + + __UHEAP_RESET; + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0026 + + @SYMDEF + + @SYMTestCaseDesc Colour mapping testing + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions attempts to map four shades of grey to greys in a colourmap + + @SYMTestExpectedResults All pixels should map to the colourmap correctly +*/ +// +// +// +void CTAuto::TestMapL(TDisplayMode aDispMode,TInt aShadowFactor) + { + TRAPD(err,iScreenDevice = CFbsScreenDevice::NewL(_L("scdv"),aDispMode)); + if (err == KErrNotSupported) + return; + User::LeaveIfError(err); + + User::LeaveIfError(iScreenDevice->CreateContext(iScreenGc)); + iScreenDevice->ChangeScreenDevice(NULL); + + TestMapColors(); + TestShadowArea(aShadowFactor); + TestFadeArea(); + + delete iScreenGc; + delete iScreenDevice; + + INFO_PRINTF2(_L("Mode %d passed colour map test\r\n"),aDispMode); + } + +void CTAuto::TestMapColors() + { + TRgb colormap[4]; + TRgb screencolor; + TInt x,y; + + for (TInt count = 0; count < KNumRects; count++) + { + for (TInt color = 0; color < 4 && iScreenDevice->DisplayMode() != EGray2; color++) + { + Clear(TRgb::Gray4(color)); + TRect r(iTestRect[count]); + colormap[0] = TRgb::Gray4(color); + colormap[1] = TRgb::Gray4(3-color); + colormap[2] = colormap[1]; + colormap[3] = colormap[0]; + if (iScreenDevice->DisplayMode() == EColor64K) + { + colormap[0] = TRgb::Color64K(colormap[0].Color64K()); + colormap[1] = TRgb::Color64K(colormap[1].Color64K()); + colormap[2] = colormap[1]; + colormap[3] = colormap[0]; + } + iScreenGc->MapColors(r,colormap,2); + + for(y=0;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + for(y=r.iBr.iY;y<100;y++) + for(x=0;x<100;x++) + { + iScreenDevice->GetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == 3-color); + } + iScreenGc->MapColors(r,colormap,2); + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + } + } + } + +void CTAuto::TestShadowArea(TInt aShadowFactor) + { + TRgb screencolor; + TInt x,y; + + for (TInt count = 0; count < KNumRects; count++) + { + for (TInt color = 0; color < 4; color++) + { + if (color > 0 && iScreenDevice->DisplayMode() == EGray2) + color = 3; + + Clear(TRgb::Gray4(color)); + TRect r(iTestRect[count]); + TRegionFix<1> reg(r); + + iScreenGc->ShadowArea(®); + + for(y=0;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + + for(y=r.iBr.iY;y<100;y++) + for(x=0;x<100;x++) + { + iScreenDevice->GetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray4() == color); + } + + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor.Gray16() == Max(0,color * 5 - aShadowFactor)); + } + } + } + } + +void CTAuto::TestFadeArea() + { + DoTestFadeArea(0,255); + DoTestFadeArea(0,127); + DoTestFadeArea(128,255); + DoTestFadeArea(64,192); + } + +void CTAuto::DoTestFadeArea(TUint8 aBlackMap,TUint8 aWhiteMap) + { + iScreenGc->SetFadingParameters(aBlackMap,aWhiteMap); + + DoTestFadeArea(KRgbWhite,FadeColor(KRgbWhite,aBlackMap,aWhiteMap)); + DoTestFadeArea(KRgbBlack,FadeColor(KRgbBlack,aBlackMap,aWhiteMap)); + + if (iScreenDevice->DisplayMode() == EGray2) + return; // EGray2 mode dithers so only check black & white + + DoTestFadeArea(KRgbGray,FadeColor(KRgbGray,aBlackMap,aWhiteMap)); + DoTestFadeArea(KRgbDarkGray,FadeColor(KRgbDarkGray,aBlackMap,aWhiteMap)); + + if (iScreenDevice->DisplayMode() == EGray4) + return; // EGray4 mode dithers so only check four gray scales + + DoTestFadeArea(KRgbRed,FadeColor(KRgbRed,aBlackMap,aWhiteMap)); + DoTestFadeArea(KRgbGreen,FadeColor(KRgbGreen,aBlackMap,aWhiteMap)); + DoTestFadeArea(KRgbBlue,FadeColor(KRgbBlue,aBlackMap,aWhiteMap)); + } + +void CTAuto::DoTestFadeArea(TRgb aColor,TRgb aFadedColor) + { + TRgb screencolor; + TInt x,y; + + for (TInt count = 0; count < KNumRects; count++) + { + Clear(aColor); + aColor = MapColorToDisplayMode(aColor); + + TRect r(iTestRect[count]); + TRegionFix<1> reg(r); + + iScreenGc->FadeArea(®); + + for(y=0;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor == aColor); + } + + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor == aColor); + } + + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor == aColor); + } + + for(y=r.iBr.iY;y<100;y++) + for(x=0;x<100;x++) + { + iScreenDevice->GetPixel(screencolor,TPoint(x,y)); + TEST(screencolor == aColor); + } + + for(y=r.iTl.iY;yGetPixel(screencolor,TPoint(x,y)); + TEST(screencolor == aFadedColor); + } + } + } + +TRgb CTAuto::FadeColor(TRgb aColor,TInt aBlackMap,TInt aWhiteMap) + { + aColor = MapColorToDisplayMode(aColor); + + TInt red = ((aColor.Red() * (aWhiteMap - aBlackMap + 1)) >> 8) + aBlackMap; + TInt green = ((aColor.Green() * (aWhiteMap - aBlackMap + 1)) >> 8) + aBlackMap; + TInt blue = ((aColor.Blue() * (aWhiteMap - aBlackMap + 1)) >> 8) + aBlackMap; + + aColor = TRgb(red,green,blue); + + aColor = MapColorToDisplayMode(aColor); + + return aColor; + } + +TRgb CTAuto::MapColorToDisplayMode(TRgb aColor) + { + switch (iScreenDevice->DisplayMode()) + { + case EGray2: + aColor = TRgb::Gray2(aColor.Gray2()); + break; + case EGray4: + aColor = TRgb::Gray4(aColor.Gray4()); + break; + case EGray16: + aColor = TRgb::Gray16(aColor.Gray16()); + break; + case EGray256: + aColor = TRgb::Gray256(aColor.Gray256()); + break; + case EColor16: + aColor = TRgb::Color16(aColor.Color16()); + break; + case EColor256: + aColor = TRgb::Color256(aColor.Color256()); + break; + case EColor4K: + aColor = TRgb::Color4K(aColor.Color4K()); + break; + case EColor64K: + aColor = TRgb::Color64K(aColor.Color64K()); + break; + case EColor16M: + aColor = TRgb::Color16M(aColor.Color16M()); + break; + case EColor16MU: + aColor = TRgb::Color16MU(aColor.Color16MU()); + break; + case EColor16MA: + aColor = TRgb::Color16MA(aColor.Color16MA()); + break; + case EColor16MAP: + aColor = TRgb::Color16MAP(aColor.Color16MAP()); + break; + default: + User::Invariant(); + break; + } + + return aColor; + } + +void CTAuto::Clear(TRgb aColor) + { + iScreenGc->SetBrushColor(aColor); + iScreenGc->Clear(); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0027 + + @SYMDEF + + @SYMTestCaseDesc tests drawing a bitmap to the screen in various colour modes + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions draws to a bitmaps gc and the screens gc then compares the result on a per pixel basis + + @SYMTestExpectedResults bitmap and screen should be identical +*/ +// +// Bitmap drawing testing +// +void CTAuto::TestBmpL(TDisplayMode aDispMode) + { + TRAPD(err,iScreenDevice = CFbsScreenDevice::NewL(_L("scdv"),aDispMode)); + if (err == KErrNotSupported) + return; + User::LeaveIfError(err); + iScreenDevice->ChangeScreenDevice(NULL); + User::LeaveIfError(iScreenDevice->CreateContext((CGraphicsContext*&)iScreenGc)); + + iHalfScreen = iScreenDevice->SizeInPixels(); + iHalfScreen.iWidth /= 2; + + CFbsBitmap bitmap; + User::LeaveIfError(bitmap.Create(iHalfScreen,aDispMode)); + + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(&bitmap); + CleanupStack::PushL(bitmapDevice); + CFbsBitGc* bitmapGc = NULL; + User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); + CleanupStack::PushL(bitmapGc); + + TestGc(iScreenGc,iHalfScreen); + TestGc(bitmapGc,iHalfScreen); + + iScreenGc->BitBlt(TPoint(iHalfScreen.iWidth,0),&bitmap); + + TRgb* left = new(ELeave) TRgb[iHalfScreen.iWidth]; + TRgb* right = new(ELeave) TRgb[iHalfScreen.iWidth]; + + TPtr8 leftBuf(REINTERPRET_CAST(TUint8*,left),iHalfScreen.iWidth * sizeof(TRgb),iHalfScreen.iWidth * sizeof(TRgb)); + TPtr8 rightBuf(REINTERPRET_CAST(TUint8*,right),iHalfScreen.iWidth * sizeof(TRgb),iHalfScreen.iWidth * sizeof(TRgb)); + + for (TInt row = 0; row < iHalfScreen.iHeight; row++) + { + iScreenDevice->GetScanLine(leftBuf,TPoint(0,row),iHalfScreen.iWidth,ERgb); + bitmap.GetScanLine(rightBuf,TPoint(iHalfScreen.iWidth,row),iHalfScreen.iWidth,ERgb); + + TRgb* leftPtr = left; + TRgb* rightPtr = right; + + for (TInt col = 0; col < iHalfScreen.iWidth; col++) + { + if (leftPtr[0] != rightPtr[0]) + User::Panic(_L("Screen/bitmap mismatch!"),KErrGeneral); + + leftPtr++; + rightPtr++; + } + } + + delete[] left; + delete[] right; + CleanupStack::PopAndDestroy(2); // bitmapGc,bitmapDevice + delete iScreenGc; + delete iScreenDevice; + + iScreenDevice = NULL; + iScreenGc = NULL; + + bitmap.Reset(); + + INFO_PRINTF2(_L("Mode %d passed bitmap drawing test\r\n"),aDispMode); + } + +void CTAuto::TestGc(CFbsBitGc* aGc,const TSize& aSize) + { + aGc->SetPenStyle(CGraphicsContext::ENullPen); + aGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + aGc->SetBrushColor(KRgbBlack); + aGc->DrawRect(TRect(TPoint(),iScreenDevice->SizeInPixels())); + aGc->SetPenStyle(CGraphicsContext::ESolidPen); + aGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + + Colors(aGc,aSize); + Shapes(aGc,aSize); + } + +void CTAuto::Colors(CFbsBitGc* aGc,const TSize& aSize) + { + TInt i=0; + TInt w=aSize.iWidth; + TInt h=aSize.iHeight; + TInt xinc = w / 16; + TInt lx = 0; + TInt rx = xinc - 1; + + for(i=0;i<256;i++) + { + aGc->SetPenColor(TRgb::Gray256(i)); + aGc->SetBrushColor(TRgb::Gray256(i)); + aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256)); + } + lx += xinc; + rx += xinc; + for(i=0;i<16;i++) + { + aGc->SetPenColor(TRgb::Gray16(i)); + aGc->SetBrushColor(TRgb::Gray16(i)); + aGc->DrawRect(TRect(lx,i*h/16,rx,(i+1)*h/16)); + } + lx += xinc; + rx += xinc; + for(i=0;i<4;i++) + { + aGc->SetPenColor(TRgb::Gray4(i)); + aGc->SetBrushColor(TRgb::Gray4(i)); + aGc->DrawRect(TRect(lx,i*h/4,rx,(i+1)*h/4)); + } + lx += xinc; + rx += xinc; + for(i=0;i<256;i++) + { + aGc->SetPenColor(TRgb(i,0,0)); + aGc->SetBrushColor(TRgb(i,0,0)); + aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256)); + } + lx += xinc; + rx += xinc; + for(i=0;i<256;i++) + { + aGc->SetPenColor(TRgb(0,i,0)); + aGc->SetBrushColor(TRgb(0,i,0)); + aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256)); + } + lx += xinc; + rx += xinc; + for(i=0;i<256;i++) + { + aGc->SetPenColor(TRgb(0,0,i)); + aGc->SetBrushColor(TRgb(0,0,i)); + aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256)); + } + lx += xinc; + rx += xinc; + for(i=0;i<256;i++) + { + aGc->SetPenColor(TRgb::Color256(i)); + aGc->SetBrushColor(TRgb::Color256(i)); + aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256)); + } + lx += xinc; + rx += xinc; + for(i=0;i<16;i++) + { + aGc->SetPenColor(TRgb::Color16(i)); + aGc->SetBrushColor(TRgb::Color16(i)); + aGc->DrawRect(TRect(lx,i*h/16,rx,(i+1)*h/16)); + } + + } + +void CTAuto::Shapes(CFbsBitGc* aGc,const TSize& aSize) + { + aGc->SetBrushStyle(CGraphicsContext::ENullBrush); + aGc->SetPenColor(KRgbWhite); + + TInt w=aSize.iWidth; + TInt h=aSize.iHeight; + + CArrayFixFlat* poly=new(ELeave) CArrayFixFlat(4); + TInt a=w>>1; + TInt b=a+(a>>1); + TPoint temppt(w*5/8,h/48); + poly->AppendL(temppt); + temppt.SetXY(b-1,h*11/48); + poly->AppendL(temppt); + temppt.SetXY(a+1,h*11/48); + poly->AppendL(temppt); + temppt.SetXY(w*5/8,h/48); + poly->AppendL(temppt); + aGc->DrawPolyLine(poly); + delete poly; + + aGc->DrawRect(TRect(a+1,h*7/24,b,h*12/24)); + aGc->DrawRoundRect(TRect(a+1,h*13/24,b,h*18/24),TSize(w/16,h/12)); + aGc->DrawEllipse(TRect(a+1,h*19/24,b,h*24/24)); + aGc->DrawArc(TRect(b+1,h*1/24,w-1,h*6/24),TPoint(w*15/16,h*6/24),TPoint(w*13/16,h*6/24)); + aGc->DrawPie(TRect(b+1,h*7/24,w-1,h*12/24),TPoint(w*13/16,h*7/24),TPoint(w*15/16,h*7/24)); + aGc->DrawEllipse(TRect(b+1,h*13/24,w-1,h*18/24)); + aGc->DrawEllipse(TRect(b+1,h*20/24,w-1,h*23/24)); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0028 + + @SYMDEF + + @SYMTestCaseDesc Tests various graphic panics + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Starts a thread that causes various graphic panics depending on the chosen option + + @SYMTestExpectedResults The thread should panic each time for each chosen option +*/ +void CTAuto::TestPanics() + { + for (TInt opt = EFirst + 1; opt < ELast; opt++) + { + StartThread(opt); + INFO_PRINTF2(_L("Panic test %d passed\r\n"),opt); + } + } + +void CTAuto::StartThread(TInt aOption) + { + RThread thrd; + TRequestStatus stat; + TBuf<256> threadNameBuf; + _LIT(KThreadNameFormat, "ptt%d"); + threadNameBuf.Format(KThreadNameFormat, aOption); + TInt threadCreationVal = thrd.Create(threadNameBuf,PanicTestThread,KDefaultStackSize,0x2000,0x20000,(TAny*)aOption); + TEST(threadCreationVal==KErrNone); + thrd.SetPriority(EPriorityMuchMore); + thrd.Logon(stat); + User::SetJustInTime(EFalse); + thrd.Resume(); + User::WaitForRequest(stat); + thrd.Close(); + User::SetJustInTime(ETrue); + } + + +/** + @SYMTestCaseID GRAPHICS-BITGDI-0029 + + @SYMDEF + + @SYMTestCaseDesc tests fading functionality + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions Tests fading functionality by drawing two rectangles with different alpha values and compares the results + + @SYMTestExpectedResults the two bitmaps should be identical after the operations +*/ +void CTAuto::TestFadingL() + { + TBool res = EFalse; + TRect rectbitmap1(0,0,100,50); + TRect rectbitmap2(25,0,75,100); + + CFbsBitmap* bitmap=new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Create(TSize(100,100), EColor64K)); + + CFbsBitmapDevice* device=CFbsBitmapDevice::NewL(bitmap); + CleanupStack::PushL(device); + + CFbsBitGc* gc; + User::LeaveIfError(device->CreateContext(gc)); + CleanupStack::PushL(gc); + + CFbsBitmap* bitmap2=new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap2); + User::LeaveIfError(bitmap2->Create(TSize(100,100), EColor64K)); + + CFbsBitmapDevice* device2=CFbsBitmapDevice::NewL(bitmap2); + CleanupStack::PushL(device2); + + CFbsBitGc* gc2; + User::LeaveIfError(device2->CreateContext(gc2)); + CleanupStack::PushL(gc2); + + gc->SetBrushStyle(CGraphicsContext::ESolidBrush); + gc->SetPenColor(TRgb(0,0,0,0)); + + //Draws rectangle with Alpha Value 0 when Fading is turned OFF + gc->SetBrushColor(TRgb(0,0,255,255)); + gc->DrawRect(rectbitmap2); + + //Draws rectangle with Alpha Value 255 when Fading is turned OFF + gc->SetBrushColor(TRgb(255,0,0,0)); + gc->DrawRect(rectbitmap1); + + gc2->SetBrushStyle(CGraphicsContext::ESolidBrush); + gc2->SetPenColor(TRgb(0,0,0,0)); + + + //Draws rectangle with Alpha Value 255 when Fading is turned OFF + gc2->SetBrushColor(TRgb(0,0,255,255)); + gc2->DrawRect(rectbitmap2); + + //Draws rectangle with Alpha Value 0 when Fading is turned ON + //Fade Option Turned ON + gc2->SetFaded(ETrue); + gc2->SetBrushColor(TRgb(255,0,0,0)); + gc2->DrawRect(rectbitmap1); + + TRect rect(0,0,100,100); + res = device->RectCompare(rect,*device2,rect); + + CleanupStack::PopAndDestroy(6, bitmap); + TEST(res); + } + +TInt PanicTestThread(TAny* aOption) + { + CTrapCleanup::New(); + RFbsSession::Connect(); + + CFbsScreenDevice* screendevice=NULL; + CFbsBitGc* bitgc=NULL; + CPolygonFiller* polyfill=NULL; + RRegion region; + const TInt option = TInt(aOption); + TInt ret; + + switch (option) + { + case EPolygonFiller: + polyfill=(CPolygonFiller*)User::Alloc(sizeof(CPolygonFiller)); + new(polyfill) CPolygonFiller; + break; + case EDrawBmp1: + case EDrawBmp2: + case EDrawBmp3: + case EDrawText1: + case EDrawText2: + case EDrawText3: + TRAP(ret,screendevice=CFbsScreenDevice::NewL(_L("scdv"),EColor256)); + if (ret == KErrNotSupported) + TRAP(ret,screendevice=CFbsScreenDevice::NewL(_L("scdv"),EGray4)); + if (ret == KErrNotSupported) + TRAP(ret,screendevice=CFbsScreenDevice::NewL(_L("scdv"),EColor4K)); + if (ret != KErrNone) + User::Panic(_L("screendevice failed"),ret); + screendevice->CreateContext((CGraphicsContext*&)bitgc); + break; + case EGcDevice1: + case EGcDevice2: + case EGcRegion1: + case EGcRegion2: + case EUseBrush1: + case EUseBrush2: + case EUseBrush3: + case EUseFont: + TRAP(ret,bitgc=CFbsBitGc::NewL()); + break; + }; + + switch (option) + { + case EPolygonFiller: + polyfill->Construct(NULL,CGraphicsContext::EAlternate); + break; + case EBitmapDevice: + (void)CFbsBitmapDevice::NewL(NULL); + break; + case EDrawBmp1: + bitgc->DrawBitmap(TPoint(0,0),NULL); + break; + case EDrawBmp2: + bitgc->DrawBitmap(TRect(0,0,0,0),NULL); + break; + case EDrawBmp3: + bitgc->DrawBitmap(TRect(0,0,0,0),NULL,TRect(0,0,0,0)); + break; + case EGcDevice1: + bitgc->Resized(); + break; + case EGcDevice2: + bitgc->MapColors(TRect(0,0,0,0),NULL,0,EFalse); + break; + case EGcRegion1: + region.ForceError(); + bitgc->SetClippingRegion(®ion); + break; + case EGcRegion2: + region.AddRect(TRect(-1,-1,1,1)); + bitgc->SetClippingRegion(®ion); + break; + case EUseBrush1: + bitgc->UseBrushPattern(NULL); + break; + case EUseBrush2: + bitgc->UseBrushPattern((CFbsBitmap*)bitgc); + break; + case EUseBrush3: + bitgc->UseBrushPattern(0); + break; + case EUseFont: + bitgc->UseFont(NULL); + break; + case EDrawText1: + bitgc->DrawText(_L("abc"),TPoint(0,0)); + break; + case EDrawText2: + bitgc->DrawText(_L("abc"),TRect(0,0,1,1),0,0); + break; + case EDrawText3: + bitgc->DrawTextVertical(_L("abc"),EFalse); + break; + default: + User::Panic(_L("Default panic"),KErrGeneral); + }; + + return KErrNone; + } +//------- +__CONSTRUCT_STEP__(Auto) + +void CTAutoStep::TestSetupL() + { + FbsStartup(); + User::LeaveIfError(RFbsSession::Connect()); + } + +void CTAutoStep::TestClose() + { + RFbsSession::Disconnect(); + }