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

*/

#ifndef __INIPARSER_H__

#include <cinidata.h>

#endif // __INIPARSER_H__

#include <test/tefunit.h> // for ASSERT macros

#include "egltest_nativepixmaptype.h"

#include <test/egltestcommonconversion.h>

#include <test/egltestcommoninisettings.h>

/**

@SYMTestCaseID GRAPHICS-EGL-0015

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

Checks the single threaded usage of a Pixmap<RSgImage>

@SYMTestActions

Call eglInitialize()

Use a Pixmap<RSgImage>

@SYMTestExpectedResults

Use of Pixmap<RSgImage> succeeds

*/

TVerdict CEglTest_NativePixmapType_SingleThread_Positive_RSgImage::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-0015"));

	INFO_PRINTF1(_L("CEglTest_NativePixmapType_SingleThread_Positive_RSgImage::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);

	if(!ret)

		{

		// The extension is not supported

		RecordTestResultL();

		CloseTMSGraphicsStep();

		return TestStepResult();

		}

	// Create display object

	GetDisplayL();

	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, 0);

	eglSess->InitializeL();

	// Try to create and use an RSgImage pixmap

	eglSess->TryUsePixmapRSgImageL();

	CleanupStack::PopAndDestroy(eglSess);

	TerminateDisplayL();

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0028

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

These tests check usage of a Pixmap<RSgImage> within two threads.

@SYMTestActions

Execute threads A and B in the following order

A: Call eglInitialize()

B: Call eglInitialize()

-----

A: Use Pixmap<RSgImage>

B: Use Pixmap<RSgImage>

@SYMTestExpectedResults

Use_Pixmap<RSgImage> succeeds for both threads

*/

TVerdict CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-0028"));

	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);

	if(ret)

		{

		Test_MultiThreadL(2, ETrue);

		TerminateDisplayL();

		}

	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doTestStepL"));

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doThreadFunctionL(TInt aIdx)

	{

	INFO_PRINTF2(_L("thread %d: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doThreadFunctionL"), aIdx);

	GetDisplayL();

	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

	eglSess->InitializeL();

	Rendezvous(aIdx);

	eglSess->TryUsePixmapRSgImageL();

	CleanupStack::PopAndDestroy(eglSess);

	INFO_PRINTF2(_L("thread %d: Exit CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice::doThreadFunctionL"), aIdx);

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0029

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

These tests check usage of a Pixmap<RSgImage> within two threads.

Threads are indipendent (no rendezvous).

@SYMTestActions

Execute threads A and B in the following order

A: Call eglInitialize()

B: Call eglInitialize()

-----

A: Use Pixmap<RSgImage>

B: Use Pixmap<RSgImage>

@SYMTestExpectedResults

Use_Pixmap<RSgImage> succeeds for both threads

*/

TVerdict CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-0029"));

	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);

	if(ret)

		{

		Test_MultiThreadL(2, ETrue);

		TerminateDisplayL();

		}

	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doTestStepL"));

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doThreadFunctionL(TInt aIdx)

	{

	INFO_PRINTF2(_L("thread %d: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doThreadFunctionL"), aIdx);

	GetDisplayL();

	//first check if the extension is present

	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);	

	eglSess->InitializeL();

	eglSess->TryUsePixmapRSgImageL();

	CleanupStack::PopAndDestroy(eglSess);

	INFO_PRINTF2(_L("thread %d: Exit CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitTwice_NoRendezvous::doThreadFunctionL"), aIdx);

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0030

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

These test checks that one call to eglInitialize per process is sufficient.

Both threads use a Pixmap<RSgImage> 

@SYMTestActions

Execute threads A and B in the following order

A: Call eglInitialize()

B: <no initialisation>

-----

A: Use Pixmap<RSgImage>

B: Use Pixmap<RSgImage>

@SYMTestExpectedResults

Use_Pixmap<RSgImage> succeeds for both threads

*/

TVerdict CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-0030"));

	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);

	if(ret)

		{

		Test_MultiThreadL(2, ETrue);

		TerminateDisplayL();

		}

	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doTestStepL"));

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doThreadFunctionL(TInt aIdx)

	{

	INFO_PRINTF2(_L("thread %d: CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doThreadFunctionL"), aIdx);

	GetDisplayL();

	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

	if (aIdx == 0)

		{

		eglSess->InitializeL();

		}

	Rendezvous(aIdx);

	if (aIdx == 1)

		{

		INFO_PRINTF2(_L("thread %d: skipping initialisation"), aIdx);

		}

	Rendezvous(aIdx);

	eglSess->TryUsePixmapRSgImageL();

	CleanupStack::PopAndDestroy(eglSess);

	INFO_PRINTF2(_L("thread %d: Exit CEglTest_NativePixmapType_MultiThread_Positive_RSgImage_InitOneThreadOnly::doThreadFunctionL"), aIdx);

	}

// MultiProcess tests

/**

@SYMTestCaseID GRAPHICS-EGL-0041

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

These tests check usage of a Pixmap<RSgImage> within two processes.

@SYMTestActions

Execute processes A and B in the following order

A: Call eglInitialize()

B: Call eglInitialize()

-----

A: Use_Pixmap<RSgImage>

B: Use_Pixmap<RSgImage>

@SYMTestExpectedResults

Use_Pixmap<RSgImage> should succeed for both processes

*/

TVerdict CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doTestStepL()

	{

    SetTestStepID(_L("GRAPHICS-EGL-0041"));

	INFO_PRINTF1(_L("CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doTestStepL"));

	// First check whether RSgImage is supported

	TBool ret = CheckForExtensionL(KEGL_RSgimage);

	if(ret)

		{

		// Now run the multiprocess test - each process can safely assume that RSgImage support is available.

		Test_MultiProcessL(KEglTestStepDllName, 2, KNativePixmapType_MultiProcess_Both_RSgImage);

		}

	INFO_PRINTF1(_L("Exit: CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doTestStepL"));

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doProcessFunctionL(TInt aIdx)

	{

	INFO_PRINTF2(_L("process %d: CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doProcessFunctionL"), aIdx);

	// Create display object

	GetDisplayL();

	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, aIdx);

	// Initialize the thread

	eglSess->InitializeL();

	// Rendezvous: ensure that both threads get to this point before continuing

	Rendezvous(aIdx);	

	// Try to create and use an RSgImage pixmap

	INFO_PRINTF2(_L("process %d: Calling TryUsePixmapRSgImageL..."), aIdx);

	eglSess->TryUsePixmapRSgImageL();

	CleanupStack::PopAndDestroy(eglSess);

	TerminateDisplayL();

	INFO_PRINTF2(_L("process %d: Exit CEglTest_NativePixmapType_MultiProcess_Both_RSgImage::doThreadFunctionL"), aIdx);

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0044

@SYMTestPriority 1

@SYMPREQ 39

@SYMREQ See SGL.GT0386.401 document

@SYMTestCaseDesc

Ensure that when asking for an EGLconfig via eglChooseConfig

passing an RSgImage with given iUsage and iPixelFormat attributes,

just the matching configs are returned.

@SYMTestActions

Fully construct an RSgImage setting iUsage and/or iPixelFormat

Loop through different values of iUsage and iPixelFormat and change RSgImage attributes accordingly

•	Query all the configs available on the display calling eglGetConfigs.

•	Loop through the possible configs and manually check how many they are and save their index.

•	Call eglChooseConfig() having in the attrib_list the attribute EGL MATCH NATIVE PIXMAP set as the handle to the RSgImage previously created.

•	Check if the number of the returned matching config is equal to the one manually checked earlier. Check if the returned configs are actually the same.

End Loop

Destroy the RSgImage object

@SYMTestExpectedResults

Returned Configs have to be the ones expected.

The values that iPixelFormat have to assume are:

•	EUidPixelFormatRGB_565

•	EUidPixelFormatXRGB_8888

•	EUidPixelFormatARGB_8888_PRE

It’s not possible to test any other pixel formats (such as 

EUidPixelFormatARGB_8888) because it is not allowed to create an RSgImage 

with that pixel format and iUsage bit saying that it is going to be used 

as a target.

The values that iUsage have to assume are:

•   ESgUsageBitOpenVgSurface

•   ESgUsageBitOpenGles2Surface

•	ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Surface

•	ESgUsageBitOpenVgImage

If OpenGLES2 is not supported creation of the SgImage is expected to fail 

with KErrNotSupported error code.

*/

TVerdict CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-0044"));

	INFO_PRINTF1(_L("CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestStepL"));

	TBool ret = CheckForExtensionL(KEGL_RSgimage);

	if(!ret)

		{

		// The extension is not supported

		RecordTestResultL();

		CloseTMSGraphicsStep();

		return TestStepResult();

		}

	// Create display object

	GetDisplayL();

	CreateEglSessionL();

	iEglSess->InitializeL();

	iEglSess->OpenSgDriverL();

	CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();

	CleanupStack::PushL(iniParser);

	TInt numRSgImageTargetFormats = iniParser->GetNumberOfFormats(KSectionPixmapSgSurfaceFormats);

	if(!numRSgImageTargetFormats)

		{

		ERR_PRINTF1(_L("No formats to iterate through!"));

		User::Leave(KErrArgument);		

		}

	TBool isGles2Supported = iEglSess->IsOpenGLES2Supported();

	for(TUint i=0; i < numRSgImageTargetFormats; i++)

		{

		//We are running thorugh all the possible "target" configurations because

		//they have one allowed pixel format less than the source has

		//so this test is expected to fail for EUidPixelFormatARGB_8888

		iSurfaceFormat			= iniParser->GetVgFormat(KSectionPixmapSgSurfaceFormats,i);

		iSourceFormat 			= EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		INFO_PRINTF1(_L("Trying usage bit ESgUsageBitOpenVgSurface"));

		iSgImageSurfaceUsage 	= ESgUsageBitOpenVgSurface;

#else

		INFO_PRINTF1(_L("Trying usage bit ESgUsageOpenVgTarget"));

		iSgImageSurfaceUsage 	= ESgUsageOpenVgTarget;

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		doTestPartialStepL();

		//if OpenGLES2 is not supported we must not succeed in creating SgImage

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		INFO_PRINTF1(_L("Trying usage bit ESgUsageVitOpenGles2Surface"));

		iSgImageSurfaceUsage    = ESgUsageBitOpenGles2Surface; 

		TRAPD(res, doTestPartialStepL());

		TESTL(res == (isGles2Supported ? KErrNone : KErrTEFUnitFail));

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		//if OpenGLES2 is not supported we must not succeed in creating SgImage

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		INFO_PRINTF1(_L("Trying usage bit ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Surface"));

		iSgImageSurfaceUsage 	= ESgUsageBitOpenVgSurface | ESgUsageBitOpenGles2Surface; 

		TRAP(res, doTestPartialStepL());

		TESTL(res == (isGles2Supported ? KErrNone : KErrTEFUnitFail));

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		INFO_PRINTF1(_L("Trying usage bit ESgUsageBitOpenVgImage"));

		iSgImageSurfaceUsage 	= ESgUsageBitOpenVgImage;

#else

		INFO_PRINTF1(_L("Trying usage bit ESgUsageOpenVgImage"));

		iSgImageSurfaceUsage 	= ESgUsageOpenVgImage;

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

		doTestPartialStepL();

		}

	CleanupStack::PopAndDestroy(iniParser);

	CleanAll();

    RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

TVerdict CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestPartialStepL()

	{

	INFO_PRINTF1(_L("CEglTest_ChooseConfig_EGL_MATCH_NATIVE_PIXMAP_KHR::doTestPartialStepL"));

	PrintUsedPixelConfiguration();

	//Creating one RSgImage containing reference bitmap's contents

	INFO_PRINTF1(_L("Creating one RSgImage"));

	RSgImage sgImage;

	CleanupClosePushL(sgImage);

	TUidPixelFormat pixelFormat = EglTestConversion::VgFormatToSgPixelFormat(iSurfaceFormat);

	TSgImageInfo imageInfo;

	imageInfo.iSizeInPixels = KPixmapSize;

	imageInfo.iPixelFormat = pixelFormat;

	imageInfo.iUsage = iSgImageSurfaceUsage;

	// Create a reference bitmap which we use to init the SgImage (we use index=4)

	TDisplayMode bitmapMode = EglTestConversion::VgFormatToDisplayMode(iSurfaceFormat);

	CFbsBitmap* bitmap = iEglSess->CreateReferenceBitmapL(bitmapMode, 4);

	CleanupStack::PushL(bitmap);	

	ASSERT_EQUALS(sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride()), KErrNone);

	CleanupStack::PopAndDestroy(bitmap);

	bitmap = NULL;

	//create bitmap for further use

    bitmap = new (ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    TSgImageInfo requestedImageInfo;

    sgImage.GetInfo(requestedImageInfo);

    TDisplayMode displayMode = EglTestConversion::PixelFormatToDisplayMode((TUidPixelFormat) (requestedImageInfo.iPixelFormat));

    TESTL(bitmap->Create(requestedImageInfo.iSizeInPixels, displayMode) == KErrNone);

	//Query all the config available on the display

	INFO_PRINTF1(_L("Calling eglGetConfigs, querying for the configs' number available on this display"));

	EGLint numConfigs;

	eglGetConfigs(iDisplay,NULL,0,&numConfigs);

	if(!numConfigs)

		{

		ERR_PRINTF1(_L("No available configs!"));

		CleanAll();

		User::Leave(KErrTEFUnitFail);

		}	

	//allocate a array to store all these configs and retrieve all the IDs	

	INFO_PRINTF2(_L("There are %d configs available on this display"),numConfigs);

	EGLConfig* configs = new(ELeave) EGLConfig[numConfigs];

	CleanupStack::PushL(configs);

	INFO_PRINTF1(_L("Calling eglGetConfigs, querying for all configs available on this display"));

	ASSERT_EGL_TRUE(eglGetConfigs(iDisplay,configs,KMaxEglConfigs,&numConfigs));		

	//"manually check" if a config is compatible with this RSgImage

    RArray<EGLint> compatibleConfigsIdsArray;

    CleanupClosePushL(compatibleConfigsIdsArray);

    RArray<EGLConfig> compatibleConfigsHandleArray;

    CleanupClosePushL(compatibleConfigsHandleArray);

  	for(TUint i=0;i<numConfigs;i++)

		{

		if(GetEglSess()->IsACompatibleConfig(configs[i],sgImage,EFalse))

			{

			compatibleConfigsHandleArray.AppendL(configs[i]);

			EGLint configID = 0;

			eglGetConfigAttrib(iDisplay, configs[i], EGL_CONFIG_ID, &configID);

			compatibleConfigsIdsArray.Append(configID);

            VERBOSE_INFO_PRINTF2(_L("Config %d is compatible"), configs[i]);

			}

		}

    const TInt numCompatibleConfigs = compatibleConfigsIdsArray.Count();