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

//

/**

 @file

 @test

 @internalComponent - Graphics Resource API Conformance Test Suite

*/

#include "tgraphicsresourceteststepbase.h"

#include <e32math.h>

CTSgTestStepBase::CTSgTestStepBase(TBool aConformanceTests) :

	iEnableConformanceTests(aConformanceTests)

	{

	}

CTSgTestStepBase::~CTSgTestStepBase()

	{

	iSecondThread.Close();

	iPixelFormatArray.Close();

	User::Free(iDiagonalImageData);

	iSgDriver.Close();

	}

/**

Overrides of base class virtual

@leave Gets system wide error code

@return - TVerdict code

*/

TVerdict CTSgTestStepBase::doTestStepPreambleL()

	{

	// Set the logger to shared so that secondary threads can write to the log

	User::LeaveIfError(Logger().ShareAuto());	

	SetTestStepResult(EPass);

	iDiagonalImageData = static_cast<TUint32*>(User::AllocL(KDiagonalImageSize * KDiagonalImageDataStride));

	// Populate iDiagonalImageData with green diagonal from top-left to bottom-right on white background

	Mem::Fill(iDiagonalImageData, KDiagonalImageSize * KDiagonalImageDataStride, 0xFF);

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

		{

		iDiagonalImageData[i * (KDiagonalImageSize + 1)] = 0xFF00FF00;

		}

	return TestStepResult();

	}

/**

Override of base class virtual

@leave Gets system wide error code

@return - TVerdict code

*/

TVerdict CTSgTestStepBase::doTestStepPostambleL()

	{

	User::Free(iDiagonalImageData);

	iDiagonalImageData = NULL;

	return TestStepResult();

	}

/**

Creates an image with some predefined parameters.

@param aImage output image handle

@leave Gets system wide error code

*/

void CTSgTestStepBase::CreateImageL(RSgImage& aImage)

	{

	TSgImageInfo info;

	info.iSizeInPixels = TSize(8, 8);

	info.iUsage = ESgUsageBitOpenVgImage;

	info.iPixelFormat = EUidPixelFormatRGB_565;

	CheckErrorL(KErrNone, aImage.Create(info, KCrossImageData, KCrossImageDataStride), (TText8*)__FILE__, __LINE__);

	}

/**

Creates a second process and do some tests in it.

@param aProcessName The name of the new process

@param aTestInfo The information for the tests

@return A bitwise mask of test passes (never an error code)

@leave Gets system wide error code

*/

TInt CTSgTestStepBase::CreateSecondProcessAndDoTestL(const TDesC &aProcessName, TSgProcessTestInfo& aTestInfo)

	{

	// Create a second process

	RProcess process;

	TInt err = process.Create(aProcessName, KNullDesC);

	User::LeaveIfError(err);

	CleanupClosePushL(process);

	// Specify the id passed to the second process

	TPckg<TSgProcessTestInfo> ptr(aTestInfo);

	TESTL(KErrNone == process.SetParameter(KSecondProcessParametersSlot, ptr));

	// Kick off the second process and wait for it to complete

	// The actual testing is done in the second process

	TRequestStatus status = KRequestPending;

	process.Logon(status);

	process.Resume();

	User::WaitForRequest(status);

	// exitreason could either be a negative error code or a bitwise

	// mask of test passes.

	TInt exitreason = process.ExitReason();

	CleanupStack::PopAndDestroy();

	if (exitreason < KErrNone)

		{

		INFO_PRINTF2(_L("The second process returned error code %d"), exitreason);

		TEST(EFalse);

		exitreason = 0;

		}

	//return test result

	return exitreason;

	}

/**

Creates a second process, runs the requested test and ensures that

the specified panic occurs.

@param aTestInfo The specification for this test

@param aPanicCode The expected panic code

@param aExitCategory The expected panic category

@param aProcessName The name of the new process

@leave One of the system wide error codes

*/

void CTSgTestStepBase::CreateSecondProcessAndCheckPanicL(TSgProcessTestInfo& aTestInfo, TInt aPanicCode, TExitCategoryName aExitCategory, const TDesC &aProcessName)

	{

	// Create a second process

	RProcess process;

	User::LeaveIfError(process.Create(aProcessName, KNullDesC));

	CleanupClosePushL(process);

	// Specify the id passed to the second process

	TPckg<TSgProcessTestInfo> ptr(aTestInfo);

	TESTL(KErrNone == process.SetParameter(KSecondProcessParametersSlot, ptr));

	// Kick off the second process and wait for it to complete

	// The actual testing is done in the second process

	TRequestStatus status = KRequestPending;

	process.Logon(status);

	process.Resume();

	User::WaitForRequest(status);

	if(EExitPanic != process.ExitType())

		{

		ERR_PRINTF3(_L("Expected exit type: %d, Actual exit type: %d"), EExitPanic, process.ExitType());

		TEST(EFalse);

		}

	if(aPanicCode != process.ExitReason())

		{

		ERR_PRINTF3(_L("Expected panic code: %d, Actual panic code: %d"), aPanicCode, process.ExitReason());

		TEST(EFalse);

		}

	TExitCategoryName secondProcessExitCategory = process.ExitCategory();

	if(aExitCategory != secondProcessExitCategory)

		{

		ERR_PRINTF3(_L("Expected panic category: %S, Actual panic category: %S"), &aExitCategory, &secondProcessExitCategory);

		TEST(EFalse);

		}

	CleanupStack::PopAndDestroy();

	}

/**

Creates a second thread and do some tests in it.

@param aTestInfo The information for the tests

@leave Gets system wide error code

*/

TInt CTSgTestStepBase::CreateSecondThreadAndDoTestL(TSgThreadTestInfo aTestInfo)

	{

	//create a semaphore

	RSemaphore sem;

	User::LeaveIfError(sem.CreateGlobal(KSecondThreadSemaphore, 0, EOwnerThread));

	CleanupClosePushL(sem);

	aTestInfo.iTestStep = this;

	User::LeaveIfError(iSecondThread.Create(KSecondThread, SgTestSecondThread::ThreadStart, KDefaultStackSize, KSecondThreadMinHeapSize, KSecondThreadMaxHeapSize, &aTestInfo));

	// Launch second thread

	TRequestStatus statusSecondThread;

	iSecondThread.Logon(statusSecondThread);

	iSecondThread.SetPriority(EPriorityLess);

	iSecondThread.Resume();	

	User::WaitForRequest(statusSecondThread);

	TExitCategoryName exitCategory = iSecondThread.ExitCategory();

	if (exitCategory.Compare(_L("Kill")) != 0)

		{

		ERR_PRINTF2(_L("Second thread terminated with reason category '%S'"), &exitCategory);

		SetTestStepResult(EFail);

		}

	TInt result = iSecondThread.ExitReason();

	//Close the handle

	CleanupStack::PopAndDestroy(1, &sem);

	iSecondThread.Close();

	return result;

	}

/**

Creates a second thread and do some panic tests in it.

@param aTestInfo The information for the tests

@param aPanicCode The expected panic code

@param aExitCategory The expected panic category

@param aThreadName The name of the new thread

@leave Gets system wide error code

*/

void CTSgTestStepBase::CreateSecondThreadAndCheckPanicL(TSgThreadTestInfo aTestInfo, TInt aPanicCode, TExitCategoryName aExitCategory, const TDesC &aThreadName)

	{

	aTestInfo.iTestStep = this;

	User::LeaveIfError(iSecondThread.Create(aThreadName, SgTestSecondThread::ThreadStart, KDefaultStackSize, KSecondThreadMinHeapSize, KSecondThreadMaxHeapSize, &aTestInfo));

	// Launch second thread

	TRequestStatus statusSecondThread;

	iSecondThread.Logon(statusSecondThread);

	iSecondThread.SetPriority(EPriorityLess);

	iSecondThread.Resume();	

	User::WaitForRequest(statusSecondThread);

	if(EExitPanic != iSecondThread.ExitType())

		{

		ERR_PRINTF3(_L("Expected exit type: %d, Actual exit type: %d"), EExitPanic, iSecondThread.ExitType());

		TEST(EFalse);

		}

	if(aPanicCode != iSecondThread.ExitReason())

		{

		ERR_PRINTF3(_L("Expected panic code: %d, Actual panic code: %d"), aPanicCode, iSecondThread.ExitReason());

		TEST(EFalse);

		}

	TExitCategoryName secondThreadExitCategory = iSecondThread.ExitCategory();

	if(aExitCategory != secondThreadExitCategory)

		{

		ERR_PRINTF3(_L("Expected panic category: %S, Actual panic category: %S"), &aExitCategory, &secondThreadExitCategory);

		TEST(EFalse);

		}

	//Close the handle

	iSecondThread.Close();

	}

/**

Gets the supporting pixel formats according to the specified usage bit.

@leave Gets system wide error code

*/

void CTSgTestStepBase::CallGetPixelFormatsL(TUint32 aUsage)

	{

	iPixelFormatArray.Reset();

	CheckErrorL(KErrNone, RSgImage::GetPixelFormats(aUsage, iPixelFormatArray), (TText8*)__FILE__, __LINE__);

	}

/**

Checks the pixel formats returned against the compatibility guarantee table.

@leave Gets system wide error code

*/

void CTSgTestStepBase::TestGetPixelFormatCompatibilityGuaranteesL()

	{

	_LIT(KLibOpenGLES2, "libGLESv2.dll");

	RLibrary lib;

	TBool supportGLES2 = (lib.Load(KLibOpenGLES2) == KErrNone);

	lib.Close();

	// OpenVG - Mandatory support

	CallGetPixelFormatsL(ESgUsageBitOpenVgImage);

	TEST(CheckPixelFormatPresent(ESgPixelFormatARGB_8888_PRE));

	TEST(CheckPixelFormatPresent(ESgPixelFormatARGB_8888));

	TEST(CheckPixelFormatPresent(ESgPixelFormatXRGB_8888));

	TEST(CheckPixelFormatPresent(ESgPixelFormatRGB_565));

	TEST(CheckPixelFormatPresent(ESgPixelFormatA_8));

	CallGetPixelFormatsL(ESgUsageBitOpenVgSurface);

	TEST(CheckPixelFormatPresent(ESgPixelFormatARGB_8888_PRE));

	TEST(CheckPixelFormatPresent(ESgPixelFormatXRGB_8888));

	TEST(CheckPixelFormatPresent(ESgPixelFormatRGB_565));

	// OpenGL ES - Not mandatory, but should cause no errors. 

	CallGetPixelFormatsL(ESgUsageBitOpenGlesTexture2D);

	CallGetPixelFormatsL(ESgUsageBitOpenGlesSurface);

	// OpenGL ES 2 - Mandatory if present.

	CallGetPixelFormatsL(ESgUsageBitOpenGles2Texture2D);

	if (supportGLES2)

	    {

        TEST(CheckPixelFormatPresent(ESgPixelFormatARGB_8888_PRE));

        TEST(CheckPixelFormatPresent(ESgPixelFormatARGB_8888));

        TEST(CheckPixelFormatPresent(ESgPixelFormatXRGB_8888));

        TEST(CheckPixelFormatPresent(ESgPixelFormatRGB_565));

        TEST(CheckPixelFormatPresent(ESgPixelFormatA_8));

	    }

	CallGetPixelFormatsL(ESgUsageBitOpenGles2Surface);

	if (supportGLES2)

	    {

	    TEST(CheckPixelFormatPresent(ESgPixelFormatARGB_8888_PRE));

	    TEST(CheckPixelFormatPresent(ESgPixelFormatXRGB_8888));

	    TEST(CheckPixelFormatPresent(ESgPixelFormatRGB_565));

	    }

	iPixelFormatArray.Reset();

	}

/**

Helper function to check if a certain pixel format is present

in the pixel formats array retrieved by CallGetPixelFormatsL().

@param aPixelFormat The pixelformat to check

@return ETrue if the pixel format is present, otherwise EFalse

@see CTsgTestStepBase::CallGetPixelFormats()

*/

TBool CTSgTestStepBase::CheckPixelFormatPresent(TSgPixelFormat aPixelFormat)

	{

	for(TInt i=0; i<iPixelFormatArray.Count(); ++i)

		{		

		if(aPixelFormat == iPixelFormatArray[i])

			{

			return ETrue;

			}

		}

	return EFalse;

	}

/**

Helper function to test the equivalence of two TSgImageInfo structures.

@see     CTDirectGdiContextTarget::CompareInfos

@param   aInfo1 A TSgImageInfo structure to compare.

@param   aInfo2 A TSgImageInfo structure to compare.

@return  ETrue if the two are identical, EFalse otherwise.

*/

TBool CTSgTestStepBase::CompareInfos(TSgImageInfo& aInfo1, TSgImageInfo& aInfo2)

	{

	return (aInfo1.iPixelFormat == aInfo2.iPixelFormat

		&& aInfo1.iSizeInPixels == aInfo2.iSizeInPixels

		&& aInfo1.iUsage == aInfo2.iUsage);

	}

/**

Wrapper function to open the graphics resource driver.

Only opens the driver if the test step has been constructed for use

as the conformance tests.

@leave One of the system wide error codes

*/

void CTSgTestStepBase::TestOpenDriverL()

	{

	if (iEnableConformanceTests)

		CheckErrorL(KErrNone, iSgDriver.Open(), (TText8*)__FILE__, __LINE__);

	}

/**

Wrapper function to close the graphics resource driver.

Only closes the driver if the test step has been constructed for use

as the conformance tests.

*/

void CTSgTestStepBase::TestCloseDriver()

	{

	if (iEnableConformanceTests)

		iSgDriver.Close();

	}

/**

Creates an image with specified parameters.

@param aImage output image handle

@return KErrNone if the image was created successfully, otherwise one of the system-wide error codes

*/

TInt CreateImageWithParameters(TInt aWidth, TInt aHeight, TUidPixelFormat aPixelFormat, TUint32 aUsage, RSgImage& aImage)

	{

	TSgImageInfo info;

	info.iSizeInPixels = TSize(aWidth, aHeight);

	info.iPixelFormat = aPixelFormat;

	info.iUsage = aUsage;

	return aImage.Create(info, NULL, 0);

	}

/**

Second thread entry function.

*/

TInt SgTestSecondThread::ThreadStart(TAny* aInfo)

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if (!cleanupStack)

		{

		return KErrNoMemory;

		}

	TSgThreadTestInfo* testInfo = static_cast<TSgThreadTestInfo*>(aInfo);

	RSemaphore sem;

	TInt openSem = sem.OpenGlobal(KSecondThreadSemaphore, EOwnerThread);

	TInt result = KErrNone;

	TRAPD(leaveCode, result = SgTestSecondThread::ThreadMainL(testInfo));

	if (KErrNone == openSem)

		{

		sem.Signal();

		}

	sem.Close();

	if (leaveCode != KErrNone)

		{

		testInfo->iTestStep->ERR_PRINTF2(_L("Second thread caused Leave (%d)"), leaveCode);

		testInfo->iTestStep->SetTestStepResult(EFail);

		result = leaveCode;

		}

	delete cleanupStack;

	__UHEAP_MARKEND;

	return result;

	}

/**

Run the test contained within the TSgresTestInfo object. A new thread is

created for each test and only one of the cases in the switch statements

below will be used.

The first switch statement contains tests that must have no driver open,

the second set require an open driver to initiate the test but may

close it part way through.

@param aInfo The parameters for the test

@return One of the system wide error codes or an enumeration of passed tests.

 */

TInt SgTestSecondThread::ThreadMainL(TSgThreadTestInfo* aInfo)

	{

	TInt result = 0;

	TSgresTestCase testcase = ((TSgThreadTestInfo*)aInfo)->iTestCase;

	RSgDriver driver;

	CleanupClosePushL(driver);

	TInt ret = driver.Open();

	if(KErrNoMemory == ret)

		{

		return KErrNoMemory;

		}

	//test cases without the need of an initialised driver

	switch (testcase)

	{

	case ESgresSecondThreadPanicDrawableOpenNoDriver:

		{

		driver.Close();

		RSgDrawable drawable;

		drawable.Open(KFakeSgDrawableId); // should panic with SGRES 1

		}

		break;

	case ESgresSecondThreadPanicImageOpenNoDriver:

		{

		driver.Close();

		RSgImage image;

		image.Open(KFakeSgDrawableId); // should panic with SGRES 1

		image.Close();

		}

	case ESgresSecondThreadPanicImageCreateNoDriver1:

		{

		driver.Close();

		RSgImage image;

		image.Create(KSgImageInfo1, NULL, 0); // should panic with SGRES 1

		image.Close();

		}

		break;

	case ESgresSecondThreadPanicImageCreateNoDriver2:

		{

		driver.Close();

		RSgImage image;

		RSgImage tempImage;

		image.Create(KSgImageInfo1, tempImage); // should panic with SGRES 1

		image.Close();

		}

		break;

	case ESgresSecondThreadOpenImage:

		result = OpenImage(((TSgThreadTestInfo*)aInfo), driver);

		break;

	case ESgresSecondThreadOpenDrawable:

		result = OpenDrawable(((TSgThreadTestInfo*)aInfo));

		break;

	case ESgresSecondThreadOpenImageInvalid:

		result = OpenImageInvalid(((TSgThreadTestInfo*)aInfo));

		break;

	case ESgresSecondThreadOpenDrawableInvalid: 

		result = OpenDrawableInvalid(((TSgThreadTestInfo*)aInfo));

		break;

	case ESgresSecondThreadPanicImageGetInterfaceInvalidHandle:

		result = PanicImageGetInterfaceInvalidHandle(driver);

		break;

	case ESgresSecondThreadPanicImageGetInterfaceNoDriver:

		result = PanicImageGetInterfaceNoDriver(driver);

		break;

	case ESgresSecondThreadPanicImageCloseInvalidHandle:

		result = PanicImageCloseInvalidHandle(driver);

		break;

	case ESgresSecondThreadPanicImageCloseNoDriver:

		result = PanicImageCloseNoDriver(driver);

		break;

	case ESgresSecondThreadPanicImageIdInvalidHandle:

		result = PanicImageIdInvalidHandle(driver);

		break;

	case ESgresSecondThreadPanicImageIdNoDriver:

		result = PanicImageIdNoDriver(driver);

		break;

	case ESgresSecondThreadPanicImageDrawableTypeInvalidHandle:

		result = PanicImageDrawableTypeInvalidHandle(driver);

		break;

	case ESgresSecondThreadPanicImageDrawableTypeNoDriver:

		result = PanicImageDrawableTypeNoDriver(driver);

		break;