diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/tauto/TBACKUPW.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/tauto/TBACKUPW.CPP Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,953 @@ +// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Test backed up windows +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "TBACKUPW.H" + +CTBackedUpWindow::CTBackedUpWindow(CTestStep* aStep): + CTWsGraphicsBase(aStep) + { + } + + +void CTBackedUpWindow::CheckWindow(CFbsBitmap *aBitmap) + { + TPoint oldPos=iBackedUpWindow.Position(); + iBackedUpWindow.SetPosition(TPoint(0,0)); + + iCheckWindow.SetVisible(ETrue); + iCheckWindow.SetPosition(iCheckPos); + + iCheckWindow.BeginRedraw(); + TheGc->Activate(iCheckWindow); + TheGc->BitBlt(TPoint(0,0), aBitmap); + TheGc->Deactivate(); + iCheckWindow.EndRedraw(); + + TheClient->iWs.Flush(); + TheClient->WaitForRedrawsToFinish(); + TBool retVal = TheClient->iScreen->RectCompare(TRect(iSize),TRect(iCheckPos,iSize)); + TEST(retVal); + if (!retVal) + INFO_PRINTF3(_L("TheClient->iScreen->RectCompare(TRect(iSize),TRect(iCheckPos,iSize)) return value - Expected: %d , Actual: %d"), ETrue, retVal); + + iCheckWindow.SetVisible(EFalse); + iBackedUpWindow.SetPosition(oldPos); + } + +void CTBackedUpWindow::CheckWindow() + { + CheckWindow(&iBitmap); + } + +void CTBackedUpWindow::Draw(TInt aDrawFunc, TAny *aParam) + { + TheGc->Activate(iBackedUpWindow); + Draw(aDrawFunc, aParam, TheGc, iBitGc); + TheGc->Deactivate(); + } + +void CTBackedUpWindow::DrawWithTwoGcsL() + { + RBlankWindow blank(TheClient->iWs); + User::LeaveIfError(blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle)); + blank.Activate(); + CWindowGc *gc2; + User::LeaveIfError(TheClient->iScreen->CreateContext(gc2)); + CleanupStack::PushL(gc2); + + CFbsFont *font1; + TFontSpec fspec(KTestFontTypefaceName,200); + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font1,fspec)); + CFbsFont *font2; + TFontSpec fspec2(KTestFontTypefaceName,400); + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font2,fspec2)); + + gc2->Activate(iBackedUpWindow); + gc2->UseFont(font2); + TheGc->Activate(iBackedUpWindow); + TheGc->UseFont(font1); + _LIT(KText,"Testing123"); + TheGc->DrawText(KText,TPoint(20,20)); + gc2->DrawText(KText,TPoint(20,40)); + iBitGc->UseFont(font1); + iBitGc->DrawText(KText,TPoint(20,20)); + iBitGc->UseFont(font2); + iBitGc->DrawText(KText,TPoint(20,40)); + iBitGc->DiscardFont(); + TheGc->Deactivate(); + TheClient->iScreen->ReleaseFont(font2); + TheClient->iScreen->ReleaseFont(font1); + CleanupStack::PopAndDestroy(); + blank.Close(); + } + +void CTBackedUpWindow::Draw(TInt aDrawFunc, TAny *aParam, CBitmapContext *gc1, CBitmapContext *gc2) //DDD + { + CBitmapContext *gc; + for(TInt mode=0;mode<2;mode++) + { + if (mode==0) + gc=gc1; + else + gc=gc2; + gc->Reset(); + switch(aDrawFunc) + { + case 0: + gc->SetBrushColor(*((TRgb *)aParam)); + gc->SetBrushStyle(CGraphicsContext::ESolidBrush); + gc->SetPenStyle(CGraphicsContext::ENullPen); + gc->DrawRect(TRect(iSize)); + break; + case 1: + { + TSize half(iSize.iWidth/2,iSize.iHeight/2); + gc->DrawEllipse(TRect(half)); + gc->DrawEllipse(TRect(TPoint(0,half.iHeight),half)); + TRect rect1(half); + gc->SetOrigin(TPoint(half.iWidth,0)); + gc->SetClippingRect(rect1); + gc->DrawEllipse(rect1); + gc->SetOrigin(TPoint(half.iWidth,half.iHeight)); + gc->SetClippingRect(rect1); + gc->DrawEllipse(rect1); + gc->SetOrigin(TPoint(0,0)); + gc->CancelClippingRect(); + } + break; + case 2: + { + TInt param= *((TInt *)aParam); + if (param&0x1) + gc->DrawLine(TPoint(param+(param*27)%iSize.iWidth,0), + TPoint(iSize.iWidth-((param<<1)+(param*19)%iSize.iWidth),iSize.iHeight)); + else + gc->DrawLine(TPoint(0, (param<<1)+(param*7)%iSize.iHeight), + TPoint(iSize.iWidth,param+(param*13)%iSize.iHeight)); + } + break; + case 3: + { + TPoint pos; + for(;pos.iXDrawLine(pos,pos+TSize(0,iSize.iHeight)); + for(pos.iX=0;pos.iYDrawLine(pos,pos+TSize(iSize.iWidth,0)); + } + break; + } + } + } + +CTBackedUpWindow::~CTBackedUpWindow() + { + iBackedUpWindow.Close(); + iCheckWindow.Close(); + iOomFrontWindow.Close(); + delete iBitGc; + delete iBitmapDevice; + delete iTestBitmap; + delete iMaskBitmap; + } + +void CopyToGray4L(CFbsBitmap*& aDestBitmap,const CFbsBitmap& aSrcBitmap) + { + aDestBitmap=new(ELeave) CFbsBitmap(); + CleanupStack::PushL(aDestBitmap); + User::LeaveIfError(aDestBitmap->Create(aSrcBitmap.SizeInPixels(),EGray4)); + CFbsBitmapDevice* device=CFbsBitmapDevice::NewL(aDestBitmap); + CleanupStack::PushL(device); + CFbsBitGc* gc; + User::LeaveIfError(device->CreateContext(gc)); + gc->BitBlt(TPoint(),&aSrcBitmap); + delete gc; + CleanupStack::PopAndDestroy(device); + CleanupStack::Pop(aDestBitmap); + } + +void CTBackedUpWindow::ConstructL() + { + iBackedUpWindow=RBackedUpWindow(TheClient->iWs); + iBackedUpWindow.Construct(*(TheClient->iGroup->GroupWin()),EGray4,ENullWsHandle); + TSize size=TheClient->iScreen->SizeInTwips(); + iSize=TheClient->iScreen->SizeInPixels(); + iSize.iWidth>>=1; + iSize.iHeight>>=1; + size.iWidth>>=1; + size.iHeight>>=1; + size.iWidth-=1; //Modification to get the mapping factor the same as the screen + size.iHeight-=1; //Ditto + iWinPos.SetXY(iSize.iWidth>>1,iSize.iHeight>>1); + User::LeaveIfError(iBackedUpWindow.SetExtentErr(iWinPos,iSize)); + iBackedUpWindow.Activate(); + + iCheckPos.SetXY(iSize.iWidth,0); + iCheckWindow=RWindow(TheClient->iWs); + iCheckWindow.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle); + iCheckWindow.SetSize(iSize); + iCheckWindow.SetVisible(EFalse); + iCheckWindow.Activate(); + + TInt col,grey; + TDisplayMode defMode=TheClient->iWs.GetDefModeMaxNumColors(col,grey); + User::LeaveIfError(iBitmap.Create(iSize,defMode)); + iBitmap.SetSizeInTwips(size); + iBitmapDevice=CFbsBitmapDevice::NewL(&iBitmap); + User::LeaveIfError(iBitmapDevice->CreateContext(iBitGc)); + + TRgb rgb(TRgb::Gray4(2)); + Draw(0,&rgb); + + iTestBitmap=new(ELeave) CFbsBitmap(); + User::LeaveIfError(iTestBitmap->Load(TEST_BITMAP_NAME,0)); + iTestBitmap->SetSizeInTwips(TSize(1500,750)); + iMaskBitmap=new(ELeave) CFbsBitmap(); + User::LeaveIfError(iMaskBitmap->Load(TEST_BITMAP_NAME,0)); + TDisplayMode defMode2=iMaskBitmap->DisplayMode(); + if (defMode>EGray4) + { + CFbsBitmap* bitmap=iTestBitmap; + CopyToGray4L(iTestBitmap,*bitmap); + delete bitmap; + bitmap=iMaskBitmap; + CopyToGray4L(iMaskBitmap,*bitmap); + delete bitmap; + } + defMode2=iMaskBitmap->DisplayMode(); + defMode2=iMaskBitmap->DisplayMode(); + } + +void CTBackedUpWindow::InvisVis() + { + iBackedUpWindow.SetVisible(EFalse); + TheClient->iWs.Flush(); + iBackedUpWindow.SetVisible(ETrue); + TheClient->iWs.Flush(); + } + +void CTBackedUpWindow::WindowOnTop() + { + RBlankWindow blank(TheClient->iWs); + blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle); + blank.Activate(); + blank.Close(); + TheClient->iWs.Flush(); + + TPoint pos; + TInt sizeMode=0; + TInt draw=13; + + for(pos.iX=-iSize.iWidth;pos.iXiWs); + blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle); + blank.SetColor(TRgb::Gray256(220)); + blank.SetShadowHeight(2); + blank.SetExtent(pos+iWinPos,TSize((sizeMode&0x1)?iSize.iWidth>>1:iSize.iWidth<<1,(sizeMode&0x2)?iSize.iHeight>>1:iSize.iHeight<<1)); + sizeMode=(sizeMode+1)%4; + blank.Activate(); + Draw(2,&draw); + TheClient->iWs.Flush(); + draw++; + blank.Close(); + } + } + +void CTBackedUpWindow::Resize() + { + RBlankWindow blank(TheClient->iWs); + blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle); + blank.SetColor(TRgb::Gray256(128)); + blank.Activate(); + TInt xtop=(iSize.iWidth)-(iSize.iWidth>>2); + TInt ytop=(iSize.iHeight)-(iSize.iHeight>>2); + for(TInt winMode=0;winMode<3;winMode++) + { + switch(winMode) + { + case 0: + blank.SetExtent(TPoint(0,ytop),TSize(iSize.iWidth,iSize.iHeight>>1)); + break; + case 1: + blank.SetExtent(TPoint(xtop,0),TSize(iSize.iWidth>>1,iSize.iHeight)); + break; + case 2: + blank.SetExtent(TPoint(xtop,ytop),TSize(iSize.iWidth>>1,iSize.iHeight>>1)); + break; + } + blank.SetShadowHeight(winMode); + TPoint oldPos=iBackedUpWindow.Position(); + TPoint pos=oldPos; + for(TUint i=0;iiWs.Flush(); + } + iBackedUpWindow.SetPosition(oldPos); + } + blank.Close(); + } + +void CTBackedUpWindow::ChildWindows() + { + TPoint pos; + TInt sizeMode=0; + TInt draw=13; + RBlankWindow blank(TheClient->iWs); + for(pos.iX=-(iSize.iWidth>>1);pos.iX>1);pos.iY>2:iSize.iWidth,(sizeMode&0x2)?iSize.iHeight>>2:iSize.iHeight)); + sizeMode=(sizeMode+1)%4; + blank.Activate(); + Draw(2,&draw); + TheClient->iWs.Flush(); + draw++; + blank.Close(); + } + } + +void CTBackedUpWindow::DupBitmapTestL() + { + INFO_PRINTF1(_L("AUTO Dup Bitmap Test ")); + CFbsBitmap *dup=new(ELeave) CFbsBitmap(); + dup->Duplicate(iBackedUpWindow.BitmapHandle()); + CheckWindow(dup); + TRgb rgb(TRgb::Gray4(1)); + Draw(0,&rgb); + CheckWindow(dup); + INFO_PRINTF1(_L(" Done Window Drawing Test")); + + CFbsBitmapDevice *dupDevice=NULL; + TRAPD(err,dupDevice=CFbsBitmapDevice::NewL(dup)); + CFbsBitGc *gc; + if (err==KErrNone && dupDevice->CreateContext(gc)==KErrNone) + { + Draw(3,NULL,gc,iBitGc); // Draw directly to backup bitmap (and test bitmap) + iBackedUpWindow.UpdateScreen(); + INFO_PRINTF1(_L(" First Bitmap Drawing")); + CheckWindow(); + TRgb rgb(TRgb::Gray256(128)); + TInt col,grey; + if (TheClient->iWs.GetDefModeMaxNumColors(col,grey)>EGray4) + rgb=TRgb::Gray4(2); + Draw(0,&rgb,gc,iBitGc); + Draw(1,NULL,gc,iBitGc); + iBackedUpWindow.UpdateScreen(TRegionFix<1>(TRect(iSize))); + INFO_PRINTF1(_L(" Second Bitmap Drawing")); + CheckWindow(); + delete gc; + } + delete dupDevice; + delete dup; + } + +void CTBackedUpWindow::UpdateBitmapTestL() + { + INFO_PRINTF1(_L("AUTO UpdateBitmap ")); + CheckWindow(); + CFbsBitmap *dup=new(ELeave) CFbsBitmap(); + dup->Duplicate(iBackedUpWindow.BitmapHandle()); + Draw(3,NULL); + iBackedUpWindow.UpdateBackupBitmap(); + INFO_PRINTF1(_L(" First Drawing")); + CheckWindow(dup); + TRgb rgb; + if (iSupState==0) + rgb=TRgb::Gray256(128); + else + rgb=TRgb::Gray4(2); + Draw(0,&rgb); + Draw(1,NULL); + iBackedUpWindow.UpdateBackupBitmap(); + INFO_PRINTF1(_L(" Second Drawing")); + CheckWindow(dup); + delete dup; + } + +void CTBackedUpWindow::OOML() + { + iOomFrontWindow=RBlankWindow(TheClient->iWs); + TSize size(iBackedUpWindow.Size()); + size.iWidth>>=1; + size.iHeight>>=1; + TPoint pos(size.iWidth*3/2,size.iHeight*3/2); + iOomFrontWindow.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle); + iOomFrontWindow.SetColor(TRgb(TRgb::Gray4(1))); + iOomFrontWindow.SetExtent(pos,size); + iOomFrontWindow.Activate(); + TheClient->iWs.Flush(); + + TPoint buwPos=iBackedUpWindow.Position(); + TSize buwSize=iBackedUpWindow.Size(); + for(TInt count=0;count<100;count++) + { + iOomFrontWindow.SetVisible(ETrue); + TheClient->iWs.HeapSetFail(RHeap::EDeterministic,count); + iBackedUpWindow.SetPosition(buwPos+TPoint(10,5)); + iBackedUpWindow.SetPosition(buwPos); + iOomFrontWindow.SetSize(size+TSize(10,5)); + iOomFrontWindow.SetSize(size); + iBackedUpWindow.SetSizeErr(buwSize+TSize(13,7)); + iBackedUpWindow.SetSizeErr(buwSize); + iOomFrontWindow.SetVisible(EFalse); + TheClient->iWs.HeapSetFail(RHeap::ENone,0); + User::LeaveIfError(iBackedUpWindow.SetSizeErr(buwSize)); + TheClient->WaitForRedrawsToFinish(); + CheckWindow(); + } + + iOomFrontWindow.Close(); + } + +void CTBackedUpWindow::doGraphicFunctionsL(CBitmapContext *gc,TBool aExtraDrawBitMap) + { + TSize size=iBackedUpWindow.Size(); + CFbsFont *aFont; + _LIT(KFontName,"Swiss"); + TFontSpec fspec(KFontName,190); + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)aFont,fspec)); + CFbsBitmap* aBitmap=iTestBitmap; + CFbsBitmap* aMaskBitmap=iMaskBitmap; + + #include "DLLDRAW.H" // Draws to a Gc called 'gc' + + TheClient->iScreen->ReleaseFont(aFont); + } + +void CTBackedUpWindow::AllGraphicFunctionsL(RBlankWindow &aBlank,TBool aExtraDrawBitMap/*=ETrue*/) + { + aExtraDrawBitMap=EFalse; //Check out when bitblit scaling has changed again + aBlank.SetVisible(ETrue); + TheGc->Activate(iBackedUpWindow); + TRAPD(err,doGraphicFunctionsL(TheGc,aExtraDrawBitMap)); + TheGc->Deactivate(); + User::LeaveIfError(err); + iBitGc->Reset(); + iBitGc->SetUserDisplayMode(EGray4); + doGraphicFunctionsL(iBitGc,aExtraDrawBitMap); + aBlank.SetVisible(EFalse); + CheckWindow(); + } + +void CTBackedUpWindow::AllGraphicFunctionsTestsL() + { + RBlankWindow blank(TheClient->iWs); + TInt xtop=(iSize.iWidth)-(iSize.iWidth>>1); + TInt ytop=(iSize.iHeight)-(iSize.iHeight>>1); + blank.Construct(*(TheClient->iGroup->GroupWin()),ENullWsHandle); + blank.SetColor(TRgb::Gray256(128)); + blank.Activate(); + blank.SetExtent(TPoint(0,ytop),TSize(iSize.iWidth,iSize.iHeight>>2)); + AllGraphicFunctionsL(blank); + blank.SetExtent(TPoint(0,ytop+10),TSize(iSize.iWidth,iSize.iHeight>>2)); + AllGraphicFunctionsL(blank); + blank.SetExtent(TPoint(xtop,ytop),TSize(iSize.iWidth>>1,iSize.iHeight)); + AllGraphicFunctionsL(blank,EFalse); + blank.SetExtent(TPoint(xtop+(iSize.iWidth>>1),ytop),TSize(iSize.iWidth>>1,iSize.iHeight)); + AllGraphicFunctionsL(blank,EFalse); + blank.SetExtent(TPoint(xtop+10,iSize.iHeight),TSize(iSize.iWidth,iSize.iHeight)); + AllGraphicFunctionsL(blank,EFalse); + blank.SetExtent(TPoint(xtop,ytop),iSize); + AllGraphicFunctionsL(blank,EFalse); + blank.SetExtent(TPoint(0,0),TSize(0,0)); + AllGraphicFunctionsL(blank); + blank.Close(); + } + +void CTBackedUpWindow::RunTestCaseL(TInt /*aCurTestCase*/) + { + switch(iSupState) + { + case 0: + for (TInt iSubTest=0;iSubTestiState=iState; +((CTBackedUpWindowStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(iState) + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0202-0001 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test drawing in a backed up window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw in a backed up window and a normal window and check + the two drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 0: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0202-0001")); + iTest->LogSubTest(KTest0); + Draw(1,NULL); + CheckWindow(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0202-0002 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test drawing in a backed up window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw in a backed up window and a normal window and check + the two drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 1: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0202-0002")); + iTest->LogSubTest(KTest1); + Draw(0,&rgb1); + Draw(3,NULL); + Resize(); + CheckWindow(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0203 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test making a backed up window invisible + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw in a backed up window and a normal window, make + the backed up window invisible then visible and + then check the two drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 2: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0203")); + iTest->LogSubTest(KTest2); + Draw(0,&rgb2); + Draw(1,NULL); + InvisVis(); + CheckWindow(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0204 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test drawing in a backed up window and then placing a + window on top of it + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw in a backed up window and a normal window, then + place a window on top of the backed up window and then + check the two drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 3: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0204")); + iTest->LogSubTest(KTest3); + //TRgb rgb(220,220,220); + Draw(0,&rgb3); + Draw(1,NULL); + WindowOnTop(); + CheckWindow(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0205 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test drawing in a backed up window and then drawing in + a child window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw in a backed up window and a normal window, then + create and draw in a child window and then + check the two original drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 4: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0205")); + iTest->LogSubTest(KTest4); + Draw(0,&rgb4); + Draw(3,NULL); + ChildWindows(); + CheckWindow(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0206 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Out of memeory test for backed up windows + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Out of memeory test for backed up windows + +@SYMTestExpectedResults Backed up window responds correctly when out + of memory +*/ + case 5: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0206")); + iTest->LogSubTest(KTest5); + if (!iTest->IsFullRomL()) + { + Draw(0,&rgb5); + Draw(3,NULL); + OOML(); + CheckWindow(); + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0207 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test updating a bitmap in a backed up window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Update a bitmap in a backed up window and a normal window + and check the two bitmaps are the same + +@SYMTestExpectedResults The two bitmaps are exactly the same +*/ + case 6: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0207")); + iTest->LogSubTest(KTest6); + Draw(0,&rgb6); + Draw(1,NULL); + UpdateBitmapTestL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0208 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test updating a duplicate bitmap in a backed up window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Update a duplicated bitmap in a backed up window and a normal window + and check the two bitmaps are the same + +@SYMTestExpectedResults The two bitmaps are exactly the same +*/ + case 7: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0208")); + if (iSupState==0) //Will fail unless the window is fully backup. + break; + iTest->LogSubTest(KTest7); + Draw(0,&rgb7); + Draw(1,NULL); + DupBitmapTestL(); + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0209 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test drawing with two graphic contexts in a backed up window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw using two graphic contexts in a backed up window and a normal + window and check the two drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 8: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0209")); + iTest->LogSubTest(KTest8); + Draw(0,&color); + Draw(1,NULL); + DrawWithTwoGcsL(); + CheckWindow(); + break; + +/** +@SYMTestCaseID GRAPHICS-WSERV-0210 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test drawing using all the graphic functions in a backed up window + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Draw using all the graphic functions in a backed up window and a normal + window and check the two drawings are the same + +@SYMTestExpectedResults The two drawings are exactly the same +*/ + case 9: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0210")); + iTest->LogSubTest(KTest9); + if(TheClient->iScreen->SizeInPixels() == TSize(640,240)) + AllGraphicFunctionsTestsL(); + break; + + //A Coverage test, nothing spectacular just making the code + //go into CWsGc::Reactivate + case 10: + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0502 +*/ + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0502")); + iTest->LogSubTest(KTest10); + TheGc->Deactivate(); + RBackedUpWindow extentWindow; + extentWindow=RBackedUpWindow(TheClient->iWs); + extentWindow.Construct(*(TheClient->iGroup->GroupWin()),EGray4,ENullWsHandle); + TheGc->Activate(extentWindow); + TheClient->Flush(); + User::LeaveIfError(extentWindow.SetExtentErr(TPoint(2,2), TSize(4,4))); + extentWindow.Activate(); + extentWindow.Close(); + TheGc->Deactivate(); + break; + } + + //Coverage for various messages for CWsGc::DoDrawCommand + case 11: + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0507 +*/ + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0507")); + iTest->LogSubTest(KTest11); + TheGc->Activate(iBackedUpWindow); + TheGc->Reset(); + iBitGc->Reset(); + iBitGc->SetUserDisplayMode(EGray4); + + // EWsGcOpDrawWsGraphic + TheGc->DrawWsGraphic(TWsGraphicId(0), TRect(0,0,10,10)); + + //create a large junk buffer so that messages with Ptr suffix will be sent + RBuf8 junkBuf8; + RBuf junkBuf; + junkBuf8.CreateMax(650); // a large enough buffer to sent as Ptr (this value used to crash the code before) + junkBuf.CreateMax(650); // a large enough buffer to sent as Ptr + for (int i=0; iDrawWsGraphic(TWsGraphicId(0), TRect(0,0,10,10), junkBuf8); + + // Set font for drawing on screen + CFbsFont *font1; + TFontSpec fspec(KTestFontTypefaceName,200); + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont *&)font1,fspec)); + TheGc->UseFont(font1); + iBitGc->UseFont(font1); + + // EWsGcOpDrawTextPtr + TheGc->DrawText(junkBuf, TPoint(0,0)); + iBitGc->DrawText(junkBuf, TPoint(0,0)); + + // EWsGcOpDrawBoxText - unreachable 299-too lo, 300-too hi + + // EWsGcOpDrawBoxTextPtr + TheGc->DrawText(junkBuf, TRect(0,0,10,10), 0, CGraphicsContext::ELeft, 0); + iBitGc->DrawText(junkBuf, TRect(0,0,10,10), 0, CGraphicsContext::ELeft, 0); + + // EWsGcOpDrawTextVerticalPtr + TheGc->DrawTextVertical(junkBuf, TPoint(0,0), ETrue); + iBitGc->DrawTextVertical(junkBuf, TPoint(0,0), ETrue); + + // EWsGcOpDrawBoxTextVerticalPtr + TheGc->DrawTextVertical(junkBuf, TRect(0,0,10,10), 0, ETrue, CGraphicsContext::ELeft, 0); + iBitGc->DrawTextVertical(junkBuf, TRect(0,0,10,10), 0, ETrue, CGraphicsContext::ELeft, 0); + + // EWsGcOpMoveBy + TheGc->MoveBy(TPoint(2,2)); + iBitGc->MoveBy(TPoint(2,2)); + + // a bitmap for bitblt ops + CWsBitmap bmp(TheClient->iWs); + bmp.Create(TSize(16,16), iBackedUpWindow.DisplayMode()); + + // EWsGcOpGdiWsBlt2 + TheGc->BitBlt(TPoint(0,0), &bmp); + iBitGc->BitBlt(TPoint(0,0), &bmp); + + // EWsGcOpGdiWsBlt3 + TheGc->BitBlt(TPoint(0,0), &bmp, TRect(0,0,10,10)); + iBitGc->BitBlt(TPoint(0,0), &bmp, TRect(0,0,10,10)); + + // EWsGcOpGdiWsBltMasked + TheGc->BitBltMasked(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, EFalse); + iBitGc->BitBltMasked(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, EFalse); + + // EWsGcOpGdiWsAlphaBlendBitmaps + TheGc->AlphaBlendBitmaps(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, TPoint(1,1)); + iBitGc->AlphaBlendBitmaps(TPoint(0,0), &bmp, TRect(0,0,10,10), &bmp, TPoint(1,1)); + + // EWsGcOpWsDrawBitmapMasked + TheGc->DrawBitmapMasked(TRect(0,0,10,10), &bmp, TRect(0,0,8,8), &bmp, ETrue); + iBitGc->DrawBitmapMasked(TRect(0,0,10,10), &bmp, TRect(0,0,8,8), &bmp, ETrue); + + // EWsGcOpDrawBitmap + TheGc->DrawBitmap(TPoint(0,0), &bmp); + iBitGc->DrawBitmap(TPoint(0,0), &bmp); + + // EWsGcOpDrawBitmapMasked + TheGc->DrawBitmapMasked(TRect(0,0,10,10), static_cast(&bmp), + TRect(0,0,8,8), static_cast(&bmp), + EFalse); + iBitGc->DrawBitmapMasked(TRect(0,0,10,10), static_cast(&bmp), + TRect(0,0,8,8), static_cast(&bmp), + EFalse); + + // EWsGcOpDrawPolyLineContinued + TheGc->DrawPolyLine(reinterpret_cast(junkBuf8.Ptr()), + TInt(junkBuf8.Size()/sizeof(TPoint))); + iBitGc->DrawPolyLine(reinterpret_cast(junkBuf8.Ptr()), + TInt(junkBuf8.Size()/sizeof(TPoint))); + + // EWsGcOpCopyRect + TheGc->CopyRect(TPoint(0,0), TRect(0,0,10,10)); + iBitGc->CopyRect(TPoint(0,0), TRect(0,0,10,10)); + + //cleanup + TheClient->Flush(); + TheGc->DiscardFont(); + iBitGc->DiscardFont(); + TheClient->iScreen->ReleaseFont(font1); + junkBuf.Close(); + junkBuf8.Close(); + TheGc->Deactivate(); + + CheckWindow(); + + //the following have no client equivalent methods + // EWsGcOpMapColorsLocal + // EWsGcOpDrawPolyLineLocalBufLen + // EWsGcOpDrawPolyLineLocal + // EWsGcOpDrawPolygonLocalBufLen + // EWsGcOpDrawPolygonLocal + // EWsGcOpDrawBitmapLocal + // EWsGcOpDrawBitmap2Local + // EWsGcOpDrawBitmap3Local + // EWsGcOpDrawBitmapMaskedLocal + // EWsGcOpDrawTextPtr1 + // EWsGcOpDrawBoxTextPtr1 + // EWsGcOpDrawTextVerticalPtr1 + // EWsGcOpDrawBoxTextVerticalPtr1 + // EWsGcOpDrawTextLocal + // EWsGcOpDrawBoxTextLocal + // EWsGcOpGdiBlt2Local + // EWsGcOpGdiBlt3Local + // EWsGcOpGdiBltMaskedLocal + ((CTBackedUpWindowStep*)iStep)->CloseTMSGraphicsStep(); + break; + } + + default: + ((CTBackedUpWindowStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTBackedUpWindowStep*)iStep)->CloseTMSGraphicsStep(); + break; + } + ((CTBackedUpWindowStep*)iStep)->RecordTestResultL(); + } + +__WS_CONSTRUCT_STEP__(BackedUpWindow)