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

 //

 /**

  @file

  @internalComponent 

  @test

 */

 #include "tmultithread.h"

 #include <graphics/directgdicontext.h>

 const TUint KMinTestThreadHeapSize = 0x00000100;

 const TUint KMaxTestThreadheapSize = 0x00100000;

 CTMultiThread::CTMultiThread()

 	{

 	SetTestStepName(KTMultiThreadStep);

 	}

 CTMultiThread::~CTMultiThread()

 	{

 	iThread1.Close();

 	iThread2.Close();

 	}

 /**

 Override of base class virtual

 @leave Gets system wide error code

 @return - TVerdict code

 */

 TVerdict CTMultiThread::doTestStepPreambleL()

 	{			

 	CTDirectGdiStepBase::doTestStepPreambleL();	

 	return TestStepResult();

 	}

 /** 

 Override of base class pure virtual

 Our implementation only gets called if the base class doTestStepPreambleL() did

 not leave. That being the case, the current test result value will be EPass.

 @leave Gets system wide error code

 @return TVerdict code

 */	

 TVerdict CTMultiThread::doTestStepL()

 	{

 	if (iUseDirectGdi)

 		{

 		RunTestsL();

 		// No framework OOM tests are run for the multithreaded tests as OOM testing only checks the 

 		// heap in the current thread and these tests use multiple threads. Some heap checking is

 		// performed within the tests themselves.

 		}

 	else

 		{

 		INFO_PRINTF1(_L("Test skipped under BitGDI.\n"));	

 		}	

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 Override of base class pure virtual

 Lists the tests to be run

 */

 void CTMultiThread::RunTestsL()

 	{

 	SetTestStepID(_L("GRAPHICS-DIRECTGDI-MULTITHREAD-0001"));

 	TestDirectGdiMultipleThreadIndependenceL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-DIRECTGDI-MULTITHREAD-0002"));

 	TestShareEGLImageBetweenSources_MultithreadedL();

 	RecordTestResultL();

 	}

 /**

 @SYMTestCaseID  

 	GRAPHICS-DIRECTGDI-MULTITHREAD-0001

 @SYMPREQ 

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc  

 	Ensure multi-threaded use of DirectGDI is truly independent.

 @SYMTestPriority  

 	High

 @SYMTestStatus 

 	Implemented

 @SYMTestActions 

 	The following sequence should be legal:

 		1: (thread 1) initialise DirectGDI by calling ThreadOneStart()

 		2: (thread 2) initialise DirectGDI by calling ThreadTwoStart()

 		3: (thread 1) close DirectGDI

 		4: (thread 2) render using DirectGDI

 @SYMTestExpectedResults 

 	There should be no panics.

 */

 void CTMultiThread::TestDirectGdiMultipleThreadIndependenceL()

 	{

 	INFO_PRINTF1(_L("Multithread_MultipleThreadIndependence"));	

 	// Create a semaphore

 	RSemaphore sem;

 	TEST(KErrNone == sem.CreateGlobal(KMultiThreadSemaphore, 0));

    	CleanupClosePushL(sem);	

    	//create threads

 	User::LeaveIfError(iThread1.Create(KNameThreadOne, ThreadOneStart, KDefaultStackSize, KMinTestThreadHeapSize, KMaxTestThreadheapSize, NULL));

 	User::LeaveIfError(iThread2.Create(KNameThreadTwo, ThreadTwoStart, KDefaultStackSize, KMinTestThreadHeapSize, KMaxTestThreadheapSize, NULL));

 	//launch thread1

 	TRequestStatus thread1Status;

 	iThread1.Logon(thread1Status);

 	iThread1.SetPriority(EPriorityLess);

 	iThread1.Resume();

 	sem.Wait();

 	iThread1.Suspend();

 	//launch thread2

 	TRequestStatus thread2Status;

 	iThread2.Logon(thread2Status);

 	iThread2.SetPriority(EPriorityLess);

 	iThread2.Resume();

 	sem.Wait();

 	iThread2.Suspend();

 	//resume thread1

 	iThread1.Resume();

 	User::WaitForRequest(thread1Status);

 	//resume thread2

 	iThread2.Resume();

 	User::WaitForRequest(thread2Status);	

 	TESTNOERROR(iThread1.ExitReason());

 	TESTNOERROR(iThread2.ExitReason());

 	iThread1.Close();

 	iThread2.Close();

 	CleanupStack::PopAndDestroy(&sem);

 	}

 /**

 Function for initializing DirectGdi, used by TestDirectGdiMultipleThreadIndependenceL().

 @see TestDirectGdiMultipleThreadIndependenceL() 

 @param aInfo Not used

 @return KErrNone if successful, one of the system wide error codes otherwise

  */

 TInt CTMultiThread::ThreadOneStart(TAny* /*aInfo*/)

 	{	

 	TInt procHandles1  =0;

 	TInt threadHandles1=0;

 	RThread().HandleCount(procHandles1, threadHandles1);

 	__UHEAP_MARK;

 	RSemaphore sem;

 	TInt ret = sem.OpenGlobal(KMultiThreadSemaphore);

 	if (ret!=KErrNone)

 		{

 		return ret;

 		}		

 	//initialize graphics resource driver

 	ret = SgDriver::Open();

 	if (ret!=KErrNone)

 		{

 		return ret;

 		}		

 	//initialise DirectGDI

 	ret = CDirectGdiDriver::Open();

 	if (ret!=KErrNone)

 		{

 		return ret;

 		}		

 	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

 	if(dgdiDriver == NULL)

 		{

 		return KErrGeneral;	

 		}

 	sem.Signal();

 	//close DirectGDI

 	dgdiDriver->Close();

 	SgDriver::Close();	

 	sem.Close();

 	__UHEAP_MARKEND;

 	TInt procHandles2  =0;

 	TInt threadHandles2=0;

 	RThread().HandleCount(procHandles2,threadHandles2);

 	if (threadHandles1 != threadHandles2)

 		{

 		ret = KErrGeneral;  // Thread-owned handles not closed

 		}

 	return ret;

 	}

 /**

 Function for initializing DirectGdi then activating a target and drawing on it,

 used by TestDirectGdiMultipleThreadIndependenceL().

 @see TestDirectGdiMultipleThreadIndependenceL()

 @param aInfo Not used

 @return KErrNone if successful, one of the system wide error codes otherwise 

  */

 TInt CTMultiThread::ThreadTwoStart(TAny* /*aInfo*/)

 	{

 	TInt procHandles1  =0;

 	TInt threadHandles1=0;

 	RThread().HandleCount(procHandles1, threadHandles1);

 	__UHEAP_MARK;

 	CTrapCleanup* cleanupStack=CTrapCleanup::New();

 	if (cleanupStack==NULL)

 		{

 		return KErrNoMemory;

 		}

 	RSemaphore sem;

 	TInt ret = sem.OpenGlobal(KMultiThreadSemaphore);

 	if (ret!=KErrNone)

 		{

 		return ret;

 		}		

 	//initialize graphics resource driver

 	ret = SgDriver::Open();

 	if (ret!=KErrNone)

 		{

 		return ret;

 		}		

 	//initialise DirectGDI

 	ret = CDirectGdiDriver::Open();

 	if (ret!=KErrNone)

 		{

 		return ret;

 		}		

 	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

 	if(dgdiDriver == NULL)

 		{

 		return KErrGeneral;	

 		}

 	sem.Signal();

 	//render using DirectGDI

 	CDirectGdiContext* gc = NULL;

 	TRAPD(err, gc=CDirectGdiContext::NewL(*dgdiDriver));

 	if(err != KErrNone)

 		{

 		return err;

 		}

 	RSgImage rsgImage;	

 	TSgImageInfo imageInfo;

 	imageInfo.iSizeInPixels = TSize (320, 240);

 	imageInfo.iPixelFormat = EUidPixelFormatRGB_565;

 	imageInfo.iUsage = ESgUsageDirectGdiTarget;

 	ret = rsgImage.Create(imageInfo, NULL,0);

 	if(ret != KErrNone)

 		{

 		return ret;

 		}

 	RDirectGdiImageTarget dgdiImageTarget(*dgdiDriver);	

 	ret = dgdiImageTarget.Create(rsgImage);

 	if(ret != KErrNone)

 		{

 		return ret;

 		}

 	gc->Activate(dgdiImageTarget);

 	gc->SetPenColor(TRgb(100,100,100));

 	gc->DrawRect(TRect(0,0,30,30));

 	rsgImage.Close();

 	dgdiImageTarget.Close();

 	delete gc;

 	dgdiDriver->Close();

 	SgDriver::Close();

 	delete cleanupStack;

 	__UHEAP_MARKEND;

 	sem.Close();	

 	TInt procHandles2  =0;

 	TInt threadHandles2=0;

 	RThread().HandleCount(procHandles2,threadHandles2);

 	if (threadHandles1 != threadHandles2)

 		{

 		ret = KErrGeneral;  // Thread-owned handles not closed

 		}

 	return ret;

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-MULTITHREAD-0002

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus

 	Implemented

 @SYMTestCaseDesc

 	Create two CDirectGdiImageSource objects from the same RSgImage, but in different threads.

 @SYMTestActions	

 	Test the use case where we:

 	Create an RSgImage

 	Create two CDirectGdiImageSource objects, one in the current thread, and one in a new thread.

 	The CDirectGdiImageSource objects should share the EGL image created from the RSgImage in the 

 	current thread as only one EGL image can be created per RSgImage per process.

 	If the EGL image sharing is not working an error will occur when creating the

 	second CDirectGdiImageSource object in the new thread.

 */

 void CTMultiThread::TestShareEGLImageBetweenSources_MultithreadedL()

 	{

 	INFO_PRINTF1(_L("Multithread_ShareEGLImageBetweenSources"));

 	TUidPixelFormat pixelFormat = EUidPixelFormatXRGB_8888;

 	SetTargetL(pixelFormat);

 	// Initialize graphics resource driver

 	TInt res = SgDriver::Open();

 	TESTNOERRORL(res);

 	res = CDirectGdiDriver::Open();

 	TESTNOERRORL(res);		

 	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

 	TESTL(dgdiDriver != NULL);	

 	CleanupClosePushL(*dgdiDriver);	

 	// Create a context

 	CDirectGdiContext* gc = CDirectGdiContext::NewL(*dgdiDriver);

 	TESTL(gc != NULL);	

 	CleanupStack::PushL(gc);	

 	// Create a CFbsBitmap	

 	TSize patternSize(90,50);

 	TRect rect(0,0,90,50);

 	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(pixelFormat, patternSize);

 	TESTL(NULL != bitmap);

 	CleanupStack::PushL(bitmap);	

 	// Create an RSgImage from the CFbsBitmap

 	TSgImageInfo imageInfo;

 	imageInfo.iSizeInPixels = patternSize;

 	imageInfo.iPixelFormat = pixelFormat;

 	imageInfo.iUsage = ESgUsageDirectGdiSource;

 	RSgImage sgImage;	

 	res = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());	

 	TESTNOERRORL(res);	

 	CleanupClosePushL(sgImage);

 	// Create a RDirectGdiDrawableSource from the RSgImage

 	RDirectGdiDrawableSource dgdiImageSource(*dgdiDriver);	

 	res = dgdiImageSource.Create(sgImage);		

 	TESTNOERRORL(res);

 	CleanupClosePushL(dgdiImageSource);	

 	// Create a semaphore

 	RSemaphore sem;

 	TEST(KErrNone == sem.CreateGlobal(KMultiThreadSemaphore, 0));

    	CleanupClosePushL(sem);	

    	// Create the thread that will create a source from the RSgImage above   	

    	TSgDrawableId sgImageId = sgImage.Id();

 	User::LeaveIfError(iThread1.Create(KNameThreadOne, ThreadEGLImageStart, KDefaultStackSize, KMinTestThreadHeapSize, KMaxTestThreadheapSize, &sgImageId));	

 	// Launch the thread

 	TRequestStatus threadStatus;

 	iThread1.Logon(threadStatus);

 	iThread1.SetPriority(EPriorityLess);

 	iThread1.Resume();

 	sem.Wait();

 	iThread1.Suspend();

 	// Resume the thread

 	iThread1.Resume();

 	User::WaitForRequest(threadStatus);

 	TESTNOERROR(iThread1.ExitReason());	

 	iThread1.Close();	

 	SgDriver::Close();

 	CleanupStack::PopAndDestroy(6, dgdiDriver);

 	}

 /**

 Function use by TestShareEGLImageBetweenSources_MultithreadedL() when testing

 creation of a target in a separate thread.

 @see TestShareEGLImageBetweenSources_MultithreadedL()

 @param aInfo Not used

 @return KErrNone if successful, one of the system wide error codes otherwise

  */

 TInt CTMultiThread::ThreadEGLImageStart(TAny* aInfo)

 	{	

 	TInt procHandles1 = 0;

 	TInt threadHandles1 = 0;

 	RThread().HandleCount(procHandles1, threadHandles1);

 	__UHEAP_MARK;

 	CTrapCleanup* cleanupStack=CTrapCleanup::New();

 	if (cleanupStack==NULL)

 		{

 		return KErrNoMemory;

 		}		

 	RSemaphore sem;

 	TInt ret = sem.OpenGlobal(KMultiThreadSemaphore);

 	if (ret!=KErrNone)

 		return ret;

 	// Initialize graphics resource driver

 	ret = SgDriver::Open();

 	if (ret!=KErrNone)

 		return ret;

 	// Initialise DirectGDI

 	ret = CDirectGdiDriver::Open();

 	if (ret!=KErrNone)

 		return ret;

 	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

 	if(dgdiDriver == NULL)

 		{

 		return KErrGeneral;	

 		}

 	TSgDrawableId* sgImageId = reinterpret_cast<TSgDrawableId*>(aInfo);

 	RSgImage sgImageSource;

 	ret = sgImageSource.Open(*sgImageId);

 	if (ret!=KErrNone)

 		return ret;

 	// Create a RDirectGdiDrawableSource from the RSgImage

 	RDirectGdiDrawableSource dgdiImageSource(*dgdiDriver);	

 	ret = dgdiImageSource.Create(sgImageSource);		

 	if (ret!=KErrNone)

 		return ret;

 	sem.Signal();

 	// Render using DirectGDI

 	CDirectGdiContext* gc = NULL;

 	TRAPD(err, gc=CDirectGdiContext::NewL(*dgdiDriver));

 	if(err != KErrNone)

 		{

 		return err;

 		}

 	RSgImage rsgImage;	

 	TSgImageInfo imageInfo;

 	imageInfo.iSizeInPixels = TSize (320, 240);

 	imageInfo.iPixelFormat = EUidPixelFormatRGB_565;

 	imageInfo.iUsage = ESgUsageDirectGdiTarget;

 	ret = rsgImage.Create(imageInfo, NULL,0);

 	if(ret != KErrNone)

 		{

 		return ret;

 		}

 	RDirectGdiImageTarget dgdiImageTarget(*dgdiDriver);	

 	ret = dgdiImageTarget.Create(rsgImage);

 	if(ret != KErrNone)

 		{

 		return ret;

 		}

 	gc->Activate(dgdiImageTarget);

 	gc->SetPenColor(TRgb(100,100,100));

 	gc->DrawRect(TRect(0,0,30,30));

 	dgdiImageSource.Close();

 	sgImageSource.Close();

 	rsgImage.Close();

 	dgdiImageTarget.Close();

 	delete gc;

 	dgdiDriver->Close();

 	SgDriver::Close();

 	delete cleanupStack;

 	__UHEAP_MARKEND;

 	sem.Close();	

 	TInt procHandles2  =0;

 	TInt threadHandles2=0;

 	RThread().HandleCount(procHandles2,threadHandles2);

 	if (threadHandles1 != threadHandles2)

 		{

 		ret = KErrGeneral;  // Thread-owned handles not closed

 		}

 	return ret;

 	}