// Copyright (c) 2007-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:

 // The fix solves the problem of bitmap drawing command being added to the window server

 // command buffer without the bitmap handle(s) being added to the command buffer bitmap array.

 // 

 //

 /**

  @file

  @test

  @internalComponent - Internal Symbian test code

 */

 #include "tw32cmdbuf.h"

 const TInt KMaxTestIterations = 300;

 const TInt KMinTestIterations = 100;

 CTW32CmdBuf::CTW32CmdBuf(CTestStep* aStep):

 	CTGraphicsBase(aStep)

 	{

 	}

 CTW32CmdBuf::~CTW32CmdBuf()

 	{

 	}

 void CTW32CmdBuf::ConstructL()

 	{

 	}

 void CTW32CmdBuf::RunTestCaseL(TInt aCurTestCase)

 	{

 	((CTW32CmdBufStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

 	switch(aCurTestCase)

 		{

 		case 1:

 			((CTW32CmdBufStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0452"));

 			INFO_PRINTF1(_L("Test all the drawing commands involving a CFbsBitmap\n"));

 			DoCmdBufTestsL();

 			break;

 		default:

 			((CTW32CmdBufStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

 			((CTW32CmdBufStep*)iStep)->CloseTMSGraphicsStep();

 			INFO_PRINTF1(_L("Test complete\n"));

 			TestComplete();

 		}

 	((CTW32CmdBufStep*)iStep)->RecordTestResultL();

 	}

 /**

 * TTestFunctionPtr pointer-to-function type definition

 */

 typedef	void (*TTestFunctionPtr)(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* aMask);

 /**

 * Calls CWindowGc::DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aDevice)

 */

 void CallDrawBitmap1(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/)

 	{

 	aGc->DrawBitmap(TPoint(0, 0), aBitmap);

 	}

 /**

 * Calls CWindowGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice)

 */

 void CallDrawBitmap2(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/)

 	{

 	aGc->DrawBitmap(TRect(0, 0, 100, 100), aBitmap);

 	}

 /**

 * Calls CWindowGc::DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aDevice, const TRect &aSourceRect)

 */

 void CallDrawBitmap3(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/)

 	{

 	aGc->DrawBitmap(TRect(0, 0, 100, 100), aBitmap, TRect(0, 0, 100, 100));

 	}

 /**

 * Calls CWindowGc::DrawBitmapMasked(const TRect& aDestRect, const CFbsBitmap* aBitmap, const TRect& aSourceRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask)

 */

 void CallDrawBitmapMasked(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* aMask)

 	{

 	aGc->DrawBitmapMasked(TRect(0, 0, 100, 100), aBitmap, TRect(0, 0, 100, 100), aMask, EFalse);

 	}

 /**

 * Calls CWindowGc::UseBrushPattern(const CFbsBitmap *aDevice)

 */	

 void CallUseBrushPattern(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/)

 	{

 	aGc->UseBrushPattern(aBitmap);

 	}

 /**

 * Calls CWindowGc::BitBlt(const TPoint &aPos, const CFbsBitmap *aBitmap)

 */

 void CallBitBlt1(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/)

 	{

 	aGc->BitBlt(TPoint(0, 0), aBitmap);

 	}

 /**

 * Calls CWindowGc::BitBlt(const TPoint &aDestination, const CFbsBitmap *aBitmap, const TRect &aSource)

 */

 void CallBitBlt2(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* /*aMask*/)

 	{

 	aGc->BitBlt(TPoint(0, 0), aBitmap, TRect(0, 0, 100, 100));

 	}

 /**

 * Calls CWindowGc::BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask)

 */

 void CallBitBltMasked(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* aMask)

 	{

 	aGc->BitBltMasked(TPoint(0, 0), aBitmap, TRect(0, 0, 100, 100), aMask, EFalse);

 	}

 /**

 * Calls CWindowGc::AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp, const TPoint& aAlphaPt)

 */	

 void CallAlphaBlendBitmaps(CWindowGc* aGc, CFbsBitmap* aBitmap, CFbsBitmap* aMask)

 	{

 	aGc->AlphaBlendBitmaps(TPoint(0, 0), aBitmap, TRect(0, 0, 100, 100), aMask, TPoint(0, 0));

 	}

 /**

 * Drawing command function array.

 */	

 const TTestFunctionPtr KTestFunctions[] =

 		{

 		CallDrawBitmap1,

 		CallDrawBitmap2,

 		CallDrawBitmap3,

 		CallDrawBitmapMasked,

 		CallUseBrushPattern,

 		CallBitBlt1,

 		CallBitBlt2,

 		CallBitBltMasked,

 		CallAlphaBlendBitmaps,

 		};

 /**

  * @SYMTestCaseID			GRAPHICS-WSERV-0452

  * @SYMTestCaseDesc			Tests drawing commands with bitmap handles.

  * @SYMDEF					INC111655

  * @SYMFssID				CWindowGc::DrawBitmap() \n 

  * 							CWindowGc::DrawBitmapMasked()\n 

  * 							CWindowGc::UseBrushPattern()\n 

  * 							CWindowGc::BitBlt()\n 

  * 							CWindowGc::AlphaBlendBitmaps()

  * @SYMTestPriority			Critical

  * @SYMTestType				Unit Test

  * @SYMTestPurpose			To ensure drawing commands with bitmap handles are added to the

  							command buffer successfully when the buffer is full.

  * @SYMTestActions			Fill the command buffer with CWindowGc::Clear() commands in a loop until

  							the buffer is full, create bitmap(s), then call the draw command and then 

  							delete the bitmap handle(s). All tests are done in a second thread.

  * @SYMTestExpectedResults	The function should not panic. Without the fix the functions will panic

  							with WSERV 7. 

  * @SYMTestStatus			Implemented 

  */	

 void CTW32CmdBuf::DoCmdBufTestsL()

 	{

 	CreateSecondThreadAndDoTestL(ECallDrawBitmap1);

 	CreateSecondThreadAndDoTestL(ECallDrawBitmap2);

 	CreateSecondThreadAndDoTestL(ECallDrawBitmap3);

 	CreateSecondThreadAndDoTestL(ECallDrawBitmapMasked);

 	CreateSecondThreadAndDoTestL(ECallUseBrushPattern);	

 	CreateSecondThreadAndDoTestL(ECallBitBlt1);

 	CreateSecondThreadAndDoTestL(ECallBitBlt2);

 	CreateSecondThreadAndDoTestL(ECallBitBltMasked);

 	CreateSecondThreadAndDoTestL(ECallAlphaBlendBitmaps);

 	}

 /**

 * Creates a second thread to run the test.

 * 

 * @param aFunctionIndex The drawing function command to be executed. All commands are defined in TestFunctionIndex.

 */

 void CTW32CmdBuf::CreateSecondThreadAndDoTestL(TTestFunctionIndex aFunctionIndex)

 	{	

 	RThread thread;

 	TBuf<30> threadName(KTW32CmdBufSecondThread);

 	static TInt threadSerialNumber = 0;

 	threadName.AppendNum(++threadSerialNumber);

 	User::LeaveIfError(thread.Create(threadName, TestCmdBufFunction, KDefaultStackSize, KMinHeapSize, 0x4000, &aFunctionIndex));

 	TRequestStatus status;

 	thread.Logon(status);

 	thread.Resume();

 	User::WaitForRequest(status);

 	TEST(thread.ExitType()==EExitKill);

 	TEST(thread.ExitReason() == KErrNone);

 	thread.Close();	

 	}

 /**

 * Runs the test in a second thread.

 *

 * @param aFunctionIndex The drawing function command to be executed. All commands are defined in TestFunctionIndex.

 */

 TInt CTW32CmdBuf::DoTestCmdBufFunctionL(TTestFunctionIndex aFunctionIndex)

 	{

 	RWsSession session;

 	User::LeaveIfError(session.Connect());

 	CleanupClosePushL(session);

 	CWsScreenDevice *device = new(ELeave) CWsScreenDevice(session);

 	CleanupStack::PushL(device);

 	User::LeaveIfError(device->Construct(CTestBase::iScreenNo));

 	CWindowGc* gc;

 	User::LeaveIfError(device->CreateContext(gc));

 	CleanupStack::PushL(gc);

 	RWindowGroup group(session);

 	User::LeaveIfError(group.Construct(1, EFalse));

 	CleanupClosePushL(group);

 	RWindow window(session);

 	User::LeaveIfError(window.Construct(group, 2));

 	CleanupClosePushL(window);

 	window.SetExtent(TPoint(0,0), TSize(200, 200));

 	User::LeaveIfError(window.SetRequiredDisplayMode(EColor64K));

 	window.Activate();	

 	gc->Activate(window);

 	session.SetAutoFlush(EFalse);

 	window.Invalidate();

 	window.BeginRedraw();

 	for(TInt i=KMinTestIterations; i<KMaxTestIterations; ++i)

 		{

 		for(TInt j=0; j<i; ++j)

 			{

 			gc->Clear();

 			}

 		CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(bitmap);

 		User::LeaveIfError(bitmap->Create(TSize(100, 100), EColor64K));

 		CFbsBitmap* mask = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(mask);

 		User::LeaveIfError(mask->Create(TSize(100, 100), EColor64K));

 		KTestFunctions[aFunctionIndex](gc, bitmap, mask);

 		CleanupStack::PopAndDestroy(2);

 		session.Flush();	

 		}	

 	window.EndRedraw();	

 	gc->Deactivate();

 	CleanupStack::PopAndDestroy(5);

 	return KErrNone;

 	}

 /**

 * Second thread entry function.

 *

 * @param aInfo The parameter(s) passed to the second thread in this case the function index.

 */

 TInt CTW32CmdBuf::TestCmdBufFunction(TAny* aInfo)

 	{	

 	if(!aInfo)

 		{

 		return KErrArgument;

 		}

 	TTestFunctionIndex functionIndex = *(TTestFunctionIndex*)aInfo;

 	CTrapCleanup *trap = CTrapCleanup::New();

 	__ASSERT_ALWAYS(trap, User::Invariant());

 	TRAPD(err, DoTestCmdBufFunctionL(functionIndex));	

 	delete trap;

 	return err;

 	}

 __CONSTRUCT_STEP__(W32CmdBuf)