// Copyright (c) 1996-2010 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 <w32debug.h>

#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<TInt> 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 (bmpMode<KNumBadBmpModes)

			{	// These two use a CFbsBitmap

			CFbsBitmap* goodBitmap=new(ELeave) CFbsBitmap;

			goodBitmap->Create(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<TWsGcCmdDrawPolyLine*>(bufData);

			drawPolyline->numPoints=headerPoints;

			drawPolyline->more=EFalse;

			drawPolyline->last=point00;

			pointPtr=reinterpret_cast<TPoint*>(drawPolyline+1);

			opcode=EWsGcOpDrawPolyLine;

			}

		else

			{

			TWsGcCmdDrawPolygon* drawPolygon=static_cast<TWsGcCmdDrawPolygon*>(bufData);

			drawPolygon->numPoints=headerPoints;

			drawPolygon->fillRule=CGraphicsContext::EAlternate;

			pointPtr=reinterpret_cast<TPoint*>(drawPolygon+1);

			opcode=EWsGcOpDrawPolygon;

			}

		const TPoint* endPtr=pointPtr+bufPoints;

		TInt pointPos=0;

		while(pointPtr<endPtr)

			*pointPtr++=TPoint(pointPos,pointPos);

		aWs.TestWrite(aGc->WsHandle(),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<TWsGcCmdSegmentedDrawPolygonData*>(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:

		{