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

*/

#include "egltest_syncobject.h"

#include <test/tefunit.h>

#include <hal.h>

#include <test/egltestcommonsgimageinfo.h>

const TUint32  KThreshold = 0.5*1000*1000; // 0.5 sec

const TUint32  KDelaySignalling = 2.5*1000*1000; // 2.5 sec

const TUint32  KWaitSyncTimeout = 5*1000*1000; // 5 sec

const TUint32  KLongDelaySignalling = 7.5*1000*1000; // 7.5 sec

const TInt 	   KNumStressIterations = 1000;

typedef void 	(*TEglDebugHeapMarkStartPtr)		(void);

typedef EGLint	(*TEglDebugHeapMarkEndPtr)			(EGLint count);

typedef void	(*TEglDebugSetBurstAllocFailPtr)	(EGLenum type, EGLint rate, EGLint burst);

struct TSurfaceToDestroy

	{

	EGLSurface iSurface;

	EGLDisplay	iDisplay;

	};

//the function clean up surface resource. Needs to be push into cleanup stack beforehand

void DestroySurface(TAny* aAny)

	{

	TSurfaceToDestroy* surfaceToDestroy = (TSurfaceToDestroy*)aAny;

	eglDestroySurface(surfaceToDestroy->iDisplay, surfaceToDestroy->iSurface);

	}

CEglTest_SyncObject_Base::CEglTest_SyncObject_Base() : 

	iSyncObject(EGL_NO_SYNC_KHR), iSyncObject1(EGL_NO_SYNC_KHR), iSyncObject2(EGL_NO_SYNC_KHR), 

	iThreshold(KThreshold), iDelaySignalling(KDelaySignalling),

	iWaitSyncTimeout(KWaitSyncTimeout), iLongDelaySignalling(KLongDelaySignalling),

	iNumStressIterations(KNumStressIterations)

	{

	}

CEglTest_SyncObject_Base::~CEglTest_SyncObject_Base()

	{

	if(iPfnEglDestroySyncKHR)

	    {

	    iPfnEglDestroySyncKHR(iDisplay, iSyncObject);

	    iPfnEglDestroySyncKHR(iDisplay, iSyncObject1);

	    iPfnEglDestroySyncKHR(iDisplay, iSyncObject2);

	    }

	CleanAll();

	}

// from CTestStep

TVerdict CEglTest_SyncObject_Base::doTestStepPreambleL()

	{

	INFO_PRINTF1(_L("CEglTest_SyncObject_Base::doTestStepPreambleL()"));

	CEglTestStep::doTestStepPreambleL();

	TInt res = HAL::Get(HALData::ENanoTickPeriod, iTickPeriodMicroSeconds);

	if(res != KErrNone)

		{

		ERR_PRINTF2(_L("Can't retrieve tick period, err %d"), res);

		User::Leave(res);

		}

	INFO_PRINTF2(_L("Tick period in micro seconds %d"), iTickPeriodMicroSeconds);

	_LIT(KSectionSyncObject, "SyncObject");

	_LIT(KKeyThreshold, "Threshold");

	_LIT(KKeyDelaySignalling, "DelaySignalling");

	_LIT(KKeyWaitSyncTimeout, "WaitSyncTimeout");

	_LIT(KKeyLongDelaySignalling, "LongDelaySignalling");

	_LIT(KKeyNumStressIterations, "NumIterations");

	//retrive all setting from INI file

	GetIntFromConfig(KSectionSyncObject, KKeyThreshold, iThreshold);

	GetIntFromConfig(KSectionSyncObject, KKeyDelaySignalling, iDelaySignalling);

	GetIntFromConfig(KSectionSyncObject, KKeyWaitSyncTimeout, iWaitSyncTimeout);

	GetIntFromConfig(KSectionSyncObject, KKeyLongDelaySignalling, iLongDelaySignalling);

	GetIntFromConfig(KSectionSyncObject, KKeyNumStressIterations, iNumStressIterations);

	INFO_PRINTF2(_L("Level of tolerance %d"), iThreshold);

	INFO_PRINTF2(_L("Delay before the signal occurs  %d"), iDelaySignalling);

	INFO_PRINTF2(_L("Timeout client waits on sync object %d"), iWaitSyncTimeout);

	INFO_PRINTF2(_L("Long delay before signalling occurs %d"), iLongDelaySignalling);

	INFO_PRINTF2(_L("Number of iterations before stress test exits %d"), iNumStressIterations);

	INFO_PRINTF1(_L("Check if the Sync object Khronos extension is supported"));

	iIsSyncObjectExtensionSupported = CheckForExtensionL(KEGL_KHR_reusable_sync);

    INFO_PRINTF1(_L("Check if the Sync object private extension is supported"));

	iIsSyncObjectPrivateExtensionSupported = CheckForExtensionL(KEGL_NOK__private__signal_sync);

	CleanAll();

    TEST(GetProcAddress());

	INFO_PRINTF1(_L("End of CEglTest_SyncObject_Base::doTestStepPreambleL()"));

	return TestStepResult();

	}

void CEglTest_SyncObject_Base::CreateEglSessionL()

	{

	delete iEglSess; //just in case it was called twice

	iEglSess = CTestEglSession::NewL(Logger(), iDisplay, 0);

	}

void CEglTest_SyncObject_Base::CheckSyncAttrib(EGLint aAttribute, EGLint aExpectedValue)

	{

	EGLint value;

	EGLBoolean res = iPfnEglGetSyncAttribKHR(iDisplay,iSyncObject,aAttribute,&value);

	TEST(res == EGL_TRUE);

	TEST(value == aExpectedValue);

	switch(aAttribute)

		{

		case EGL_SYNC_TYPE_KHR:

			{

			if (value == EGL_SYNC_REUSABLE_KHR)

				{

				INFO_PRINTF1(_L("  EGL_SYNC_TYPE_KHR: EGL_SYNC_REUSABLE_KHR"));

				}

			else

				{

				ERR_PRINTF1(_L("  EGL_SYNC_TYPE_KHR: Invalid attribute"));

				}

			break;

			}

		case EGL_SYNC_STATUS_KHR:

			{

			if (value == EGL_SIGNALED_KHR)

				{

				INFO_PRINTF1(_L("  EGL_SYNC_STATUS_KHR: EGL_SIGNALED_KHR"));

				}

			else if (value == EGL_UNSIGNALED_KHR)

				{

				INFO_PRINTF1(_L("  EGL_SYNC_STATUS_KHR: EGL_UNSIGNALED_KHR"));

				}

			else

				{

				ERR_PRINTF1(_L("  EGL_SYNC_STATUS_KHR: Invalid attribute"));

				}

			break;

			}

		default:

			{

			ERR_PRINTF1(_L("  Invalid attribute"));

			}

		}

	}

/**

 Obtain extension functions for the sync object 

 */

TBool CEglTest_SyncObject_Base::GetProcAddress()

	{

    if(!iIsSyncObjectExtensionSupported)

        {

        INFO_PRINTF1(_L("Sync object extension is not defined in test INI file.\

The retrieval of the pointers to the extension sync object function will be skipped"));

        return ETrue;

        }

    //retrieve the pointers to the EGL sync object extension functions 

    INFO_PRINTF1(_L("retrieve the pointers to the EGL sync object extension functions"));

	iPfnEglCreateSyncKHR = reinterpret_cast <TFPtrEglCreateSyncKhr> (eglGetProcAddress("eglCreateSyncKHR"));

	iPfnEglDestroySyncKHR = reinterpret_cast <TFPtrEglDestroySyncKhr> (eglGetProcAddress("eglDestroySyncKHR"));

	iPfnEglClientWaitSyncKHR = reinterpret_cast <TFPtrEglClientWaitSyncKhr> (eglGetProcAddress("eglClientWaitSyncKHR"));

	iPfnEglSignalSyncKHR = reinterpret_cast <TFPtrEglSignalSyncKhr> (eglGetProcAddress("eglSignalSyncKHR"));

	iPfnEglGetSyncAttribKHR = reinterpret_cast <TFPtrEglGetSyncAttribKhr> (eglGetProcAddress("eglGetSyncAttribKHR"));

    if(iIsSyncObjectPrivateExtensionSupported)

        {

        iPfnEglPrivateSignalSyncNOK = reinterpret_cast <TFPtrEglPrivateSignalSyncNok> (eglGetProcAddress("egl_Private_SignalSyncNOK"));

        if(!iPfnEglPrivateSignalSyncNOK)

            {

            ERR_PRINTF1(_L("   Pointer to function \"egl_Private_SignalSyncNOK\" is not valid"));

            }

        }

	if(!iPfnEglCreateSyncKHR)

		{

		ERR_PRINTF1(_L("   Pointer to function \"eglCreateSyncKHR\" is not valid"));

		}

	if(!iPfnEglDestroySyncKHR)

		{

		ERR_PRINTF1(_L("   Pointer to function \"eglDestroySyncKHR\" is not valid"));

		}

	if(!iPfnEglClientWaitSyncKHR)

		{

		ERR_PRINTF1(_L("   Pointer to function \"eglClientWaitSyncKHR\" is not valid"));

		}

	if(!iPfnEglSignalSyncKHR)

		{

		ERR_PRINTF1(_L("   Pointer to function \"eglSignalSyncKHR\" is not valid"));

		}

	if(!iPfnEglGetSyncAttribKHR)

		{

		ERR_PRINTF1(_L("   Pointer to function \"eglGetSyncAttribKHR\" is not valid"));

		}

	if(!(iPfnEglCreateSyncKHR && iPfnEglDestroySyncKHR && iPfnEglClientWaitSyncKHR 

	        && iPfnEglSignalSyncKHR && iPfnEglGetSyncAttribKHR && 

	        (!iIsSyncObjectPrivateExtensionSupported || (iPfnEglPrivateSignalSyncNOK))))

		{//if the private extension is not declared in the test ini file, we won't signal the failure

		return EFalse;

		}

	return ETrue;

	}

void CEglTest_SyncObject_Base::CleanAll()

	{

	if(iEglSess)

		{

		delete iEglSess;

		iEglSess = NULL;

		}

	TRAPD(res, TerminateDisplayL());

	TEST(res == KErrNone);

	INFO_PRINTF2(_L("Display termination completed with error %d"), res);

	INFO_PRINTF1(_L("Main Thread: Calling eglReleaseThread()"));

	ASSERT_EGL_TRUE(eglReleaseThread())

	}

/**

@SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-001

@SYMTestPriority 1

@SYMPREQ 2400

@SYMREQ 12326

@SYMTestCaseDesc

To check that current implementation support EGL sync object extension

@SYMTestActions

1.	Request supporting extension for the existing display by calling eglQueryString(...) and passing EGL_EXTENSIONS as a second parameter.

2.	Obtain an EGL sync object extension functions by supplying the following procname to the function  void (*eglGetProcAddress(const char *procname)):

"eglCreateSyncKHR"

"eglDestroySyncKHR"

"eglClientWaitSyncKHR"

"eglSignalSyncKHR"

"eglGetSyncAttribKHR"

@SYMTestExpectedResults

1. The function must return a string which includes space separated sub-string "EGL_KHR_reusable_sync".

2. The pointer to the functions should be non zero.

*/

TVerdict CEglTest_SyncObject_Positive_GetProcAddress::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-001"));

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

   if(!iIsSyncObjectExtensionSupported)

        {

        INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed"));

        CleanAll();

        RecordTestResultL();

        CloseTMSGraphicsStep();

        return TestStepResult();

        }

	// check that extension "EGL_KHR_reusable_sync" is supported

	INFO_PRINTF1(_L("Check that extension \"EGL_KHR_reusable_sync\" is supported"));

	TEST(CheckForExtensionL(KEGL_KHR_reusable_sync));

	INFO_PRINTF1(_L("Obtain EGL sync object extension functions"));

	TEST(GetProcAddress());

	RecordTestResultL();

	CloseTMSGraphicsStep();

	INFO_PRINTF1(_L("End of CEglTest_SyncObject_Positive_GetProcAddress::doTestStepL"));

	return TestStepResult();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-005

@SYMTestPriority 1

@SYMPREQ 2400

@SYMREQ 12326

@SYMTestCaseDesc

To validate the creation and deletion of the sync object.

@SYMTestActions

1. Create sync object for the default display. NULL are specified in attribute_list. 

   The type parameter is set to EGL_SYNC_REUSABLE_KHR 

2. Retrieve the following attributes of the sync object: EGL_SYNC_TYPE_KHR , 

   EGL_SYNC_STATUS_KHR

3. Delete the sync object 

4. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). 

   The type parameter is set to EGL_SYNC_REUSABLE_KHR 

5. Retrieve the following attributes of the sync object: EGL_SYNC_TYPE_KHR , 

   EGL_SYNC_STATUS_KHR

6. Delete the sync object 

@SYMTestExpectedResults

1. Sync object handle doesn't equal to EGL_NO_SYNC_KHR 

2. Sync object attribute EGL_SYNC_STATUS_KHR should be set to EGL_UNSIGNALED_KHR by default,  

   attribute EGL_SYNC_TYPE_KHR should be set to EGL_SYNC_REUSABLE_KHR

4. Sync object handle doesn't equal to EGL_NO_SYNC_KHR 

5. Sync object attribute EGL_SYNC_STATUS_KHR should be set to EGL_UNSIGNALED_KHR by default,  

   attribute EGL_SYNC_TYPE_KHR should be set to EGL_SYNC_REUSABLE_KHR

 */

TVerdict CEglTest_SyncObject_Positive_CreateDestroy::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-005"));

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

	if(!iIsSyncObjectExtensionSupported)

		{

		INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed"));

		CleanAll();

		RecordTestResultL();

		CloseTMSGraphicsStep();

		return TestStepResult();

		}

	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

	GetDisplayL();

	CreateEglSessionL();

	iEglSess->InitializeL();

	INFO_PRINTF1(_L("Create sync object - default display, NULL at attributes, type parameter set to EGL_SYNC_REUSABLE_KHR"));

	iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, NULL);

	TESTL(iSyncObject != EGL_NO_SYNC_KHR);

	//check attributes of the sync object.

	INFO_PRINTF1(_L("Check attributes of sync object"));	

	CheckSyncAttrib(EGL_SYNC_TYPE_KHR, EGL_SYNC_REUSABLE_KHR);

	CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_UNSIGNALED_KHR);

	INFO_PRINTF1(_L("Delete sync object"));

	EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject);

	TEST(res == EGL_TRUE);

	INFO_PRINTF1(_L("Create sync object - default display, no attribute specified, type parameter set to EGL_SYNC_REUSABLE_KHR "));

	iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone);

	TESTL(iSyncObject != EGL_NO_SYNC_KHR);

	INFO_PRINTF1(_L("Check attributes"));

	CheckSyncAttrib(EGL_SYNC_TYPE_KHR, EGL_SYNC_REUSABLE_KHR);

	CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR);

	INFO_PRINTF1(_L("Delete sync object"));

	res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject);

	TEST(res == EGL_TRUE);

	CleanAll();

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-010

@SYMTestPriority 1

@SYMPREQ 2400

@SYMREQ 12326

@SYMTestCaseDesc

To check that transition from EGL_UNSIGNALED_KHR to EGL_SIGNALED_KHR state will trigger the signal and unblock the client thread  

@SYMTestActions

1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). 

   The type parameter is set to EGL_SYNC_REUSABLE_KHR  

2. Launch thread A

3. Wait on sync object by calling eglClientWaitSyncKHR  

4. Signal on the sync object from thread A with the flag EGL_SIGNALED_KHR

5. Retrieve EGL_SYNC_STATUS_KHR attribute

6. Delete the sync object

@SYMTestExpectedResults

3. The main thread is blocked

4. After the signal the main thread should be unblocked and the value returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR

5. Status attribute is set to EGL_SIGNALED_KHR

*/

TVerdict CEglTest_SyncObject_Positive_WaitSignal::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-010"));

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

	if(!iIsSyncObjectExtensionSupported)

		{

		INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed"));

		CleanAll();

		RecordTestResultL();

		CloseTMSGraphicsStep();

		return TestStepResult();

		}

	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

	GetDisplayL();

	CreateEglSessionL();

	iEglSess->InitializeL();

	//create sync object

	INFO_PRINTF1(_L("Create sync object"));

	iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone);

	TESTL(iSyncObject != EGL_NO_SYNC_KHR);

	//launch threadA

	Test_MultiThreadL(1, EFalse);

	//Stall the main thread

	TUint32 timestampBefore = User::NTickCount();	//microsecond

	EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR);

	TUint32 timestampAfter = User::NTickCount();

	TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore);

	INFO_PRINTF4(_L("Main thread waited on eglClientWaitSyncKHR for %d usec (threshold was [%d +- %d])"),timeElapsed, iDelaySignalling, iThreshold);

	TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR);

	TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold);

	INFO_PRINTF1(_L("Check attributes of sync object"));	

	CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR);

	INFO_PRINTF1(_L("Delete sync object"));

	EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject);

	TEST(res == EGL_TRUE);

	CleanAll();

	RecordTestResultL();

	CloseTMSGraphicsStep();

	return TestStepResult();

	}

void CEglTest_SyncObject_Positive_WaitSignal::doThreadFunctionL(TInt aIdx)

	{

	INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_WaitSignal::doThreadFunctionL, Thread %d"),aIdx);

	ASSERT_TRUE(aIdx==0);

	User::After(iDelaySignalling);

	INFO_PRINTF1(_L("signal sync object from thread A"));

	EGLBoolean res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_SIGNALED_KHR);

	TEST(res == EGL_TRUE);

	}

/**

@SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-015

@SYMTestPriority 1

@SYMPREQ 2400

@SYMREQ 12326

@SYMTestCaseDesc

To check that the client will not be blocked by waiting on the sync object 

if the latter is in EGL_SIGNALED_KHR state and will stay blocked until 

transition from unsignal to signal state occurs.

To check that eglSignalSyncKHR sets the state of the sync object correctly.

@SYMTestActions

1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). 

   The type parameter is set to EGL_SYNC_REUSABLE_KHR

2. Call eglSignalSyncKHR with EGL_SIGNALED_KHR as a parameter.

3. Retrieve an EGL_SYNC_STATUS_KHR attribute.

4. Try to wait on the sync object by calling eglClientWaitSyncKHR.

5. Call eglSignalSyncKHR with EGL_UNSIGNALED_KHR as a parameter.

6. Retrieve an EGL_SYNC_STATUS_KHR attribute. 

7. Launch thread A.

8. Waiting on the sync object by calling eglClientWaitSyncKHR.

9. From thread A call eglSignalSyncKHR with EGL_UNSIGNALED_KHR as a parameter. 

10. From thread A retrieve EGL_SYNC_STATUS_KHR attribute.

11. From thread A call eglSignalSyncKHR with EGL_SIGNALED_KHR as a parameter.

12. From thread A retrieve EGL_SYNC_STATUS_KHR attribute.

13  Delete the sync object.

@SYMTestExpectedResults

3. EGL_SYNC_STATUS_KHR attribute is set to EGL_SIGNALED_KHR

4. The thread is not blocked and an error code returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR

6. EGL_SYNC_STATUS_KHR attribute is set to EGL_UNSIGNALED_KHR

8. Main thread is blocked

9. Main thread stays blocked

10. EGL_SYNC_STATUS_KHR attribute is set to EGL_UNSIGNALED_KHR

11. Main thread is unblocked

12. EGL_SYNC_STATUS_KHR attribute is set to EGL_SIGNALED_KHR

*/

TVerdict CEglTest_SyncObject_Positive_WaitSignal2::doTestStepL()

	{

	SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-015"));

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

	if(!iIsSyncObjectExtensionSupported)

		{

		INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed"));

		CleanAll();

		RecordTestResultL();

		CloseTMSGraphicsStep();

		return TestStepResult();

		}

	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);

	GetDisplayL();

	CreateEglSessionL();

	iEglSess->InitializeL();

	INFO_PRINTF1(_L("Create sync object"));

	iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone);

	TESTL(iSyncObject != EGL_NO_SYNC_KHR);

	//set to signal state, basically we are not changing anything here 

	EGLBoolean res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_SIGNALED_KHR);

	TEST(res = EGL_TRUE);

	CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_SIGNALED_KHR);

	INFO_PRINTF1(_L("Try to wait on the sync object by calling eglClientWaitSyncKHR"));

	TUint32 timestampBefore = User::NTickCount();	//microsecond