// 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;

	}