diff -r bbf46f59e123 -r 25ffed67c7ef windowing/windowserver/tauto/TPANIC.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/tauto/TPANIC.CPP Wed Sep 01 12:39:21 2010 +0100 @@ -0,0 +1,2014 @@ +// 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 various cases of Wserv panicing client apps +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "TPANIC.H" +#include "../tlib/testbase.h" +#include +#define TEST_BITMAP _L("Z:\\WSTEST\\WSAUTOTEST.MBM") + +class RWsSessionHacker : public RWsSession + { +public: + inline RWsBuffer *WsBuffer() const {return(iBuffer);}; + inline TInt PanicItSendReceive(TInt aFunction,const TIpcArgs& aArgs) const {return SendReceive(aFunction,aArgs);}; + inline TInt PanicItSend(TInt aFunction,const TIpcArgs& aArgs) const {return Send(aFunction,aArgs);}; + inline TInt PanicItSendReceive(TInt aFunction) const {return SendReceive(aFunction);}; + inline TInt PanicItSend(TInt aFunction) const {return Send(aFunction);}; + }; + +class RWsBufferHacker // copy of original data structure to access buffer data + { +public: + RWsSession* iSession; + CWsGraphic::CManager* iManager; + TBool iAutoFlush; + TPtr8 iBuf; + RWsBuffer* iNext; + TInt iPreviousHandle; + TInt iBufSize; + TInt iMaxBufSize; + TInt iDirectAcessCount; + RArray iBitmapArray; + TBool iInvalidBitmapArray; + }; + +CTPanic::CTPanic(CTestStep* aStep): + CTWsGraphicsBase(aStep) + { + } + +CTPanic::~CTPanic() + { + } + +LOCAL_C TInt DoDeletedParentTest(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // point to correct screen + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + switch(aInt) + { + case 1: + RWindow win1(ws); + User::LeaveIfError(win1.Construct(group,1)); + RWindow win2(ws); + User::LeaveIfError(win2.Construct(win1,2)); + win1.Close(); + win2.SetExtent(TPoint(1,2),TSize(3,4)); + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +LOCAL_C void ReuseWindow(RWsSession& aWs,RWindowGroup& aGroup,RWindow aCopyWin,RWindow* aPtrWin) + { + aPtrWin->Close(); + RWindow win(aWs); + User::LeaveIfError(win.Construct(aGroup,17)); + aCopyWin.SetExtent(TPoint(1,2),TSize(3,4)); + } + +LOCAL_C void ReuseGroupWindow(RWsSession& aWs,RWindowGroup aCopyWin,RWindowGroup* aPtrWin) + { + aPtrWin->Close(); + RWindowGroup group(aWs); + User::LeaveIfError(group.Construct(889)); + group.EnableReceiptOfFocus(EFalse); + aCopyWin.EnableReceiptOfFocus(EFalse); + } + +LOCAL_C void ReuseSprite(RWsSession& aWs,RWindow& aWin,RWsSprite aCopySprite,RWsSprite* aPtrSprite) + { + aPtrSprite->Close(); + RWsSprite sprite(aWs); + sprite.Construct(aWin,TPoint(0,0),0); + aCopySprite.SetPosition(TPoint(22,22)); + } + +LOCAL_C void ReusePointerCursor(RWsSession& aWs,RWsPointerCursor aCopyCursor,RWsPointerCursor* aPtrCursor) + { + aPtrCursor->Close(); + RWsPointerCursor cursor(aWs); + cursor.Construct(0); + aCopyCursor.Activate(); + } + +LOCAL_C TInt DoHandleReUse(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + CWsScreenDevice *scrdev=new(ELeave) CWsScreenDevice(ws); + scrdev->Construct((TInt)aScreenNumber); + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + RWindow win(ws); + User::LeaveIfError(win.Construct(group,1)); + switch(aInt) + { + case 2: //WS_HANDLE_WINDOW + ReuseWindow(ws,group,win,&win); + break; + case 3: //WS_HANDLE_GROUP_WINDOW + ReuseGroupWindow(ws,group,&group); + break; + case 4: //WS_HANDLE_SPRITE + { + RWsSprite sprite(ws); + sprite.Construct(win,TPoint(0,0),0); + ReuseSprite(ws,win,sprite,&sprite); + } + break; + case 5: //WS_HANDLE_POINTER_CURSOR + { + RWsPointerCursor cursor(ws); + cursor.Construct(0); + ReusePointerCursor(ws,cursor,&cursor); + } + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoScreenDevicePanicTest(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + + CWsScreenDevice *scrdev=new(ELeave) CWsScreenDevice(ws); + User::LeaveIfError(scrdev->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + RWindow win(ws); + User::LeaveIfError(win.Construct(group, 1)); + win.Activate(); + CFbsBitmap *bitmap=new(ELeave) CFbsBitmap; + switch(aInt) + { + case 1: + scrdev->CopyScreenToBitmap(bitmap); + break; + case 2: + scrdev->CopyScreenToBitmap(bitmap,TRect(0,0,10,10)); + break; + default: + return(EWsExitReasonFinished); + } + ws.Flush(); + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoOpcodeTests(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + + CWsScreenDevice *scrdev=new(ELeave) CWsScreenDevice(ws); + User::LeaveIfError(scrdev->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + RWindow win(ws); + User::LeaveIfError(win.Construct(group, 1)); + win.Activate(); + CWindowGc *gc; + scrdev->CreateContext(gc); + switch(aInt) + { + case 1: + ws.TestWrite(ws.WsHandle(),9999,NULL,0); + break; + case 2: + gc->Activate(win); + win.BeginRedraw(); + ws.TestWrite(gc->WsHandle(),9999,NULL,0); + /* This only panics if the command is processed immediately. If it goes into the redraw + store then it will be unable to panic the client untill an additional buffer has been received, + hence the double flush. + */ + win.EndRedraw(); + ws.Finish(); + win.BeginRedraw(); + win.EndRedraw(); + break; + case 3: + ws.TestWrite(scrdev->WsHandle(),9999,NULL,0); + break; + case 4: + { + CWsBitmap *bitmap=new(ELeave) CWsBitmap(ws); + bitmap->Create(TSize(10,10),EGray4); + ws.TestWrite(bitmap->WsHandle(),9999,NULL,0); + } + break; + case 5: + ws.TestWrite(win.WsHandle(),9999,NULL,0); + break; + case 6: + ws.TestWrite(group.WsHandle(),9999,NULL,0); + break; + case 7: + { + RWsSprite sprite(ws); + sprite.Construct(win,TPoint(0,0),0); + ws.TestWrite(sprite.WsHandle(),9999,NULL,0); + } + break; + default: + return(EWsExitReasonFinished); + } + ws.Flush(); + return(EWsExitReasonBad); + } + +TInt DoGraphicsPanicTest(RWsSession& aWs, RWindow& aRWin, RDrawableWindow* aDrawWin, CWindowGc* aGc, CFbsFont* aFont, TInt aTest, TInt aSubTest, TBool aInRedraw, TBool aNeedsValidating) + { + if (aInRedraw || aNeedsValidating) + { + aRWin.BeginRedraw(); + if (!aInRedraw) + { // TransWin without redraw active needs the begin/end to make the redraw store active + aRWin.EndRedraw(); // or else all graphics will simply be ignored and no panics will occur + } + } + aWs.Flush(); + TRect rect01(0,0,1,1); + TPoint point00; + switch(aTest) + { + case 1: + aGc->UseFont(aFont); + switch(aSubTest) + { + case 0: + { + TWsGcCmdBoxText boxText(rect01,0,CGraphicsContext::ELeft,0,0x800000,1); + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawBoxText,&boxText,sizeof(boxText)); + } + break; + case 1: + { + TWsGcCmdDrawText dt(point00,600); + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawText,&dt,sizeof(dt)); + } + break; + case 2: + { + TWsGcCmdBoxTextOptimised1 dt(rect01,0,600); + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawBoxTextOptimised1,&dt,sizeof(dt)); + } + break; + case 3: + { + TWsGcCmdDrawTextVertical dt(point00,600,EFalse); + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawTextVertical,&dt,sizeof(dt)); + } + break; + case 4: + { + TWsGcCmdBoxTextVertical dt(rect01); + dt.length=600; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawBoxTextVertical,&dt,sizeof(dt)); + } + break; + case 5: + return(EWsExitReasonFinished); + } + break; + case 2: + { + TInt opcode=0; + switch(aSubTest) + { + case 0: + opcode=EWsGcOpGdiBlt2; + break; + case 1: + opcode=EWsGcOpGdiWsBlt2; + break; + case 2: + return(EWsExitReasonFinished); + } + TWsGcCmdGdiBlt2 gdiBlit(point00,0xBADBAD); + aWs.TestWrite(aGc->WsHandle(),opcode,&gdiBlit,sizeof(gdiBlit)); + if (aInRedraw) + { // Adding two bad bitmaps to redraw store fbs store causes leave as NULL handles of failed bitmaps clash + gdiBlit.handle=0xBADBAD2; + aWs.TestWrite(aGc->WsHandle(),opcode,&gdiBlit,sizeof(gdiBlit)); + } + } + break; + case 3: + { + const TInt KNumBadBmpModes=3; + const TInt KNumTestsPerOpcode=KNumBadBmpModes*2; + enum {KPanicIndexMasked,KPanicIndexDraw,KPanicIndexAlphaBlend,KPanicIndexMax}; + TInt opcodeMode=aSubTest/KNumTestsPerOpcode; + TInt bmpMode=aSubTest%KNumTestsPerOpcode; + TInt bmp1=0xBADBAD; + TInt bmp2=0xBADBAD; + TInt goodBmp; + TInt opcodeBlt; + TInt opcodeDraw; + if (bmpModeCreate(TSize(10,10),EGray4); + goodBmp=goodBitmap->Handle(); + opcodeBlt=EWsGcOpGdiBltMasked; + opcodeDraw=EWsGcOpDrawBitmapMasked; + } + else + { // These two use a CWsBitmap + CWsBitmap* goodBitmap=new(ELeave) CWsBitmap(aWs); + goodBitmap->Create(TSize(10,10),EGray4); + goodBmp=goodBitmap->WsHandle(); + opcodeBlt=EWsGcOpGdiWsBltMasked; + opcodeDraw=EWsGcOpWsDrawBitmapMasked; + } + switch(bmpMode%KNumBadBmpModes) + { + case 0: + bmp2=goodBmp; + break; + case 1: + bmp1=goodBmp; + break; + case 2: // Leave them both bad + break; + } + switch(opcodeMode) + { + case KPanicIndexMasked: + { + TWsGcCmdBltMasked gdiBlitMasked(point00,bmp1,rect01,bmp2,EFalse); + aWs.TestWrite(aGc->WsHandle(),opcodeBlt,&gdiBlitMasked,sizeof(gdiBlitMasked)); + } + break; + case KPanicIndexDraw: + { + TWsGcCmdDrawBitmapMasked maskedBitmap(rect01,bmp1,rect01,bmp2,EFalse); + aWs.TestWrite(aGc->WsHandle(),opcodeDraw,&maskedBitmap,sizeof(maskedBitmap)); + } + break; + case KPanicIndexAlphaBlend: + { + TWsGcCmdAlphaBlendBitmaps alphaBlend(point00,bmp1,rect01,bmp2,point00); + aWs.TestWrite(aGc->WsHandle(),EWsGcOpGdiAlphaBlendBitmaps,&alphaBlend,sizeof(alphaBlend)); + } + break; + case KPanicIndexMax: + return(EWsExitReasonFinished); + } + } + break; + case 4: + switch(aSubTest) + { + case 0: + { + TWsClCmdCreateBitmap createBitmap; + createBitmap.handle=0xB0D; + aWs.TestWrite(aWs.WsHandle(),EWsClOpCreateBitmap,&createBitmap,sizeof(createBitmap)); + } + break; + case 1: + { + TInt badBrush=0xBADB3054; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpUseBrushPattern,&badBrush,sizeof(badBrush)); + } + break; + case 2: + { + TWsGcCmdDrawBitmap drawBitmap(point00,0xBADBAD); + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawBitmap,&drawBitmap,sizeof(drawBitmap)); + } + break; + case 3: + return(EWsExitReasonFinished); + } + break; + case 5: + // test bad opcodes + { + TInt opcode=0; + switch(aSubTest) + { + case 0: + opcode=9999; + break; + case 1: + return(EWsExitReasonFinished); + } + aWs.TestWrite(aGc->WsHandle(),opcode,NULL,0); + } + break; + case 6: + {// Test EWsGcOpDrawPolygon with invalid parameters + // First two times has slightly more points specified than exist in the data + // Third time time has a massive number of points in the header + const TInt KNumTestsPerPolyMode=3; + enum TPanicPolyMode {EPanicPolyModePolygon,EPanicPolyModePolyLine,EPanicPolyModeEnd}; + TInt polyMode=aSubTest/KNumTestsPerPolyMode; + if (polyMode==EPanicPolyModeEnd) + return(EWsExitReasonFinished); + TInt subMode=aSubTest%KNumTestsPerPolyMode; + TInt bufPoints=0; + TInt headerPoints=1; + switch(subMode) + { + case 0: + break; + case 1: + bufPoints=2; + headerPoints=8; + break; + case 2: + bufPoints=2; + headerPoints=999999; + break; + } + TInt bufDataLen=bufPoints*sizeof(TPoint); + if (polyMode==EPanicPolyModePolyLine) + bufDataLen+=sizeof(TWsGcCmdDrawPolyLine); + else + bufDataLen+=sizeof(TWsGcCmdDrawPolygon); + TAny* bufData=User::AllocL(bufDataLen); + TPoint* pointPtr; + TInt opcode; + if (polyMode==EPanicPolyModePolyLine) + { + TWsGcCmdDrawPolyLine* drawPolyline=static_cast(bufData); + drawPolyline->numPoints=headerPoints; + drawPolyline->more=EFalse; + drawPolyline->last=point00; + pointPtr=reinterpret_cast(drawPolyline+1); + opcode=EWsGcOpDrawPolyLine; + } + else + { + TWsGcCmdDrawPolygon* drawPolygon=static_cast(bufData); + drawPolygon->numPoints=headerPoints; + drawPolygon->fillRule=CGraphicsContext::EAlternate; + pointPtr=reinterpret_cast(drawPolygon+1); + opcode=EWsGcOpDrawPolygon; + } + const TPoint* endPtr=pointPtr+bufPoints; + TInt pointPos=0; + while(pointPtrWsHandle(),opcode,bufData,bufDataLen); + aWs.Flush(); // Needs flush to make sure EndRedraw() doesn't make buffer bigger and catch out buf len check + } + break; + case 7: + { + // first sets the index to match the total count + // second sets the index negative + // fourth sends too much data + TWsGcCmdStartSegmentedDrawPolygon startPoly; + startPoly.totalNumPoints=8; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpStartSegmentedDrawPolygon,&startPoly,sizeof(startPoly)); + TInt bufDataLen=sizeof(TWsGcCmdSegmentedDrawPolygonData)+startPoly.totalNumPoints*sizeof(TPoint); + TAny* bufData=User::AllocL(bufDataLen); + TWsGcCmdSegmentedDrawPolygonData* polyData=static_cast(bufData); + polyData->numPoints=1; + polyData->index=0; + switch(aSubTest) + { + case 0: + polyData->index=startPoly.totalNumPoints; + break; + case 1: + polyData->index=-123; + break; + case 2: + polyData->numPoints=startPoly.totalNumPoints+1; + break; + case 3: + return(EWsExitReasonFinished); + } + aWs.TestWrite(aGc->WsHandle(),EWsGcOpSegmentedDrawPolygonData,polyData,bufDataLen); + TWsGcCmdDrawSegmentedPolygon drawit; + drawit.fillRule=CGraphicsContext::EAlternate; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawSegmentedPolygon,&drawit,sizeof(drawit)); + } + break; + case 8: + { + if (aSubTest==1) + return(EWsExitReasonFinished); + // This is a test designed to specificially test polylines still work after the previous + // polyline/polygon tests. One potential defect is they leave the common redraw store gc + // in a bad state still holding part of the poly data and causing a EWservPanicBadPolyData + // panic. + // This test is designed to make sure the drawpolyline call works ok and we reach the bad + // opcode panic instead. + TWsGcCmdStartSegmentedDrawPolygon startPoly; + startPoly.totalNumPoints=2; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpStartSegmentedDrawPolygon,&startPoly,sizeof(startPoly)); + struct + { + TWsGcCmdSegmentedDrawPolygonData iPolyData; + TPoint iPoints[2]; + } polyParams; + polyParams.iPoints[0].iX=1; + polyParams.iPoints[0].iY=1; + polyParams.iPoints[1].iX=2; + polyParams.iPoints[1].iY=2; + + polyParams.iPolyData.numPoints=2; + polyParams.iPolyData.index=0; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpSegmentedDrawPolygonData,&polyParams.iPolyData,sizeof(polyParams)); + TWsGcCmdDrawSegmentedPolygon drawit; + drawit.fillRule=CGraphicsContext::EAlternate; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpDrawSegmentedPolygon,&drawit,sizeof(drawit)); + aWs.TestWrite(aGc->WsHandle(),9999,NULL,0); + } + break; + case 9: + if (aSubTest==1) + return(EWsExitReasonFinished); + aGc->Activate(*aDrawWin); // Double activate + break; + case 10: + if (aSubTest==1) + return(EWsExitReasonFinished); + aGc->DrawText(_L("No font"),point00); + break; + case 11: + if (aSubTest==1) + return(EWsExitReasonFinished); + aGc->SetBrushStyle(CGraphicsContext::EPatternedBrush); + aGc->DrawRect(rect01); + break; + case 12: + { + if (aSubTest==1) + return(EWsExitReasonFinished); + aGc->UseFont(aFont); + TPtrC bigAndbad(NULL,5000); // Will go through remote descriptor fetching code + aGc->DrawText(bigAndbad,point00); + } + break; + case 13: + { + if (aSubTest==1) + return(EWsExitReasonFinished); + TInt badHandle=0xDEADBAD; + aWs.TestWrite(aGc->WsHandle(),EWsGcOpUseFont,&badHandle,sizeof(badHandle)); + aGc->DrawText(_L("BOO!"),point00); + } + break; + } + if (aInRedraw) + aRWin.EndRedraw(); + aWs.Finish(); + return(EWsExitReasonBad); + } + +LOCAL_C TInt GraphicsPanicTest(TInt aInt, TAny* aPanicParams) + { + CTPanic::TPanicParams* panicParams=static_cast(aPanicParams); + /* + * Drawing to a transparent window goes via the redraw store. In this + * situation parameters do not get checked during the original processing + * of the incoming graphics commands. They are only caught later when + * playing back from the redraw store. + */ + const TBool useTransWin = panicParams->iRedrawMode==EPanicRedrawModeTransRedraw; + /* + * We always do redraw drawing unless we are using a BackedUpWindow. + * Redraws can affect the way graphics commands are pre-processed, + * as with transparent windows they can also cause commands to get + * buffered in the redraw store and played back later. + */ + const TBool inRedraw = + panicParams->iRedrawMode==EPanicRedrawModeNormalRedraw || + panicParams->iRedrawMode==EPanicRedrawModeTransRedraw || + panicParams->iRedrawMode==EPanicRedrawModeInvisRedraw; + /* + * Drawing to an invisible window skips some of the code where errors + * are caught. Particularly text drawing commands that skip the actual + * drawing, but still process the update of the justification, this + * has the potential of missing parameter checks made during the actual + * drawing, but being caught out when processing the justification update. + */ + const TBool invisWin = panicParams->iRedrawMode==EPanicRedrawModeInvisRedraw; + + RWsSession ws; + User::LeaveIfError(ws.Connect()); + + CWsScreenDevice* scrdev=new(ELeave) CWsScreenDevice(ws); + User::LeaveIfError(scrdev->Construct(panicParams->iScreen)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + RDrawableWindow* drawWin; + RWindow rwin(ws); + RBackedUpWindow bwin(ws); + TBool needsValidating=EFalse; + if (useTransWin || inRedraw || invisWin) + { + drawWin=&rwin; + needsValidating=ETrue; + User::LeaveIfError(rwin.Construct(group,1)); + if (useTransWin) + { + rwin.SetTransparencyAlphaChannel(); + } + } + else + { + // EPanicRedrawModeBackedUpWindow case + drawWin=&bwin; + User::LeaveIfError(bwin.Construct(group, EGray4, 1)); + } + const TSize testWinSize(100,100); + User::LeaveIfError(drawWin->SetSizeErr(testWinSize)); + if (invisWin) + drawWin->SetPosition(TPoint(-testWinSize.iWidth,-testWinSize.iHeight)); + drawWin->Activate(); + CWindowGc* gc; + scrdev->CreateContext(gc); + gc->Activate(*drawWin); + CFbsFont* font; + User::LeaveIfError(scrdev->GetNearestFontToDesignHeightInTwips((CFont*&)font,TFontSpec())); + TInt ret=DoGraphicsPanicTest(ws,rwin,drawWin,gc,font,aInt,panicParams->iSubTest,inRedraw,needsValidating); + if (ret!=EWsExitReasonFinished && invisWin) + { + /* + * Some functions are totally skipped on invisible windows, parameter + * errors will be harmlessly ignored in these case. To make the test + * pass we re-do the tests with the window now visible. The purpose + * of the invisible draw tests was not to check the client is always + * panicked doing illegal draws to invisible windows, but to make sure + * they had no harmful side effects. + */ + drawWin->SetPosition(TPoint(0,0)); + gc->Reset(); + ret=DoGraphicsPanicTest(ws,rwin,drawWin,gc,font,aInt,panicParams->iSubTest,inRedraw,needsValidating); + } + return(ret); + } +LOCAL_C TInt DoMiscPanicTest(TInt aSubTest, TAny* ) + { + const TInt KNumPanicFuncsPerMode=EWsClOpLastEnumValue; + const TInt KNumPanicFuncModes=6; + const TInt KNumPanicSendTests=KNumPanicFuncsPerMode*KNumPanicFuncModes; + const TInt KNumRandGarbageTests=500; + if (aSubTest==(KNumPanicSendTests+KNumRandGarbageTests)) + return(EWsExitReasonFinished); + RWsSessionHacker wshacker; + User::LeaveIfError(wshacker.Connect()); + if (aSubTest(0xDEAD),100); + TIpcArgs ipcArgs; + ipcArgs.Set(0,&badDesc); + if (msgFunc&EPanicWservMessAsynchronousService) + { + sendItErr=wshacker.PanicItSend(msgFunc,ipcArgs); + msgFunc&=~EPanicWservMessAsynchronousService; + } + sendItErr=wshacker.PanicItSendReceive(msgFunc,ipcArgs); + } + if (sendItErr==KErrNotSupported) + wshacker.PanicItSendReceive(EWservMessCommandBuffer); // Should always panic + } + else + { + // Fill Wserv buffer with random garbage + RWsBufferHacker* hacker=reinterpret_cast(wshacker.WsBuffer()); + TInt64 seed=aSubTest; + TInt retries=0; + const TInt KMaxRandPanicRetrys=1000; + do + { + const TInt maxLen=hacker->iBuf.MaxLength()-1; + TInt writeLen=1+Math::Rand(seed)%maxLen; + while(writeLen--) + { + TUint8 randData=static_cast(Math::Rand(seed)); + hacker->iBuf.Append(randData); + } + wshacker.Flush(); + retries++; + } while(retriesConstruct((TInt)aScreenNumber)); + + switch(aInt) + { + case 1: + ws.ComputeMode((RWsSession::TComputeMode)543); + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +#if defined(_DEBUG) && defined(__WINS__) +LOCAL_C TInt DoCKPanicTest(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // use correct screen + // + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + group.Construct(888); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + switch(aInt) + { + case 1: + group.CancelCaptureKey(345); + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } +#endif + +LOCAL_C TInt DoEventPanicTest(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // use correct screen + // + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + + switch(aInt) + { + case 1: + TRequestStatus stat; + ws.EventReady(&stat); + ws.EventReady(&stat); + User::After(15000000); //15secs + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoTBufPtrTests(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // use correct screen + // + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + switch(aInt) + { + case 1: + { + TWsClCmdLoadAnimDll dt; + dt.length=600; + ws.TestWrite(ws.WsHandle(),EWsClOpCreateAnimDll,&dt,sizeof(dt)); + } + break; + case 2: + { + TInt len=600; + ws.TestWrite(ws.WsHandle(),EWsClOpLogMessage,&len,sizeof(len)); + } + break; + case 3: + { + RWindowGroup group(ws); + group.Construct(888); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + TWsWinCmdSetName dt; + dt.length=600; + dt.ptr=NULL; + ws.TestWrite(group.WsHandle(),EWsWinOpSetName,&dt,sizeof(dt)); + } + break; + case 4: + { + RWindowGroup group(ws); + group.Construct(888); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + TWsWinCmdSetName dt; + dt.length=600; + dt.ptr=(TDesC *)0x1234; + ws.TestWrite(group.WsHandle(),EWsWinOpSetName,&dt,sizeof(dt)); + } + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +#if defined(_DEBUG) && defined(__WINS__) +LOCAL_C TInt DoMismatchedCancelCaptureTest(TInt aInt, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // use correct screen + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + RWindow win(ws); + User::LeaveIfError(win.Construct(group, 1)); + win.Activate(); + TInt capture; + + switch (aInt) + { + case CTPanic::ECancelCaptureKey: + // Create a capture that is not matched to CancelCaptureKey() + capture = group.CaptureLongKey(' ','a',0,0,2,ELongCaptureNormal); + ws.Flush(); + group.CancelCaptureKey(capture); + break; + case CTPanic::ECancelCaptureKeyUpAndDowns: + // Create a capture that is not matched to CancelCaptureKeyUpAndDowns() + capture = group.CaptureKey('A',0,0); + ws.Flush(); + group.CancelCaptureKeyUpAndDowns(capture); + break; + case CTPanic::ECancelCaptureLongKey: + // Create a capture that is not matched to CancelCaptureLongKey() + capture = group.CaptureKeyUpAndDowns(EStdKeySpace,0,0); + ws.Flush(); + group.CancelCaptureLongKey(capture); + break; + } + + ws.Flush(); + return(EWsExitReasonBad); + } +#endif // _DEBUG + +class ROverrideProtectionInRSessionBase : public RWsSession + { +public: + inline TInt SendReceive(TInt aFunction,TAny *aPtr) const {return(RSessionBase::SendReceive(aFunction,TIpcArgs(aPtr)));}; + }; + +LOCAL_C TInt DoMultiInitPanicTest(TInt , TAny *aScreenNumber) + { + ROverrideProtectionInRSessionBase ws; + User::LeaveIfError(ws.Connect()); + + // use correct screen + // + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + group.Construct(888); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + ws.Flush(); + ws.SendReceive(EWservMessInit,NULL); + + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoSpritePanicTestL(TInt aTest, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // use correct screen + // + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(889)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + RBlankWindow win(ws); + User::LeaveIfError(win.Construct(group,898)); + RWsPointerCursor* cursor=(RWsPointerCursor*)&win; + switch (aTest) + { + case 1: + win.SetCustomPointerCursor(*cursor); + break; + case 2: + ws.SetSystemPointerCursor(*cursor,0); + break; + case 3: + { + RAnimDll animDll=RAnimDll(ws); + User::LeaveIfError(animDll.Load(KAnimDLLName)); + RTestAnim anim=RTestAnim(animDll); + RWsSprite* sprite=(RWsSprite*)&win; + User::LeaveIfError(anim.Construct(*sprite,EAnimTypeSprite,TPtrC8())); + } + break; + case 4: + { + CFbsBitmap* bitmap=new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME,0)); + win.SetExtent(TPoint(),TSize(150,250)); + win.SetVisible(ETrue); + win.Activate(); + RWsSprite sprite(ws); + User::LeaveIfError(sprite.Construct(win,TPoint(),0)); + TSpriteMember member; + member.iMaskBitmap=NULL; + member.iInvertMask=EFalse; + member.iDrawMode=CGraphicsContext::EDrawModePEN; + member.iOffset=TPoint(); + member.iInterval=TTimeIntervalMicroSeconds32(0); + member.iBitmap=bitmap; + User::LeaveIfError(sprite.AppendMember(member)); + User::LeaveIfError(sprite.Activate()); + User::After(1000000); //1 sec + User::LeaveIfError(bitmap->Resize(bitmap->SizeInPixels() + TSize(200,200))); + User::After(1000000); //1 sec + CleanupStack::Pop(bitmap); + break; + } + } + ws.Flush(); + return(EWsExitReasonBad); + } + +#ifdef __WINS__ +LOCAL_C TInt DoDoubleConstructionTestL(TInt aTest, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + + // use correct screen + // + CWsScreenDevice* screen = new(ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(890, EFalse)); + RBlankWindow bwin(ws); + User::LeaveIfError(bwin.Construct(group,900)); + + switch (aTest) + { + case 1: + { + RWsSprite sprite = RWsSprite(ws); + User::LeaveIfError(sprite.Construct(bwin,TPoint(),0)); + sprite.Construct(bwin,TPoint(),0); //should panic + sprite.Close(); + } + break; + case 2: + { + RWsPointerCursor cursor(ws); + User::LeaveIfError(cursor.Construct(0)); + cursor.Construct(0); //should panic + cursor.Close(); + } + break; + case 3: + { + RSoundPlugIn click(ws); + User::LeaveIfError(click.Construct()); + click.Construct(); //should panic + click.Close(); + } + break; + case 4: + { + RWindowGroup windowgroup(ws); + User::LeaveIfError(windowgroup.Construct(901)); + windowgroup.Construct(902); //should panic + windowgroup.Close(); + } + break; + case 5: + { + RWindow win(ws); + User::LeaveIfError(win.Construct(group,902)); + win.Construct(group,903); //should panic + win.Close(); + } + break; + case 6: + { + RBlankWindow win(ws); + User::LeaveIfError(win.Construct(group,902)); + win.Construct(group,903); //should panic + win.Close(); + } + break; + case 7: + { + RBackedUpWindow win(ws); + User::LeaveIfError(win.Construct(group,EGray4,902)); + win.Construct(group,EGray4,903); //should panic + win.Close(); + } + break; + case 8: + { + RAnimDll animDll=RAnimDll(ws); + User::LeaveIfError(animDll.Load(KAnimDLLName)); + animDll.Load(KAnimDLLName); //should panic + animDll.Close(); + } + break; + case 9: + { + CWindowGc *gc = new(ELeave) CWindowGc(screen); + User::LeaveIfError(gc->Construct()); + gc->Construct(); //should panic + delete gc; + } + break; + case 10: + { + CWsScreenDevice* screendevice = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screendevice->Construct()); + screendevice->Construct(); //should panic + delete screendevice; + } + break; + default: + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } +#endif + +/** Checks that activating a sprite without members will panic. +*/ +LOCAL_C TInt DoTestSpriteActivatePanicL(TInt aTest, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + CWsScreenDevice* screen = new(ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(891, EFalse, screen)); + RBlankWindow bwin(ws); + User::LeaveIfError(bwin.Construct(group,892)); + + switch(aTest) + { + case 1: + { + RWsSprite sprite = RWsSprite(ws); + User::LeaveIfError(sprite.Construct(group,TPoint(),0)); + sprite.Activate(); //should panic here + sprite.Close(); + } + break; + case 2: + { + RWsSprite sprite = RWsSprite(ws); + User::LeaveIfError(sprite.Construct(bwin,TPoint(),0)); + sprite.Activate(); //should panic here + sprite.Close(); + } + break; + } + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoMoveToGroupPanicTestL(TInt aTest, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // use correct screen + // + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(887)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + TInt id=group.Identifier(); + switch (aTest) + { + case 1: + { + RWindowTreeNode* win=&group; + ((RWindowBase*)win)->MoveToGroup(id); + } + break; + case 2: + { + RBlankWindow win1(ws); + User::LeaveIfError(win1.Construct(group,878)); + RBlankWindow win2(ws); + User::LeaveIfError(win2.Construct(win1,788)); + win2.MoveToGroup(id); + } + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoGetEventPanicTestL(TInt aTest, TAny *aScreenNumber) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + switch(aTest) + { + case 1: + { + TPckgBuf event; + ws.TestWrite(ws.WsHandle(),EWsClOpGetEvent,&event,0); + } + break; + case 2: + { + CWsScreenDevice* screen=new(ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(555)); // trigger a focus changed event + TRequestStatus stat; + ws.EventReady(&stat); + User::WaitForRequest(stat); + TPtrC8 badDesc(reinterpret_cast(0xDEAD),100); + ws.TestWrite(ws.WsHandle(),EWsClOpGetEvent,&badDesc,0); + } + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +LOCAL_C TInt DoWinHandlePanicTestL(TInt aTest, TAny *) + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + RWindowGroup group1(ws); + RWindowGroup group2(ws); + RWindow win1(ws); + RWindow win2(ws); + switch(aTest) + { + case 1: + User::LeaveIfError(group1.Construct(888)); + User::LeaveIfError(group2.Construct(888)); + break; + case 2: + User::LeaveIfError(group1.Construct(777)); + User::LeaveIfError(win1.Construct(group1,888)); + User::LeaveIfError(win2.Construct(group1,888)); + break; + case 3: + User::LeaveIfError(group1.Construct(777)); + User::LeaveIfError(win1.Construct(group1,777)); + break; + case 4: + User::LeaveIfError(group1.Construct(777)); + User::LeaveIfError(win1.Construct(group1,0)); + break; + } + ws.Flush(); + return(EWsExitReasonBad); + } + +#ifdef __WINS__ +LOCAL_C TInt DoDeleteScreenPanicTestL(TInt aTest, TAny *aScreenNumber) +/** + * Test examples of use of the 'screen device deleted' panic for group windows. + * This is issued to panic the client, if they make API calls to RWindowGroup after having deleted + * the CWsScreenDevice with which that window group is associated. + */ + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + // point to correct screen + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); + User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(888)); + group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close + switch(aTest) + { + // Test 1: deleting screen then modifying screen change events is illegal + case 1: + { + delete screen, screen=NULL; + group.EnableScreenChangeEvents(); + break; + } + // Test 2: deleting screen then setting window group name is illegal + case 2: + { + delete screen, screen=NULL; + _LIT(KPanicTest, "PanicTest"); + group.SetName(KPanicTest); + break; + } + } + ws.Flush(); + return(EWsExitReasonBad); + } +#endif + +LOCAL_C TInt DoUnInitPanicTest(TInt , TAny *) + { + // Creating a client session outside the test harness for panicking + // before initialisation as the test harness initialises the one it creates. + TVersion version(0,0,0); + _LIT(KServerName, "!Windowserver"); + + RUnInitalisedConnect myUnInit; + + User::LeaveIfError(myUnInit.Connect(KServerName(), version)); + myUnInit.Send(EWservMessCommandBuffer); + + return(EWsExitReasonBad); + } + +void CTPanic::TestScreenDevicePanicsL() + { + TEST(iTest->TestWsPanicL(&DoScreenDevicePanicTest,EWservPanicBitmap,1,(TAny*)iTest->iScreenNumber)); + + TEST(iTest->TestWsPanicL(&DoScreenDevicePanicTest,EWservPanicBitmap,2,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestMiscPanicsL() + { + TBool finished=EFalse; + TInt index=0; + while(!finished) + { + const TBool result = iTest->TestWsPanicL(&DoMiscPanicTest, EWservNoPanic, index, NULL, &finished); + if(!result) + { + INFO_PRINTF2(_L("TestMiscPanicsL %d failed"), index); + TEST(result); + } + index++; + } + } + +void CTPanic::LogHeapInfo() + { + _LIT(KInfoHeapSummary," WsHeap - Count=%d,Total=%d,Free=%d,Max free=%d"); + TPckgBuf heapInfo; + TheClient->iWs.DebugInfo(EWsDebugInfoHeap,heapInfo); + TBuf<256> infoBuf; + infoBuf.Format(KInfoHeapSummary,heapInfo().iCount,heapInfo().iTotal,heapInfo().iAvailable,heapInfo().iLargestAvailable); + INFO_PRINTF1(infoBuf); + } + +void CTPanic::TestGraphicsPanicsL(TClientPanic aExitReason, TInt aIndex, CTPanic::TPanicParams* aPanicParams) + { + TBool finished=EFalse; + aPanicParams->iSubTest=0; + + // uncomment to show which test is being run + INFO_PRINTF3(_L("GraphicsPanicTest %d, mode=%d"),aIndex,aPanicParams->iRedrawMode); + RDebug::Print(_L("GraphicsPanicTest %d, mode=%d"),aIndex,aPanicParams->iRedrawMode); + do + { + // uncomment for detailed view of which sub-test failed + LogHeapInfo(); + INFO_PRINTF4(_L("GraphicsPanicTest %d/%d, mode=%d"),aIndex,aPanicParams->iSubTest,aPanicParams->iRedrawMode); + RDebug::Print(_L("GraphicsPanicTest %d/%d, mode=%d"),aIndex,aPanicParams->iSubTest,aPanicParams->iRedrawMode); + TEST(iTest->TestWsPanicL(&GraphicsPanicTest,aExitReason,aIndex,aPanicParams,&finished)); + aPanicParams->iSubTest++; + } while(!finished); + iTest->CloseAllPanicWindows(); + } + +void CTPanic::TestGraphicsPanicsL(TPanicRedrawMode aRedrawMode) + { + CTPanic::TPanicParams pp; + pp.iScreen=iTest->iScreenNumber; + pp.iRedrawMode=aRedrawMode; + static TClientPanic expectedPanics[]= + { + EWservPanicBufferPtr, + EWservPanicBitmap, + EWservPanicBitmap, + EWservPanicBitmap, + EWservPanicOpcode, + EWservPanicBadPolyData, + EWservPanicBadPolyData, + EWservPanicOpcode, + EWservPanicGcActive, + EWservPanicNoFont, + EWservPanicNoBrush, + EWservPanicDescriptor, + EWservPanicFont, + EWservNoPanic, // Marks the end of the list + }; + TInt panicIndex=0; + TClientPanic expectedPanic; + while((expectedPanic=expectedPanics[panicIndex++])!=EWservNoPanic) + { + TestGraphicsPanicsL(expectedPanic,panicIndex,&pp); + } + } + +void CTPanic::TestGraphicsPanicsL() + { + TestGraphicsPanicsL(EPanicRedrawModeBackedUpWindow); + TestGraphicsPanicsL(EPanicRedrawModeNormalRedraw); + if (TransparencySupportedL()==KErrNone) + { + TestGraphicsPanicsL(EPanicRedrawModeTransRedraw); + } + TestGraphicsPanicsL(EPanicRedrawModeInvisRedraw); + } + +void CTPanic::TestDeletedParentPanicsL() + { + TEST(iTest->TestWsPanicL(&DoDeletedParentTest,EWservPanicParentDeleted,1,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestHandleReUseL() + { + for (TInt ii=2;ii<6;++ii) + { + TEST(iTest->TestWsPanicL(&DoHandleReUse,EWservPanicHandle,ii,(TAny*)iTest->iScreenNumber)); + } + } + +void CTPanic::TestComputeModePanicsL() + { + TEST(iTest->TestWsPanicL(&DoCMPanicTest,EWservPanicSetComputeMode,1,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestCaptureKeyPanicsL() + { +// Run this test in debug on emulator only. +// On a debug ROM the release version of the wserv.exe is included so the test can't be run as no panic happens. +#if defined(_DEBUG) && defined(__WINS__) + TEST(iTest->TestWsPanicL(&DoCKPanicTest,EWservPanicDestroy,1,(TAny*)iTest->iScreenNumber)); +#endif + } + +void CTPanic::TestEventPanicsL() + { + TEST(iTest->TestWsPanicL(&DoEventPanicTest,EWservPanicReadOutstanding,1,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestTPtrPanicsL() + { + TEST(iTest->TestWsPanicL(&DoTBufPtrTests,EWservPanicBufferPtr,1,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestOpcodePanicsL() + { + TInt param=1; + TBool finishTest = EFalse; + while(!finishTest) + { + TEST(iTest->TestWsPanicL(&DoOpcodeTests,EWservPanicOpcode,param,(TAny*)iTest->iScreenNumber,&finishTest)); + param++; + } + } + +void CTPanic::TestMultiInitPanicL() + { + TEST(iTest->TestWsPanicL(&DoMultiInitPanicTest,EWservPanicReInitialise,0,(TAny*)iTest->iScreenNumber)); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0472 + +@SYMDEF DEF118618 + +@SYMTestCaseDesc Test defect fixes to system panics + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that various defect fixes to system panics are correct. + Also verify that reconstructing a closed object will succeed. + +@SYMTestExpectedResults Panics respond correctly +*/ +void CTPanic::TestDoubleConstructionL() + { +#ifdef __WINS__ + for(TInt test=1;test<11;test++) + { + TEST(iTest->TestW32PanicL(&DoDoubleConstructionTestL,EW32PanicGraphicDoubleConstruction,test,NULL)); + } + TestDoubleConstructionNoPanic(); +#endif + } + +/** Verifies the following scenario is valid: + 1. Create some wserv client-side objects. + 2. Call Close on them. + 3. Reconstruct them and they shouldn't panic this time. */ +void CTPanic::TestDoubleConstructionNoPanic() + { + RWsSession ws; + User::LeaveIfError(ws.Connect()); + + RWindowGroup group(ws); + User::LeaveIfError(group.Construct(890, EFalse)); + RBlankWindow bwin(ws); + User::LeaveIfError(bwin.Construct(group,900)); + + //RWsSprite + RWsSprite sprite(ws); + TEST(KErrNone == sprite.Construct(bwin,TPoint(0,0),0)); + sprite.Close(); + TEST(KErrNone == sprite.Construct(bwin,TPoint(0,0),0)); + sprite.Close(); + + //RWsPointerCursor + RWsPointerCursor cursor(ws); + TEST(KErrNone == cursor.Construct(0)); + cursor.Close(); + TEST(KErrNone == cursor.Construct(0)); + cursor.Close(); + + //RSoundPlugIn + RSoundPlugIn click(ws); + TEST(KErrNone == click.Construct()); + click.Close(); + TEST(KErrNone == click.Construct()); + click.Close(); + + //RWindowGroup + RWindowGroup windowgroup(ws); + TEST(KErrNone ==windowgroup.Construct(901)); + windowgroup.Close(); + TEST(KErrNone ==windowgroup.Construct(901)); + windowgroup.Close(); + + //RWindow + RWindow win1(ws); + TEST(KErrNone == win1.Construct(group,902)); + win1.Close(); + TEST(KErrNone == win1.Construct(group,902)); + win1.Close(); + + //RBlankWindow + RBlankWindow win2(ws); + TEST(KErrNone == win2.Construct(group,902)); + win2.Close(); + TEST(KErrNone == win2.Construct(group,902)); + win2.Close(); + + //RBackedUpWindow + RBackedUpWindow win3(ws); + TEST(KErrNone == win3.Construct(group,EGray4,902)); + win3.Close(); + TEST(KErrNone == win3.Construct(group,EGray4,902)); + win3.Close(); + + //RAnimDll + RAnimDll animDll=RAnimDll(ws); + TEST(KErrNone == animDll.Load(KAnimDLLName)); + animDll.Close(); + TEST(KErrNone == animDll.Load(KAnimDLLName)); + animDll.Close(); + + group.Close(); + bwin.Close(); + ws.Close(); + } + +void CTPanic::TestSpritePanicsL() + { + for(TInt test=1;test<4;test++) + { + TEST(iTest->TestWsPanicL(&DoSpritePanicTestL,EWservPanicSprite,test,(TAny*)iTest->iScreenNumber)); + } + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0475 + +@SYMDEF DEF118616 + +@SYMTestCaseDesc Test defect fixes to system panics + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that various defect fixes to system panics are correct. + +@SYMTestExpectedResults Panics respond correctly +*/ +void CTPanic::TestSpriteActivatePanicL() + { + for(TInt test=1;test<3;test++) + { + TEST(iTest->TestWsPanicL(&DoTestSpriteActivatePanicL,EWservPanicNoSpriteMember,test,NULL)); + } + } + +void CTPanic::TestMoveToGroupPanicsL() + { + TEST(iTest->TestWsPanicL(&DoMoveToGroupPanicTestL,EWservPanicOpcode,1,(TAny*)iTest->iScreenNumber)); + TEST(iTest->TestWsPanicL(&DoMoveToGroupPanicTestL,EWservPanicNotTopClient,2,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestDeleteScreenPanicL() + { +#ifdef __WINS__ + TEST(iTest->TestWsPanicL(&DoDeleteScreenPanicTestL,EWservPanicGroupWinScreenDeviceDeleted,1,(TAny*)iTest->iScreenNumber)); + TEST(iTest->TestWsPanicL(&DoDeleteScreenPanicTestL,EWservPanicGroupWinScreenDeviceDeleted,2,(TAny*)iTest->iScreenNumber)); +#endif + } + +void CTPanic::TestWinHandleErrors() + { +#ifdef __WINS__ + TEST(iTest->TestWsPanicL(&DoWinHandlePanicTestL,EWservPanicDuplicateHandle,1)); + TEST(iTest->TestWsPanicL(&DoWinHandlePanicTestL,EWservPanicDuplicateHandle,2)); + TEST(iTest->TestWsPanicL(&DoWinHandlePanicTestL,EWservPanicDuplicateHandle,3)); +#endif + TEST(iTest->TestWsPanicL(&DoWinHandlePanicTestL,EWservPanicNullHandle,4)); + } + +void CTPanic::TestGetEventErrors() + { + TEST(iTest->TestWsPanicL(&DoGetEventPanicTestL,EWservPanicUnsignalledEventData,1,(TAny*)iTest->iScreenNumber)); + TEST(iTest->TestWsPanicL(&DoGetEventPanicTestL,EWservPanicDescriptor,2,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::TestUnInitPanicL() + { + TEST(iTest->TestWsPanicL(&DoUnInitPanicTest,EWservPanicUninitialisedClient,0,(TAny*)iTest->iScreenNumber)); + } + +void CTPanic::ConstructL() + { + TheGc->Activate(*BaseWin->Win()); + TheGc->Clear(); + TheGc->SetBrushColor(TRgb::Gray16(12)); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetPenStyle(CGraphicsContext::ENullPen); + TheGc->DrawRect(TRect(BaseWin->Win()->Size())); + TheGc->Deactivate(); + TheGc->Activate(*TestWin->Win()); + TheGc->Clear(); + TheGc->SetBrushColor(TRgb::Gray16(4)); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetPenStyle(CGraphicsContext::ENullPen); + TheGc->DrawRect(TRect(TestWin->Win()->Size())); + TheGc->Deactivate(); +// + _LIT(KReportFullRom,"Warning full ROM, EikSrv present, panic dialogs may interfere with tests"); + _LIT(KReportGoodRom,"ROM OK, No EikSrv present"); + if (iTest->IsFullRomL()) + { + INFO_PRINTF1(KReportFullRom); + } + else + { + INFO_PRINTF1(KReportGoodRom); + } + } + +void CTPanic::TestAlphaBlendingPanicL() + { + INFO_PRINTF1(_L("Masked transparency support has been removed.")); + } + +void CTPanic::TestMismatchedCaptureCancelPanicL() + { +// Run this test in debug on emulator only. +// On a debug ROM the release version of the wserv.exe is included so the test can't be run as no panic happens. +#if defined(_DEBUG) && defined(__WINS__) + TEST(iTest->TestWsPanicL(DoMismatchedCancelCaptureTest,EWservPanicDestroy,ECancelCaptureKey,(TAny*)iTest->iScreenNumber)); + TEST(iTest->TestWsPanicL(DoMismatchedCancelCaptureTest,EWservPanicDestroy,ECancelCaptureKeyUpAndDowns,(TAny*)iTest->iScreenNumber)); + TEST(iTest->TestWsPanicL(DoMismatchedCancelCaptureTest,EWservPanicDestroy,ECancelCaptureLongKey,(TAny*)iTest->iScreenNumber)); +#endif + } + +void CTPanic::RunTestCaseL(TInt /*aCurTestCase*/) + { + ((CTPanicStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(++iTest->iState) + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0259 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test various system panics + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that various system panics respond correctly + +@SYMTestExpectedResults Panics respond correctly +*/ + case 1: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0259")); + iTest->LogSubTest(_L("TestCaptureKeyPanicsL")); + TestCaptureKeyPanicsL(); + } + break; + case 2: + { + iTest->LogSubTest(_L("TestEventPanicsL")); + TestEventPanicsL(); + } + break; + case 3: + { + iTest->LogSubTest(_L("TestComputeModePanicsL")); + TestComputeModePanicsL(); + } + break; + case 4: + { +#ifdef __WINS__ +// Only running this under WINS as the tests are a bit excessive, firing off all sorts of illegal +// opcode/flag combinations, as well as buffers of random data. +// Currently on ARM builds they're failing with KErrOutOfMemory, probably running out of handles +// somewhere in the OS. + iTest->LogSubTest(_L("TestMiscPanicsL")); + TestMiscPanicsL(); +#endif + } + break; + case 5: + { + iTest->LogSubTest(_L("TestGraphicsPanicsL")); + TestGraphicsPanicsL(); + } + break; + case 6: + { + iTest->LogSubTest(_L("TestTPtrPanicsL")); + TestTPtrPanicsL(); + } + break; + case 7: + { + iTest->LogSubTest(_L("TestOpcodePanicsL")); + TestOpcodePanicsL(); + } + break; + case 8: + { + iTest->LogSubTest(_L("TestScreenDevicePanicsL")); + TestScreenDevicePanicsL(); + } + break; + case 9: + { + iTest->LogSubTest(_L("TestMultiInitPanicL")); + TestMultiInitPanicL(); + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0260 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test various system panics + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that various system panics respond correctly + +@SYMTestExpectedResults Panics respond correctly +*/ + case 10: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0260")); + iTest->LogSubTest(_L("Panic 2")); + TestSpritePanicsL(); + TestMoveToGroupPanicsL(); + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0261 + +@SYMDEF DEF081259 + +@SYMTestCaseDesc Test defect fixes to system panics + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that various defect fixes to system panics are correct + +@SYMTestExpectedResults Panics respond correctly +*/ + case 11: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0261")); + _LIT(KPanicTest,"Defect Fixes (Pan.3)"); + iTest->LogSubTest(KPanicTest); + TestDeletedParentPanicsL(); + TestHandleReUseL(); + TestDeleteScreenPanicL(); // DEF069809 + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-097969-0001 + +@SYMDEF DEF097969 + +@SYMTestCaseDesc Test defect fixes to system panics + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that various defect fixes to system panics are correct + +@SYMTestExpectedResults Panics respond correctly +*/ + case 12: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-097969-0001")); + _LIT(KPanicTest,"Server panic defect Fix (Pan.4)"); + iTest->LogSubTest(KPanicTest); + TestUnInitPanicL(); // DEF097969 + } + break; + + case 13: + { +/** +@SYMTestCaseID GRAPHICS-WSERV-0501 +*/ + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0501")); + _LIT(KPanicTest,"AlphaBlending Bitmap panic defect Fix (Pan.5)"); + iTest->LogSubTest(KPanicTest); + TestAlphaBlendingPanicL(); // DEF112916 + } + break; + case 14: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0472")); + _LIT(KPanicTest,"Double construction panic test"); + iTest->LogSubTest(KPanicTest); + TestDoubleConstructionL(); // DEF118618 + } + break; + case 15: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0475")); + _LIT(KPanicTest, "RWsSprite Activate() without members panic test"); + iTest->LogSubTest(KPanicTest); + TestSpriteActivatePanicL(); //DEF118616 + } + break; +/** +@SYMTestCaseID GRAPHICS-WSERV-0497 + +@SYMDEF DEF133776 + +@SYMTestCaseDesc Test that a debug only panic occurs when an attempt + is made to cancel a key capture using the wrong cancel capture API. + +@SYMTestPriority High + +@SYMTestStatus Implemented + +@SYMTestActions Check that calling the each RWindowGroup::CancelCapture***() API + using the handle returned from a mismatched RWindowGroup::Capture***() call causes + a debug only panic. Tests each of the three RWindowGroup::CancelCapture***() APIs. + +@SYMTestExpectedResults Panics respond correctly in debug only. +*/ + case 16: + { + ((CTPanicStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0497")); + _LIT(KPanicTest,"TestMismatchedCaptureCancelPanicL"); + iTest->LogSubTest(KPanicTest); + TestMismatchedCaptureCancelPanicL(); + } + break; +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + case 17: + { + _LIT(KPanicTest, "Non-Redraw Drawing inside Redrawer Panic Test"); + iTest->LogSubTest(KPanicTest); + TestNonRedrawRedrawerL(); + } +#endif + default: + ((CTPanicStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTPanicStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTPanicStep*)iStep)->RecordTestResultL(); + } + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA +LOCAL_C TInt DoTestNonRedrawRedrawerL(TInt /* aInt */, TAny * /* aPtr */) + { + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler(); + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + RWsSession session; + User::LeaveIfError(session.Connect()); + + CWsScreenDevice *screenDevice = new (ELeave)CWsScreenDevice(session); + User::LeaveIfError(screenDevice->Construct ()); + CWindowGc *gc; + User::LeaveIfError(screenDevice->CreateContext(gc)); + + CNonRedrawWin *nonRedrawWin=CNonRedrawWin::NewL(session, gc); + nonRedrawWin->Invalidate(); + CActiveScheduler::Start(); + User::After(2000000); // so the Redrawer has a chance to run + CActiveScheduler::Stop(); + delete gc; + delete screenDevice; + session.Close(); + CleanupStack::PopAndDestroy(scheduler); + return(EWsExitReasonBad); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0121808 +@SYMDEF DEF121808: No more Non-Redraw drawing for NGA (test added during DEF134308) +@SYMTestCaseDesc Test defect fixes to system panics +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Check that WServ panics a client which uses Non-Redraw drawing in the Redrawer. +@SYMTestExpectedResults Panics respond correctly +*/ +void CTPanic::TestNonRedrawRedrawerL() + { + TEST(iTest->TestWsPanicL(&DoTestNonRedrawRedrawerL,EWservPanicWindowBeginRedrawNotCalled,NULL,NULL)); + } + +CNonRedrawWin::CRedrawer::CRedrawer(CNonRedrawWin* aWd) : + CActive(CActive::EPriorityStandard), iWd(aWd){ + CActiveScheduler::Add(this); + HandleRedrawEvent(); +} + +CNonRedrawWin::CRedrawer::~CRedrawer(){ + Cancel(); +} + +void CNonRedrawWin::CRedrawer::HandleRedrawEvent(){ + iWd->GetSession().RedrawReady(&iStatus); + SetActive(); +} + +void CNonRedrawWin::CRedrawer::RunL(){ + TWsRedrawEvent redrawEvent; + iWd->GetSession().GetRedraw(redrawEvent); + iWd->Redraw(); + HandleRedrawEvent(); +} + +void CNonRedrawWin::CRedrawer::DoCancel(){ + iWd->GetSession().RedrawReadyCancel(); +} + +CNonRedrawWin* CNonRedrawWin::NewL(RWsSession &aSession, CWindowGc *aGc){ + CNonRedrawWin* self=new(ELeave)CNonRedrawWin(aSession, aGc); + CleanupStack::PushL(self); + self->ConstrucL(); + CleanupStack::Pop(self); + return self; +} + +CNonRedrawWin::CNonRedrawWin(RWsSession &aSession, CWindowGc *aGc): + iSession(aSession), iGc(aGc){} + +CNonRedrawWin::~CNonRedrawWin(){ + delete iRedrawer; + iWd.Close(); + iWdGrp.Close(); +} + +void CNonRedrawWin::Redraw(){ + // This is a Non-Redraw Drawing Redrawer; BeginRedraw()/EndRedraw() + // have been intentionally omitted. + iGc->Activate(iWd); + iGc->SetBrushColor(TRgb(255,0,0)); + iGc->SetPenColor(KRgbBlue); + iGc->SetPenSize(TSize(10,20)); + iGc->DrawRect(TRect(TPoint(10,10),TPoint(50,50))); + iGc->Deactivate(); + iSession.Finish(); +} + +RWsSession &CNonRedrawWin::GetSession(){return iSession;} + +void CNonRedrawWin::Invalidate(){iWd.Invalidate();} + +void CNonRedrawWin::ConstrucL(){ + iWdGrp=RWindowGroup(iSession); + iWdGrp.Construct((TUint32)this,ETrue); + _LIT(KWndGrpName,"NonRedrawWndGrp"); + iWdGrp.SetName(KWndGrpName); + iWd=RWindow(iSession); + iWd.Construct(iWdGrp, 0x101); + User::LeaveIfError(iWd.SetExtentErr(TPoint(0,0),TSize(150,150))); + iWd.SetBackgroundColor(KRgbWhite); + iWd.SetOrdinalPosition(0); + iWd.Activate(); + iRedrawer=new(ELeave) CRedrawer(this); +} +#endif + +TInt RUnInitalisedConnect::Connect(const TDesC &aName, const TVersion &aVersion) + { + return CreateSession(aName, aVersion, 255); + } + +TInt RUnInitalisedConnect::Send(const TInt aMsg) + { + return SendReceive(aMsg); + } + +__WS_CONSTRUCT_STEP__(Panic) +#pragma warning( disable : 4505 )