sl@0: // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). sl@0: // All rights reserved. sl@0: // This component and the accompanying materials are made available sl@0: // under the terms of "Eclipse Public License v1.0" sl@0: // which accompanies this distribution, and is available sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: // sl@0: // Initial Contributors: sl@0: // Nokia Corporation - initial contribution. sl@0: // sl@0: // Contributors: sl@0: // sl@0: // Description: sl@0: // sl@0: sl@0: /** sl@0: @file sl@0: @test sl@0: */ sl@0: #include "egltest_syncobject.h" sl@0: #include sl@0: #include sl@0: #include sl@0: sl@0: const TUint32 KThreshold = 0.5*1000*1000; // 0.5 sec sl@0: const TUint32 KDelaySignalling = 2.5*1000*1000; // 2.5 sec sl@0: const TUint32 KWaitSyncTimeout = 5*1000*1000; // 5 sec sl@0: const TUint32 KLongDelaySignalling = 7.5*1000*1000; // 7.5 sec sl@0: const TInt KNumStressIterations = 1000; sl@0: sl@0: typedef void (*TEglDebugHeapMarkStartPtr) (void); sl@0: typedef EGLint (*TEglDebugHeapMarkEndPtr) (EGLint count); sl@0: typedef void (*TEglDebugSetBurstAllocFailPtr) (EGLenum type, EGLint rate, EGLint burst); sl@0: sl@0: struct TSurfaceToDestroy sl@0: { sl@0: EGLSurface iSurface; sl@0: EGLDisplay iDisplay; sl@0: }; sl@0: sl@0: //the function clean up surface resource. Needs to be push into cleanup stack beforehand sl@0: void DestroySurface(TAny* aAny) sl@0: { sl@0: TSurfaceToDestroy* surfaceToDestroy = (TSurfaceToDestroy*)aAny; sl@0: eglDestroySurface(surfaceToDestroy->iDisplay, surfaceToDestroy->iSurface); sl@0: } sl@0: sl@0: CEglTest_SyncObject_Base::CEglTest_SyncObject_Base() : sl@0: iSyncObject(EGL_NO_SYNC_KHR), iSyncObject1(EGL_NO_SYNC_KHR), iSyncObject2(EGL_NO_SYNC_KHR), sl@0: iThreshold(KThreshold), iDelaySignalling(KDelaySignalling), sl@0: iWaitSyncTimeout(KWaitSyncTimeout), iLongDelaySignalling(KLongDelaySignalling), sl@0: iNumStressIterations(KNumStressIterations) sl@0: { sl@0: } sl@0: sl@0: CEglTest_SyncObject_Base::~CEglTest_SyncObject_Base() sl@0: { sl@0: if(iPfnEglDestroySyncKHR) sl@0: { sl@0: iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: iPfnEglDestroySyncKHR(iDisplay, iSyncObject1); sl@0: iPfnEglDestroySyncKHR(iDisplay, iSyncObject2); sl@0: } sl@0: CleanAll(); sl@0: } sl@0: sl@0: // from CTestStep sl@0: TVerdict CEglTest_SyncObject_Base::doTestStepPreambleL() sl@0: { sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Base::doTestStepPreambleL()")); sl@0: CEglTestStep::doTestStepPreambleL(); sl@0: TInt res = HAL::Get(HALData::ENanoTickPeriod, iTickPeriodMicroSeconds); sl@0: if(res != KErrNone) sl@0: { sl@0: ERR_PRINTF2(_L("Can't retrieve tick period, err %d"), res); sl@0: User::Leave(res); sl@0: } sl@0: INFO_PRINTF2(_L("Tick period in micro seconds %d"), iTickPeriodMicroSeconds); sl@0: sl@0: _LIT(KKeyThreshold, "Threshold"); sl@0: _LIT(KKeyDelaySignalling, "DelaySignalling"); sl@0: _LIT(KKeyWaitSyncTimeout, "WaitSyncTimeout"); sl@0: _LIT(KKeyLongDelaySignalling, "LongDelaySignalling"); sl@0: _LIT(KKeyNumStressIterations, "NumIterations"); sl@0: sl@0: //retrive all setting from INI file sl@0: GetIntFromConfig(ConfigSection(), KKeyThreshold, iThreshold); sl@0: GetIntFromConfig(ConfigSection(), KKeyDelaySignalling, iDelaySignalling); sl@0: GetIntFromConfig(ConfigSection(), KKeyWaitSyncTimeout, iWaitSyncTimeout); sl@0: GetIntFromConfig(ConfigSection(), KKeyLongDelaySignalling, iLongDelaySignalling); sl@0: GetIntFromConfig(ConfigSection(), KKeyNumStressIterations, iNumStressIterations); sl@0: sl@0: INFO_PRINTF2(_L("Level of tolerance %d"), iThreshold); sl@0: INFO_PRINTF2(_L("Delay before the signal occurs %d"), iDelaySignalling); sl@0: INFO_PRINTF2(_L("Timeout client waits on sync object %d"), iWaitSyncTimeout); sl@0: INFO_PRINTF2(_L("Long delay before signalling occurs %d"), iLongDelaySignalling); sl@0: INFO_PRINTF2(_L("Number of iterations before stress test exits %d"), iNumStressIterations); sl@0: sl@0: INFO_PRINTF1(_L("Check if the Sync object Khronos extension is supported")); sl@0: iIsSyncObjectExtensionSupported = CheckForExtensionL(KEGL_KHR_reusable_sync); sl@0: sl@0: INFO_PRINTF1(_L("Check if the Sync object private extension is supported")); sl@0: iIsSyncObjectPrivateExtensionSupported = CheckForExtensionL(KEGL_NOK__private__signal_sync); sl@0: sl@0: CleanAll(); sl@0: TEST(GetProcAddress()); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Base::doTestStepPreambleL()")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Base::CreateEglSessionL() sl@0: { sl@0: delete iEglSess; //just in case it was called twice sl@0: iEglSess = CTestEglSession::NewL(Logger(), iDisplay, 0); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Base::CheckSyncAttrib(EGLint aAttribute, EGLint aExpectedValue) sl@0: { sl@0: EGLint value; sl@0: EGLBoolean res = iPfnEglGetSyncAttribKHR(iDisplay,iSyncObject,aAttribute,&value); sl@0: TEST(res == EGL_TRUE); sl@0: TEST(value == aExpectedValue); sl@0: sl@0: switch(aAttribute) sl@0: { sl@0: case EGL_SYNC_TYPE_KHR: sl@0: { sl@0: if (value == EGL_SYNC_REUSABLE_KHR) sl@0: { sl@0: INFO_PRINTF1(_L(" EGL_SYNC_TYPE_KHR: EGL_SYNC_REUSABLE_KHR")); sl@0: } sl@0: else sl@0: { sl@0: ERR_PRINTF1(_L(" EGL_SYNC_TYPE_KHR: Invalid attribute")); sl@0: } sl@0: break; sl@0: } sl@0: case EGL_SYNC_STATUS_KHR: sl@0: { sl@0: if (value == EGL_SIGNALED_KHR) sl@0: { sl@0: INFO_PRINTF1(_L(" EGL_SYNC_STATUS_KHR: EGL_SIGNALED_KHR")); sl@0: } sl@0: else if (value == EGL_UNSIGNALED_KHR) sl@0: { sl@0: INFO_PRINTF1(_L(" EGL_SYNC_STATUS_KHR: EGL_UNSIGNALED_KHR")); sl@0: } sl@0: else sl@0: { sl@0: ERR_PRINTF1(_L(" EGL_SYNC_STATUS_KHR: Invalid attribute")); sl@0: } sl@0: break; sl@0: } sl@0: default: sl@0: { sl@0: ERR_PRINTF1(_L(" Invalid attribute")); sl@0: } sl@0: } sl@0: } sl@0: sl@0: /** sl@0: Obtain extension functions for the sync object sl@0: */ sl@0: TBool CEglTest_SyncObject_Base::GetProcAddress() sl@0: { sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not defined in test INI file.\ sl@0: The retrieval of the pointers to the extension sync object function will be skipped")); sl@0: return ETrue; sl@0: } sl@0: sl@0: //retrieve the pointers to the EGL sync object extension functions sl@0: INFO_PRINTF1(_L("retrieve the pointers to the EGL sync object extension functions")); sl@0: sl@0: iPfnEglCreateSyncKHR = reinterpret_cast (eglGetProcAddress("eglCreateSyncKHR")); sl@0: iPfnEglDestroySyncKHR = reinterpret_cast (eglGetProcAddress("eglDestroySyncKHR")); sl@0: iPfnEglClientWaitSyncKHR = reinterpret_cast (eglGetProcAddress("eglClientWaitSyncKHR")); sl@0: iPfnEglSignalSyncKHR = reinterpret_cast (eglGetProcAddress("eglSignalSyncKHR")); sl@0: iPfnEglGetSyncAttribKHR = reinterpret_cast (eglGetProcAddress("eglGetSyncAttribKHR")); sl@0: if(iIsSyncObjectPrivateExtensionSupported) sl@0: { sl@0: iPfnEglPrivateSignalSyncNOK = reinterpret_cast (eglGetProcAddress("egl_Private_SignalSyncNOK")); sl@0: if(!iPfnEglPrivateSignalSyncNOK) sl@0: { sl@0: ERR_PRINTF1(_L(" Pointer to function \"egl_Private_SignalSyncNOK\" is not valid")); sl@0: } sl@0: } sl@0: if(!iPfnEglCreateSyncKHR) sl@0: { sl@0: ERR_PRINTF1(_L(" Pointer to function \"eglCreateSyncKHR\" is not valid")); sl@0: } sl@0: if(!iPfnEglDestroySyncKHR) sl@0: { sl@0: ERR_PRINTF1(_L(" Pointer to function \"eglDestroySyncKHR\" is not valid")); sl@0: } sl@0: if(!iPfnEglClientWaitSyncKHR) sl@0: { sl@0: ERR_PRINTF1(_L(" Pointer to function \"eglClientWaitSyncKHR\" is not valid")); sl@0: } sl@0: if(!iPfnEglSignalSyncKHR) sl@0: { sl@0: ERR_PRINTF1(_L(" Pointer to function \"eglSignalSyncKHR\" is not valid")); sl@0: } sl@0: sl@0: if(!iPfnEglGetSyncAttribKHR) sl@0: { sl@0: ERR_PRINTF1(_L(" Pointer to function \"eglGetSyncAttribKHR\" is not valid")); sl@0: } sl@0: sl@0: if(!(iPfnEglCreateSyncKHR && iPfnEglDestroySyncKHR && iPfnEglClientWaitSyncKHR sl@0: && iPfnEglSignalSyncKHR && iPfnEglGetSyncAttribKHR && sl@0: (!iIsSyncObjectPrivateExtensionSupported || (iPfnEglPrivateSignalSyncNOK)))) sl@0: {//if the private extension is not declared in the test ini file, we won't signal the failure sl@0: return EFalse; sl@0: } sl@0: return ETrue; sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Base::CleanAll() sl@0: { sl@0: if(iEglSess) sl@0: { sl@0: delete iEglSess; sl@0: iEglSess = NULL; sl@0: } sl@0: TRAPD(res, TerminateDisplayL()); sl@0: TEST(res == KErrNone); sl@0: INFO_PRINTF2(_L("Display termination completed with error %d"), res); sl@0: sl@0: INFO_PRINTF1(_L("Main Thread: Calling eglReleaseThread()")); sl@0: ASSERT_EGL_TRUE(eglReleaseThread()) sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-001 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that current implementation support EGL sync object extension sl@0: sl@0: @SYMTestActions sl@0: 1. Request supporting extension for the existing display by calling eglQueryString(...) and passing EGL_EXTENSIONS as a second parameter. sl@0: 2. Obtain an EGL sync object extension functions by supplying the following procname to the function void (*eglGetProcAddress(const char *procname)): sl@0: "eglCreateSyncKHR" sl@0: "eglDestroySyncKHR" sl@0: "eglClientWaitSyncKHR" sl@0: "eglSignalSyncKHR" sl@0: "eglGetSyncAttribKHR" sl@0: sl@0: @SYMTestExpectedResults sl@0: 1. The function must return a string which includes space separated sub-string "EGL_KHR_reusable_sync". sl@0: 2. The pointer to the functions should be non zero. sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_GetProcAddress::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-001")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_GetProcAddress::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: // check that extension "EGL_KHR_reusable_sync" is supported sl@0: INFO_PRINTF1(_L("Check that extension \"EGL_KHR_reusable_sync\" is supported")); sl@0: TEST(CheckForExtensionL(KEGL_KHR_reusable_sync)); sl@0: sl@0: INFO_PRINTF1(_L("Obtain EGL sync object extension functions")); sl@0: TEST(GetProcAddress()); sl@0: sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Positive_GetProcAddress::doTestStepL")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-005 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To validate the creation and deletion of the sync object. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. NULL are specified in attribute_list. sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Retrieve the following attributes of the sync object: EGL_SYNC_TYPE_KHR , sl@0: EGL_SYNC_STATUS_KHR sl@0: 3. Delete the sync object sl@0: 4. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 5. Retrieve the following attributes of the sync object: EGL_SYNC_TYPE_KHR , sl@0: EGL_SYNC_STATUS_KHR sl@0: 6. Delete the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 1. Sync object handle doesn't equal to EGL_NO_SYNC_KHR sl@0: 2. Sync object attribute EGL_SYNC_STATUS_KHR should be set to EGL_UNSIGNALED_KHR by default, sl@0: attribute EGL_SYNC_TYPE_KHR should be set to EGL_SYNC_REUSABLE_KHR sl@0: 4. Sync object handle doesn't equal to EGL_NO_SYNC_KHR sl@0: 5. Sync object attribute EGL_SYNC_STATUS_KHR should be set to EGL_UNSIGNALED_KHR by default, sl@0: attribute EGL_SYNC_TYPE_KHR should be set to EGL_SYNC_REUSABLE_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_CreateDestroy::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-005")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_CreateDestroy::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object - default display, NULL at attributes, type parameter set to EGL_SYNC_REUSABLE_KHR")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, NULL); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: //check attributes of the sync object. sl@0: INFO_PRINTF1(_L("Check attributes of sync object")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR, EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_UNSIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object - default display, no attribute specified, type parameter set to EGL_SYNC_REUSABLE_KHR ")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR, EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-010 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that transition from EGL_UNSIGNALED_KHR to EGL_SIGNALED_KHR state will trigger the signal and unblock the client thread sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch thread A sl@0: 3. Wait on sync object by calling eglClientWaitSyncKHR sl@0: 4. Signal on the sync object from thread A with the flag EGL_SIGNALED_KHR sl@0: 5. Retrieve EGL_SYNC_STATUS_KHR attribute sl@0: 6. Delete the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. The main thread is blocked sl@0: 4. After the signal the main thread should be unblocked and the value returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR sl@0: 5. Status attribute is set to EGL_SIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_WaitSignal::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-010")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_WaitSignal::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: //create sync object sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: //Stall the main thread sl@0: TUint32 timestampBefore = User::NTickCount(); //microsecond sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF4(_L("Main thread waited on eglClientWaitSyncKHR for %d usec (threshold was [%d +- %d])"),timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes of sync object")); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_WaitSignal::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_WaitSignal::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: User::After(iDelaySignalling); sl@0: sl@0: INFO_PRINTF1(_L("signal sync object from thread A")); sl@0: EGLBoolean res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_SIGNALED_KHR); sl@0: TEST(res == EGL_TRUE); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-015 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that the client will not be blocked by waiting on the sync object sl@0: if the latter is in EGL_SIGNALED_KHR state and will stay blocked until sl@0: transition from unsignal to signal state occurs. sl@0: To check that eglSignalSyncKHR sets the state of the sync object correctly. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Call eglSignalSyncKHR with EGL_SIGNALED_KHR as a parameter. sl@0: 3. Retrieve an EGL_SYNC_STATUS_KHR attribute. sl@0: 4. Try to wait on the sync object by calling eglClientWaitSyncKHR. sl@0: 5. Call eglSignalSyncKHR with EGL_UNSIGNALED_KHR as a parameter. sl@0: 6. Retrieve an EGL_SYNC_STATUS_KHR attribute. sl@0: 7. Launch thread A. sl@0: 8. Waiting on the sync object by calling eglClientWaitSyncKHR. sl@0: 9. From thread A call eglSignalSyncKHR with EGL_UNSIGNALED_KHR as a parameter. sl@0: 10. From thread A retrieve EGL_SYNC_STATUS_KHR attribute. sl@0: 11. From thread A call eglSignalSyncKHR with EGL_SIGNALED_KHR as a parameter. sl@0: 12. From thread A retrieve EGL_SYNC_STATUS_KHR attribute. sl@0: 13 Delete the sync object. sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. EGL_SYNC_STATUS_KHR attribute is set to EGL_SIGNALED_KHR sl@0: 4. The thread is not blocked and an error code returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR sl@0: 6. EGL_SYNC_STATUS_KHR attribute is set to EGL_UNSIGNALED_KHR sl@0: 8. Main thread is blocked sl@0: 9. Main thread stays blocked sl@0: 10. EGL_SYNC_STATUS_KHR attribute is set to EGL_UNSIGNALED_KHR sl@0: 11. Main thread is unblocked sl@0: 12. EGL_SYNC_STATUS_KHR attribute is set to EGL_SIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_WaitSignal2::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-015")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_WaitSignal2::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: //set to signal state, basically we are not changing anything here sl@0: EGLBoolean res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_SIGNALED_KHR); sl@0: TEST(res = EGL_TRUE); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Try to wait on the sync object by calling eglClientWaitSyncKHR")); sl@0: TUint32 timestampBefore = User::NTickCount(); //microsecond sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: INFO_PRINTF1(_L(" Check that main thread was not stalled at eglClientWaitSyncKHR()")); sl@0: TEST(timeElapsed < iThreshold); sl@0: sl@0: //set to unsignal state sl@0: res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_UNSIGNALED_KHR); sl@0: TEST(res == EGL_TRUE); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_UNSIGNALED_KHR); sl@0: sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: //Stall the main thread sl@0: timestampBefore = User::NTickCount(); sl@0: resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: timestampAfter = User::NTickCount(); sl@0: timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Main thread waited on eglClientWaitSyncKHR for %d usec (threshold was [%d + %d +- %d])"),timeElapsed, iDelaySignalling*2, iTimeOverhead, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST(Abs(timeElapsed - (iDelaySignalling*2 + iTimeOverhead)) < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_WaitSignal2::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: TUint32 timeOverheadStart = User::NTickCount(); sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_WaitSignal2::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: User::After(iDelaySignalling); sl@0: INFO_PRINTF1(_L("unsignal sync object from thread A")); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_UNSIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_UNSIGNALED_KHR); sl@0: sl@0: User::After(iDelaySignalling); sl@0: INFO_PRINTF1(_L("signal sync object from thread A")); sl@0: TUint32 timeOverheadEnd = User::NTickCount(); sl@0: iTimeOverhead = ElapsedTime(timeOverheadEnd, timeOverheadStart) - iDelaySignalling*2; sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_SIGNALED_KHR); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-020 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that the deletion of the sync object triggers the signalling sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch a thread A sl@0: 3. Stall the main thread by calling eglClientWaitSyncKHR() on the sync object with timeout value EGL_FOREVER_KHR sl@0: 4. Delete the sync object from the thread A sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. The main thread which waits for the signal must be stalled sl@0: 4. After the sync object has been deleted the main client thread will be unblocked and an error code returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_WaitDelete::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-020")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_WaitDelete::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: //create sync object sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: //Stall the main thread sl@0: TUint32 timestampBefore = User::NTickCount(); //microsecond sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF4(_L("Main thread waited on eglClientWaitSyncKHR for %d usec (threshold was [%d +- %d])"),timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_WaitDelete::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_WaitDelete::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: User::After(iDelaySignalling); sl@0: INFO_PRINTF1(_L("Delete sync object from thread A")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-025 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that client will be unblocked once the timeout has expired even if there is no signalling occurred. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Take the start time stamp sl@0: 3. Call eglClientWaitSyncKHR() on the sync object with timeout value equals five seconds sl@0: 4. Take the end timestamp sl@0: 5. Retrieve EGL_SYNC_STATUS attribute of the sync object sl@0: 6. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. The client thread should stay blocked until timeout is expired sl@0: 4. Check that (timestamp End - timestamp Before) equals (roughly) timeout and an error code returned by sl@0: eglClientWaitSyncKHR is EGL_TIMEOUTE_EXPIRED_KHR sl@0: 5. The sync object attribute EGL_SYNC_STATUS is set to EGL_UNSIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_WaitWithTimeoutExpired::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-025")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_WaitWithTimeoutExpired::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: // calling wait sync without signaling the object should hit the predefined timeout if set to anything different to EGL_FOREVER_KHR sl@0: INFO_PRINTF2(_L("Calling eglClientWaitSyncKHR on the object with a defined timeout of %d usec"), iWaitSyncTimeout); sl@0: EGLTimeKHR timeoutNano = (TUint64)iWaitSyncTimeout * 1000; // EGLTimeKHR is in nanoseconds!! sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,timeoutNano); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF4(_L("Waited on eglClientWaitSyncKHR for %d usec (threshold was [%d +- %d])"),timeElapsed, iWaitSyncTimeout, iThreshold); sl@0: TEST(resClientWait == EGL_TIMEOUT_EXPIRED_KHR); sl@0: TEST (Abs(timeElapsed - timeoutNano/1000) < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_WaitWithTimeoutExpired::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-030 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that client will be unblocked once the signalling occurs even if the timeout is not expired sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR. sl@0: 2. Launch thread A sl@0: 3. Take the start time stamp sl@0: 4. Call eglClientWaitSyncKHR() on the sync object with timeout value equals five seconds sl@0: 5. Signal on the sync object from thread A before timeout is expired (after 2.5 seconds). sl@0: 6. Takes the end timestamp sl@0: 7. Retrieve EGL_SYNC_STATUS attribute of the sync object from thread A sl@0: 8. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 4. The client thread should be blocked sl@0: 6. The main thread is unblocked. Check that (timestamp End - timestamp Before) equals (roughly) sl@0: 2.5 seconds and an error code returned by eglClientWaitSyncKHR is EGL_CONDITION_SATISFIED_KHR sl@0: 7. The sync object attribute EGL_SYNC_STATUS is set to EGL_SIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_SignalBeforeTimeoutExpired::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-030")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_SignalBeforeTimeoutExpired::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching thread A...")); sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: INFO_PRINTF2(_L("Main thread waiting for thread A to signal with a defined timeout of %d usec"), iWaitSyncTimeout); sl@0: EGLTimeKHR timeoutNano = (TUint64)iWaitSyncTimeout * 1000; // EGLTimeKHR is in nanoseconds!! sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,timeoutNano); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF4(_L("Main thread waited on eglClientWaitSyncKHR for %d usec (threshold was [%d +- %d])"),timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_SignalBeforeTimeoutExpired::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_SignalBeforeTimeoutExpired::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_SignalBeforeTimeoutExpired::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: INFO_PRINTF2(_L("Wait for a bit before Signal sync object, Thread %d"),aIdx); sl@0: User::After(iDelaySignalling); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: INFO_PRINTF2(_L("Signal sync object done, Thread %d"),aIdx); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-035 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that client will be unblocked once the sync object has been deleted even if the timeout is not expired sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch thread A sl@0: 3. Take the start time stamp sl@0: 4. Stall the client thread by calling eglClientWaitSyncKHR() on the sync object with timeout value equals five seconds sl@0: 5. Destroy the sync object from thread A before timeout is expired. (2.5 seconds) sl@0: 6. Takes the end timestamp sl@0: 7. Retrieve EGL_SYNC_STATUS attribute of the sync object sl@0: 8. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 4. The main client thread should be blocked sl@0: 5. The main thread is unblocked. Check that (timestamp End - timestamp Before) equals (roughly) sl@0: 2.5 seconds and an error code returned by eglClientWaitSyncKHR is EGL_CONDITION_SATISFIED_KHR sl@0: 7. eglGetSyncAttribKHR() returns EGL_FALSE and EGL_BAD_PARAMETER is generated sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_DeleteBeforeTimeoutExpired::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-035")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_DeleteBeforeTimeoutExpired::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching thread A...")); sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: INFO_PRINTF2(_L("Main thread waiting for thread A to signal with a defined timeout of %d usec"), iWaitSyncTimeout); sl@0: EGLTimeKHR timeoutNano = (TUint64)iWaitSyncTimeout * 1000; // EGLTimeKHR is in nanoseconds!! sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,timeoutNano); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF4(_L("Main thread waited on eglClientWaitSyncKHR for %d usec before sync object was deleted (threshold was [%d +- %d])"),timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: EGLint syncTypeValue=-1; sl@0: EGLBoolean ret = iPfnEglGetSyncAttribKHR(iDisplay,iSyncObject,EGL_SYNC_TYPE_KHR,&syncTypeValue); sl@0: TEST(ret == EGL_FALSE); sl@0: EGLint error = eglGetError(); sl@0: TEST(error == EGL_BAD_PARAMETER); sl@0: TEST(syncTypeValue == -1); // due to the error, it wasn't properly retrieved sl@0: sl@0: INFO_PRINTF1(_L("(attempt to) Delete sync object (was already deleted by a worker thread)")); sl@0: ret = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(ret == EGL_FALSE); sl@0: error = eglGetError(); sl@0: TEST(error == EGL_BAD_PARAMETER); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_DeleteBeforeTimeoutExpired::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_DeleteBeforeTimeoutExpired::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_DeleteBeforeTimeoutExpired::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: INFO_PRINTF2(_L("Wait for a bit before destroying sync object, Thread %d"),aIdx); sl@0: User::After(iDelaySignalling); sl@0: TInt res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: INFO_PRINTF2(_L("Delete sync object done, Thread %d"),aIdx); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-040 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that all threads waiting for the signal on the same sync object will be unblocked before the timeout has expired. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch two threads A and B. sl@0: 3. Call eglClientWaitSyncKHR() (from threads A and B) on the sync object with timeout value equals five seconds sl@0: in thread A and EGL_FOREVER_KHR in thread B. sl@0: 4. Signal on the sync object with the flag EGL_SIGNALED_KHR from the main thread before timeout expired (after 2.5 seconds) sl@0: 5. Retrieve EGL_SYNC_STATUS attribute of the sync object from the main thread sl@0: 6. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. Threads A and B will be stalled sl@0: 4. Both threads A and B will be unblocked and a value returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR. sl@0: 5. The sync object attribute EGL_SYNC_STATUS is set to EGL_SIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_Multithread_SignalBeforeTimeout::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-040")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Multithread_SignalBeforeTimeout::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching threads A and B...")); sl@0: Test_MultiThreadL(2, EFalse); sl@0: sl@0: INFO_PRINTF1(_L("Main thread, wait for a bit before Signal sync object")); sl@0: User::After(iDelaySignalling); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: INFO_PRINTF1(_L("Main thread Signal sync object done")); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_Multithread_SignalBeforeTimeout::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_Multithread_SignalBeforeTimeout::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_Multithread_SignalBeforeTimeout::doThreadFunctionL, Thread %d"), aIdx); sl@0: ASSERT_TRUE(aIdx==0 || aIdx==1); sl@0: sl@0: //Thread 0 waits for the main thread to signal the sync object, and exits sl@0: if(aIdx == 0) sl@0: { sl@0: INFO_PRINTF2(_L("Thread %d waiting for main thread to signal with a timeout EGL_FOREVER_KHR"), aIdx); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was signaled (threshold was [%d +- %d])"), aIdx, timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: } sl@0: //Thread 1 waits for the main thread to signal the sync object, and exits sl@0: else if(aIdx == 1) sl@0: { sl@0: INFO_PRINTF3(_L("Thread %d waiting for main thread to signal with a defined timeout of %d"), aIdx, iWaitSyncTimeout); sl@0: EGLTimeKHR timeoutNano = (TUint64)iWaitSyncTimeout * 1000; // EGLTimeKHR is in nanoseconds!! sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,timeoutNano); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was signaled (threshold was [%d +- %d])"), aIdx, timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-045 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that a thread resumed due to timeout will not unblock another thread waiting for the signal. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch two threads A and B. sl@0: 3. Call eglClientWaitSyncKHR() (from threads A and B) on the sync object with timeout value equals five seconds in thread A and EGL_FOREVER_KHR in thread B. sl@0: 4. Wait for approximately 7.5 seconds sl@0: 5. Retrieve EGL_SYNC_STATUS attribute of the sync object from the main thread sl@0: 6. Signal on the sync object with the flag EGL_SIGNALED_KHR from the main thread sl@0: 7. Retrieve EGL_SYNC_STATUS attribute of the sync object from the main thread sl@0: 8. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 3.Threads A and B will be stalled sl@0: 4. Thread A will be unblocked after approximately 5 seconds and a value returned by eglClientWaitSyncKHR() is set to EGL_TIMEOUT_EXPIRED_KHR. sl@0: 5. EGL_SYNC_STATUS attribute of the sync object is set to EGL_UNSIGNALED_KHR sl@0: 6. Threads B will be unblocked and a value returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR. sl@0: 7. The sync object attribute EGL_SYNC_STATUS is set to EGL_SIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_Multithread_SignalAfterTimeout::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-045")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Multithread_SignalAfterTimeout::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching threads A and B...")); sl@0: Test_MultiThreadL(2, EFalse); sl@0: TUint32 timeOverheadStart = User::NTickCount(); sl@0: sl@0: INFO_PRINTF1(_L("Main thread, wait for a long time, no Signal sync object yet")); sl@0: User::After(iLongDelaySignalling); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Main thread, Signal sync object now")); sl@0: TUint32 timeOverheadEnd = User::NTickCount(); sl@0: iTimeOverhead = ElapsedTime(timeOverheadEnd, timeOverheadStart) - iLongDelaySignalling; sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: INFO_PRINTF1(_L("Main thread, Signal sync object done")); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_Multithread_SignalAfterTimeout::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_Multithread_SignalAfterTimeout::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_Multithread_SignalAfterTimeout::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0 || aIdx==1); sl@0: sl@0: //Thread 0 waits for the main thread to signal the sync object, and exits sl@0: if(aIdx == 0) sl@0: { sl@0: INFO_PRINTF2(_L("Thread %d waiting for main thread to signal with a timeout EGL_FOREVER_KHR"), aIdx); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF6(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was signaled (threshold was [%d + %d +- %d])"), aIdx, timeElapsed, iLongDelaySignalling, iTimeOverhead, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - (iLongDelaySignalling + iTimeOverhead)) < iThreshold); sl@0: } sl@0: //Thread 1 waits for the main thread to signal the sync object, and exits sl@0: else if(aIdx == 1) sl@0: { sl@0: INFO_PRINTF3(_L("Thread %d waiting for main thread to signal with a defined timeout of %d"), aIdx, iWaitSyncTimeout); sl@0: EGLTimeKHR timeoutNano = (TUint64)iWaitSyncTimeout * 1000; // EGLTimeKHR is in nanoseconds!! sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,timeoutNano); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was timeout'ed (threshold was [%d +- %d])"), aIdx, timeElapsed, iWaitSyncTimeout, iThreshold); sl@0: TEST(resClientWait == EGL_TIMEOUT_EXPIRED_KHR); sl@0: TEST (Abs(timeElapsed - iWaitSyncTimeout) < iThreshold); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-050 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that signalling on one sync object won't unblock the thread waiting on another sync object. sl@0: sl@0: @SYMTestActions sl@0: 1. Create two sync objects (S1 and S2) for the default display with no attributes are specified and the type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch two threads A and B. sl@0: 3. Wait on the sync objects S1 and S2 from threads A and B respectively by calling eglClientWaitSyncKHR() with timeout set to EGL_FOREVER_KHR. sl@0: 4. Signal on S1 with the flag EGL_SIGNALED_KHR from main thread sl@0: 5. Retrieve EGL_SYNC_STATUS attribute of S1 and S2 from main thread sl@0: 6. Signal on S2 with the flag EGL_SIGNALED_KHR from main thread sl@0: 7. Retrieve EGL_SYNC_STATUS attribute of S1 and S2 from main thread sl@0: 8. Destroy the sync objects sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. Threads A and B will be stalled sl@0: 4. Thread A will be unblocked and an error code returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR. sl@0: Thread B stays blocked. sl@0: 5. The S1 attribute EGL_SYNC_STATUS is set to EGL_SIGNALED_KHR, S2 attribute EGL_SYNC_STATUS is set to EGL_UNSIGNALED_KHR sl@0: 6. Thread B will be unblocked and an error code returned by eglClientWaitSyncKHR() is set to EGL_CONDITION_SATISFIED_KHR. sl@0: 7. The S1 & S2 attribute EGL_SYNC_STATUS is set to EGL_SIGNALED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_Multithread_WaitOnTwoSyncObject::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-050")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Multithread_WaitOnTwoSyncObject::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create two sync objects")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: iSyncObject2 = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject2 != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching threads A and B...")); sl@0: Test_MultiThreadL(2, EFalse); sl@0: TUint32 timeOverheadStart = User::NTickCount(); sl@0: sl@0: INFO_PRINTF1(_L("Main thread, wait for a bit before Signal sync object number 1")); sl@0: User::After(iDelaySignalling); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: INFO_PRINTF1(_L("Main thread Signal sync object number 1 done")); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes for sync object number 1...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes for sync object number 2...")); sl@0: // the CheckSyncAttrib uses iSyncObject, so we need to replace it, and restore it later sl@0: EGLSyncKHR oldSyncObject=iSyncObject; sl@0: iSyncObject=iSyncObject2; sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR, EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR); sl@0: iSyncObject=oldSyncObject; sl@0: sl@0: INFO_PRINTF1(_L("Main thread, wait for a bit before Signal sync object number 2")); sl@0: User::After(iDelaySignalling); sl@0: sl@0: TUint32 timeOverheadEnd = User::NTickCount(); sl@0: iTimeOverhead = ElapsedTime(timeOverheadEnd, timeOverheadStart) - iDelaySignalling*2; sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject2, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: INFO_PRINTF1(_L("Main thread Signal sync object number 2 done")); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes for sync object number 1...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes for sync object number 2...")); sl@0: oldSyncObject=iSyncObject; sl@0: iSyncObject=iSyncObject2; sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: iSyncObject=oldSyncObject; sl@0: sl@0: INFO_PRINTF1(_L("Delete both sync objects")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject2); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_Multithread_WaitOnTwoSyncObject::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_Multithread_WaitOnTwoSyncObject::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_Multithread_WaitOnTwoSyncObject::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0 || aIdx==1); sl@0: sl@0: //Thread 0 waits for the main thread to signal the sync object, and exits sl@0: if(aIdx == 0) sl@0: { sl@0: INFO_PRINTF2(_L("Thread %d waiting for main thread to signal object 1 with a timeout EGL_FOREVER_KHR"), aIdx); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was signaled (threshold was [%d +- %d])"), aIdx, timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: } sl@0: //Thread 1 waits for the main thread to signal the sync object, and exits sl@0: else if(aIdx == 1) sl@0: { sl@0: INFO_PRINTF2(_L("Thread %d waiting for main thread to signal object 2 with a timeout EGL_FOREVER_KHR"), aIdx); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject2,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF6(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was signaled (threshold was [%d + %d +- %d])"), aIdx, timeElapsed, 2*iDelaySignalling, iTimeOverhead, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - (2*iDelaySignalling + iTimeOverhead)) < iThreshold); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-055 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that if zero timeout is passed to eglClientWaitSyncKHR(), the function just test the current status without attempt to stall the client thread. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Take timestamp before sl@0: 3. Call eglClientWaitSyncKHR() on the sync object with timeout value equals to zero sl@0: 4. Take timestamp after sl@0: 5. Call eglSignalSyncKHR on the sync object with the flag EGL_SIGNALED_KHR sl@0: 6. Repeat steps 2 to 4 sl@0: 7. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. The client thread is not stalled. The function eglClientWaitSyncKHR() should return EGL_TIMEOUT_EXPIRED_KHR. sl@0: 4. The difference timestamp (after - before) should be less than a half second sl@0: 3.1 The client thread is not stalled. The function eglClientWaitSyncKHR() should return EGL_CONDITION_SATISFIED_KHR. sl@0: 4.1 The difference timestamp (after - before) should be less than a half second sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_Wait_TestMode::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-055")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Wait_TestMode::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: // calling wait sync without signaling the object, but with timeout set to 0 ==> no stalling sl@0: INFO_PRINTF1(_L("Calling eglClientWaitSyncKHR on the object, without signaling the object, but with timeout set to 0")); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,0); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF3(_L("Check it didn't wait on eglClientWaitSyncKHR. Elapsed time was %d usec (threshold was [%d])"),timeElapsed, iThreshold); sl@0: TEST(resClientWait == EGL_TIMEOUT_EXPIRED_KHR); sl@0: TEST (timeElapsed < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Signal sync object")); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: INFO_PRINTF1(_L("Repeat same step, calling eglClientWaitSyncKHR with timeout set to 0")); sl@0: timestampBefore = User::NTickCount(); sl@0: resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,0); sl@0: timestampAfter = User::NTickCount(); sl@0: timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF3(_L("Check it didn't wait on eglClientWaitSyncKHR. Elapsed time was %d usec (threshold was [%d])"),timeElapsed, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (timeElapsed < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR,EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_SIGNALED_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Delete sync object")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_Wait_TestMode::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-060 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that deletion of the sync object will unblock all threads waiting for the signal. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch threads A and B sl@0: 3. Call eglClientWaitSyncKHR() on the sync object in main thread and thread A. sl@0: 4. Destroy the sync object from thread B sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. Main thread and thread A will be stalled sl@0: 4. All client threads which waited for the signal must be unblocked as if eglSignalSyncKHR() has been called. sl@0: The function eglClientWaitSyncKHR should return EGL_CONDITION_SATISFIED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_Multithread_Deletion::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-060")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Multithread_Deletion::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching threads A and B...")); sl@0: Test_MultiThreadL(2, EFalse); sl@0: sl@0: INFO_PRINTF1(_L("Main thread waiting for thread B to destroy the sync object, with timeout EGL_FOREVER_KHR")); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF4(_L("Main thread waited on eglClientWaitSyncKHR for %d usec before sync object was deleted (threshold was [%d +- %d])"),timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: sl@0: INFO_PRINTF1(_L("Check attributes...")); sl@0: EGLint syncTypeValue=-1; sl@0: EGLBoolean ret = iPfnEglGetSyncAttribKHR(iDisplay,iSyncObject,EGL_SYNC_TYPE_KHR,&syncTypeValue); sl@0: TEST(ret == EGL_FALSE); sl@0: EGLint error = eglGetError(); sl@0: TEST(error == EGL_BAD_PARAMETER); sl@0: TEST(syncTypeValue == -1); // due to the error, it wasn't properly retrieved sl@0: sl@0: INFO_PRINTF1(_L("(attempt to) Delete sync object (was already deleted by a worker thread)")); sl@0: ret = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(ret == EGL_FALSE); sl@0: error = eglGetError(); sl@0: TEST(error == EGL_BAD_PARAMETER); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_Multithread_Deletion::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_Multithread_Deletion::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_Multithread_Deletion::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0 || aIdx==1); sl@0: sl@0: //Thread 0 waits for a the thread B to delete the sync object, and exits sl@0: if(aIdx == 0) sl@0: { sl@0: INFO_PRINTF2(_L("Thread %d waiting for thread B to destroy the sync object, with timeout EGL_FOREVER_KHR"), aIdx); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was deleted (threshold was [%d +- %d])"), aIdx, timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: } sl@0: //Thread 1 waits for a certain amount of time, deletes the sync object and exits sl@0: else if(aIdx == 1) sl@0: { sl@0: INFO_PRINTF2(_L("Wait for a bit before destroying sync object, Thread %d"),aIdx); sl@0: User::After(iDelaySignalling); sl@0: TInt res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: INFO_PRINTF2(_L("Delete sync object done, Thread %d"),aIdx); sl@0: //This Thread now will just exit sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-065 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To exercise sync object functionality in stress conditions. sl@0: sl@0: @SYMTestActions sl@0: 1. Create three sync objects (S1, S2, S3) for the default display with no attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR. sl@0: 2. Launch 2 threads (A and B) sl@0: 3. Make the threads A and B waiting on sync objects S2 and S3 respectively. sl@0: 4. Make consequential signalling in that order: Client-> A->B->Client->... for some period of time. sl@0: Each thread signals the next thread in the chain and then stalls itself on the corresponding sync object. sl@0: (Whenever each thread is unstalled, corresponding sync object should be reset by unsignalling it.) sl@0: Main thread is waiting on S1 sl@0: 5. When the number of iteration exceeds some predefined value (by default is 1000, but could be reconfigured in ini file) the sequence, defined in step 4 will stop executing sl@0: 6. Delete the sync objects sl@0: sl@0: @SYMTestExpectedResults sl@0: 4. The functionality is robust, transition from "unsignaled" to "signaled" sl@0: state always unblocks the threads sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_Stress::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-065")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Stress::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync objects")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: iSyncObject1 = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject1 != EGL_NO_SYNC_KHR); sl@0: iSyncObject2 = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject2 != EGL_NO_SYNC_KHR); sl@0: sl@0: iLastThreadToSignal = 2; sl@0: sl@0: //launch threadA & threadB sl@0: Test_MultiThreadL(2, EFalse); sl@0: User::After(iDelaySignalling); //to allow threads start up before we signal sl@0: sl@0: for(TInt index = 0; index < iNumStressIterations; index++) sl@0: { sl@0: iLastThreadToSignal = 2; sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay,iSyncObject1,EGL_SIGNALED_KHR ); sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: EGLint res = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TEST(iLastThreadToSignal == 1); sl@0: TEST(res == EGL_CONDITION_SATISFIED_KHR); sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_UNSIGNALED_KHR );//to set the status of iSyncObject EGL_UNSIGNALED_KHR sl@0: TEST(resSignal == EGL_TRUE); sl@0: User::After(0);//to yield the processor sl@0: } sl@0: iStopTest = ETrue; sl@0: INFO_PRINTF2(_L("Threads have been signalling for %d times"), iNumStressIterations); sl@0: INFO_PRINTF1(_L("Delete sync objects")); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject1); sl@0: TEST(res == EGL_TRUE); sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject2); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Positive_Stress::doTestStepL")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_Stress::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_Stress::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0 || aIdx==1); sl@0: sl@0: EGLint res; sl@0: if(aIdx == 0) sl@0: { sl@0: while(!iStopTest) sl@0: { sl@0: res = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject1,0,EGL_FOREVER_KHR); sl@0: TEST(res == EGL_CONDITION_SATISFIED_KHR); sl@0: User::After(0); //to yield the processor sl@0: if(!iStopTest) sl@0: { sl@0: TEST(iLastThreadToSignal == 2); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay,iSyncObject1,EGL_UNSIGNALED_KHR );//to reset the status of iSyncObject1 EGL_UNSIGNALED_KHR sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: iLastThreadToSignal = 0; sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay,iSyncObject2,EGL_SIGNALED_KHR ); sl@0: TEST(resSignal == EGL_TRUE); sl@0: } sl@0: } sl@0: } sl@0: else if(aIdx == 1) sl@0: { sl@0: while(!iStopTest) sl@0: { sl@0: res = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject2,0,EGL_FOREVER_KHR); sl@0: TEST(res == EGL_CONDITION_SATISFIED_KHR); sl@0: User::After(0); //to yield the processor sl@0: if(!iStopTest) sl@0: { sl@0: TEST(iLastThreadToSignal == 0); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay,iSyncObject2,EGL_UNSIGNALED_KHR );//to reset the status of iSyncObject2 EGL_UNSIGNALED_KHR sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: iLastThreadToSignal = 1; sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,EGL_SIGNALED_KHR ); sl@0: TEST(resSignal == EGL_TRUE); sl@0: } sl@0: } sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-070 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that flushing of the client API (bit EGL_SYNC_FLUSH_COMMANDS_BIT_KHR is set sl@0: for eglClientWaitSyncKHR()) doesn't cause any problems. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Bind Open VG API. sl@0: 3. Create and make the context current for the bound API. sl@0: 4. Launch the thread A. sl@0: 5. Wait on sync object by calling eglClientWaitSyncKHR(), pass on EGL_SYNC_FLUSH_COMMANDS_BIT_KHR as a flag. sl@0: 6. Signal "EGL_UNSIGNALED_KHR" to the sync object. sl@0: 7. Bind Open GLES API. sl@0: 8. Repeat steps 3-6. sl@0: 9. Repeat step 5, but client waits in test mode (timeout is set to zero) sl@0: 10. Make no context current sl@0: 11. Repeat steps 3-5. sl@0: 12. Delete the sync object. sl@0: sl@0: @SYMTestExpectedResults sl@0: All functions succeed. Setting the flag on step 5 doesn't cause any problem. sl@0: 9. The function eglClientWaitSyncKHR()returns EGL_TIMEOUT_EXPIRED_KHR sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Positive_WaitFlush::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-070")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_WaitFlush::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("bind OpenVG API")); sl@0: ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API)); sl@0: EGLConfig currentConfig = iEglSess->GetConfigExactMatchL(EPixmapAttribsColor64K); sl@0: INFO_PRINTF1(_L("Create and make the context current for the bound API")); sl@0: EGLContext context = eglCreateContext(iDisplay, currentConfig, EGL_NO_CONTEXT, NULL); sl@0: ASSERT_EGL_TRUE(context != EGL_NO_CONTEXT); sl@0: sl@0: //Create an OffScreen Pixmap to be used as an OpenVg target sl@0: TSgImageInfoTest imageInfo = TSgImageInfoTest(); sl@0: imageInfo.iSizeInPixels = TSize(200, 200); sl@0: imageInfo.iPixelFormat = EUidPixelFormatRGB_565; sl@0: #ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE sl@0: imageInfo.iUsage = ESgUsageBitOpenVgSurface; sl@0: #else sl@0: imageInfo.iUsage = ESgUsageOpenVgTarget; sl@0: #endif sl@0: RSgImage sgImageTarget; sl@0: CleanupClosePushL(sgImageTarget); sl@0: TInt ret2 = sgImageTarget.Create(imageInfo, NULL, NULL); sl@0: ASSERT_EQUALS(ret2, KErrNone); sl@0: EGLSurface surface = eglCreatePixmapSurface(iDisplay, currentConfig,&sgImageTarget, KPixmapAttribsNone ); sl@0: ASSERT_EGL_TRUE(surface != EGL_NO_SURFACE); sl@0: sl@0: TSurfaceToDestroy surfaceToDestroy; sl@0: surfaceToDestroy.iSurface = surface; sl@0: surfaceToDestroy.iDisplay = iDisplay; sl@0: CleanupStack::PushL(TCleanupItem(DestroySurface, &surfaceToDestroy)); sl@0: sl@0: INFO_PRINTF1(_L("Calling eglMakeCurrent")); sl@0: ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, surface, surface, context)); sl@0: sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: INFO_PRINTF1(_L("Wait on sync object by calling eglClientWaitSyncKHR(), pass on EGL_SYNC_FLUSH_COMMANDS_BIT_KHR as a flag")); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST(Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: EGLBoolean resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_UNSIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: //make no context current sl@0: ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); sl@0: sl@0: //Wait for the thread to finish before starting the next part of the test. sl@0: Test_MultiThread_WaitL(ETrue, TThreadStatus::ELogin); sl@0: sl@0: //---- the same test but for OpenGLES sl@0: INFO_PRINTF1(_L("bind OpenGLES API")); sl@0: ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENGL_ES_API)); sl@0: EGLContext context1 = eglCreateContext(iDisplay, currentConfig, EGL_NO_CONTEXT, NULL); sl@0: ASSERT_EGL_TRUE(context1 != EGL_NO_CONTEXT); sl@0: sl@0: INFO_PRINTF1(_L("Calling eglMakeCurrent")); sl@0: ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, surface, surface, context1)); sl@0: sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: INFO_PRINTF1(_L("Wait on sync object by calling eglClientWaitSyncKHR(), pass on EGL_SYNC_FLUSH_COMMANDS_BIT_KHR as a flag")); sl@0: timestampBefore = User::NTickCount(); sl@0: resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,EGL_FOREVER_KHR); sl@0: timestampAfter = User::NTickCount(); sl@0: timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST(Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_UNSIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: //repeat the same, but in test mode (timeout is set to zero) sl@0: INFO_PRINTF1(_L("Wait on sync object by calling eglClientWaitSyncKHR(), pass on EGL_SYNC_FLUSH_COMMANDS_BIT_KHR as a flag")); sl@0: timestampBefore = User::NTickCount(); sl@0: resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,0); sl@0: timestampAfter = User::NTickCount(); sl@0: timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: TEST(resClientWait == EGL_TIMEOUT_EXPIRED_KHR);//the sync object is in "unsignaled" state sl@0: TEST(timeElapsed < iThreshold); sl@0: resSignal = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_UNSIGNALED_KHR); sl@0: TEST(resSignal == EGL_TRUE); sl@0: sl@0: INFO_PRINTF1(_L("Make no context current")); sl@0: ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); sl@0: sl@0: //Wait for the thread to finish before starting the next part of the test. sl@0: Test_MultiThread_WaitL(ETrue, TThreadStatus::ELogin); sl@0: sl@0: //now try to wait with flushing bit on (EGL_SYNC_FLUSH_COMMANDS_BIT_KHR). The flag will be ignored sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: INFO_PRINTF1(_L("Wait on sync object by calling eglClientWaitSyncKHR(), pass on EGL_SYNC_FLUSH_COMMANDS_BIT_KHR as a flag, when no context is current")); sl@0: timestampBefore = User::NTickCount(); sl@0: resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,EGL_FOREVER_KHR); sl@0: timestampAfter = User::NTickCount(); sl@0: timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST(Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: sl@0: eglDestroyContext(iDisplay, context1); //Closing eglContext sl@0: eglDestroyContext(iDisplay, context); //Closing eglContext sl@0: CleanupStack::PopAndDestroy(2, &sgImageTarget); sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Positive_WaitFlush::doTestStepL")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_WaitFlush::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_WaitFlush::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: User::After(TTimeIntervalMicroSeconds32(iDelaySignalling)); sl@0: EGLBoolean res = iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(res == EGL_TRUE); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-075 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that eglTerminate() destroys sync object associated with display. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. NULL are specified in attribute_list. sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR. sl@0: 2. Call eglTerminate() without deleting the sync objects. sl@0: sl@0: @SYMTestExpectedResults sl@0: 1. Sync object handle doesn't equal to EGL_NO_SYNC_KHR. sl@0: 2. Test completes without any error and panic. No memory leak. sl@0: */ sl@0: sl@0: TVerdict CEglTest_SyncObject_Positive_Terminate::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-075")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_Terminate::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object - default display, NULL at attributes, type parameter set to EGL_SYNC_REUSABLE_KHR")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, NULL); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: //check attributes of the sync object. sl@0: INFO_PRINTF1(_L("Check attributes of sync object")); sl@0: CheckSyncAttrib(EGL_SYNC_TYPE_KHR, EGL_SYNC_REUSABLE_KHR); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR, EGL_UNSIGNALED_KHR); sl@0: sl@0: TRAPD(result, TerminateDisplayL()); sl@0: TEST(result == KErrNone); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-080 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that eglTerminate() destroys sync object and will unblock thread waiting for the signal. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Launch thread A sl@0: 3. Call eglClientWaitSyncKHR() on the sync object in thread A. sl@0: 4. Call eglTerminate() from main thread without deleting the sync object. sl@0: sl@0: @SYMTestExpectedResults sl@0: 1. Sync object handle doesn't equal to EGL_NO_SYNC_KHR. sl@0: 3. Thread A will be stalled sl@0: 4. Thread A which waited for the signal must be unblocked as if eglSignalSyncKHR() has been called. sl@0: The function eglClientWaitSyncKHR should return EGL_CONDITION_SATISFIED_KHR. sl@0: Test completes without any error and panic. No memory leak. sl@0: */ sl@0: sl@0: TVerdict CEglTest_SyncObject_Positive_TerminateBeforeTimeoutExpired::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-080")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Positive_TerminateBeforeTimeoutExpired::doTestStepL started....")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Launching threads A")); sl@0: Test_MultiThreadL(1, EFalse); sl@0: sl@0: INFO_PRINTF1(_L("Wait for a bit before eglTerminate")); sl@0: User::After(iDelaySignalling); sl@0: sl@0: TRAPD(result, TerminateDisplayL()); sl@0: TEST(result == KErrNone); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("....CEglTest_SyncObject_Positive_TerminateBeforeTimeoutExpired::doTestStepL completed!")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Positive_TerminateBeforeTimeoutExpired::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Positive_TerminateBeforeTimeoutExpired::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: INFO_PRINTF2(_L("Thread %d waiting for main thread to call eglTerminate(), with timeout EGL_FOREVER_KHR"), aIdx); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: sl@0: INFO_PRINTF5(_L("Thread %d waited on eglClientWaitSyncKHR for %d usec before sync object was destroyed by eglTerminate() (threshold was [%d +- %d])"), aIdx, timeElapsed, iDelaySignalling, iThreshold); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR); sl@0: TEST (Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-100 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To ensure that sync object API generates correct errors and returns correct sl@0: value if wrong parameters supplied. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR sl@0: 2. Call all sync API for the display which doesn't exist in the system. sl@0: 3. Call eglCreateSyncKHR() with unsupported type parameter. sl@0: 4. Call eglCreateSyncKHR() with specified attributes, type parameter set to EGL_SYNC_REUSABLE_KHR sl@0: 5. Call eglCreateSyncKHR() with unspecified attributes, type parameter set to EGL_SYNC_REUSABLE_KHR sl@0: 6. Call all sync API (with the exception to eglCreateSyncKHR(...), providing invalid EGLSyncKHR as a parameter sl@0: 7. Call eglClientWaitSyncKHR(), providing unspecified flags. sl@0: 8. Call eglSignalSyncKHR(), providing unspecified status. sl@0: 9. Call eglGetSyncAttribSyncKHR(), providing unspecified attributes. sl@0: 10. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 2. eglCreateSyncKHR(...) should return EGL_NO_SYNC_KHR and EGL_BAD_DISPLAY error is generated. sl@0: eglClientWaitSyncKHR(...), eglSignalSyncKHR(...), eglGetSyncAttribKHR(...) and eglDestroySyncKHR(...) sl@0: should return EGL_FALSE and EGL_BAD_DISPLAY error is generated. sl@0: 3. Should return EGL_NO_SYNC_KHR and EGL_BAD_ATTRIBUTE error is generated. sl@0: 4.5 Should return EGL_NO_SYNC_KHR and EGL_BAD_ATTRIBUTE error is generated. sl@0: 6, 7, 8. Should return EGL_FALSE and EGL_BAD_PARAMETER error is generated sl@0: 9. Should return EGL_FALSE and EGL_BAD_ATTRIBUTE error is generated sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Negative_WrongParameters::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-100")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Negative_WrongParameters::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: //create a sync object sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: TEST(eglGetError() == EGL_SUCCESS); sl@0: sl@0: INFO_PRINTF1(_L("Call all sync API for the display which doesn't exist in the system")); sl@0: EGLDisplay invalidDisplay = iDisplay + 1; sl@0: iSyncObject1 = iPfnEglCreateSyncKHR(invalidDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TEST(iSyncObject1 == EGL_NO_SYNC_KHR); sl@0: TEST(eglGetError() == EGL_BAD_DISPLAY); sl@0: EGLBoolean res = iPfnEglSignalSyncKHR(invalidDisplay,iSyncObject,EGL_UNSIGNALED_KHR ); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_DISPLAY); sl@0: EGLint res1 = iPfnEglClientWaitSyncKHR(invalidDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TEST(res1 == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_DISPLAY); sl@0: EGLint value; sl@0: res = iPfnEglGetSyncAttribKHR(invalidDisplay,iSyncObject,EGL_SYNC_STATUS_KHR, &value); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_DISPLAY); sl@0: res = iPfnEglDestroySyncKHR(invalidDisplay, iSyncObject); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_DISPLAY); sl@0: sl@0: INFO_PRINTF1(_L("Call eglCreateSyncKHR() with unsupported type parameter.")); sl@0: const EGLint unsupportedType = 0x3fff; sl@0: iSyncObject1 = iPfnEglCreateSyncKHR(iDisplay, unsupportedType, KEglSyncAttribsNone); sl@0: TEST(iSyncObject1 == EGL_NO_SYNC_KHR); sl@0: TEST(eglGetError() == EGL_BAD_ATTRIBUTE); sl@0: sl@0: const EGLint KSpecifiedAttrib[] = { sl@0: EGL_SYNC_STATUS_KHR, EGL_UNSIGNALED_KHR, sl@0: EGL_NONE sl@0: }; sl@0: INFO_PRINTF1(_L("Call eglCreateSyncKHR() with specified condition, type parameter set to EGL_SYNC_REUSABLE_KHR")); sl@0: iSyncObject1 = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KSpecifiedAttrib); sl@0: TEST(iSyncObject1 == EGL_NO_SYNC_KHR); sl@0: TEST(eglGetError() == EGL_BAD_ATTRIBUTE); sl@0: sl@0: INFO_PRINTF1(_L("Call eglCreateSyncKHR() with unspecified attributes, type parameter set to EGL_SYNC_REUSABLE_KHR")); sl@0: const TInt KUndefinedAttrib = 0x4000; sl@0: const EGLint KUnspecifiedAttrib1[] = { sl@0: KUndefinedAttrib, EGL_UNSIGNALED_KHR, sl@0: EGL_NONE sl@0: }; sl@0: iSyncObject1 = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KUnspecifiedAttrib1); sl@0: TEST(iSyncObject1 == EGL_NO_SYNC_KHR); sl@0: TEST(eglGetError() == EGL_BAD_ATTRIBUTE); sl@0: const EGLint KUnspecifiedAttrib2[] = { sl@0: EGL_SYNC_STATUS_KHR, KUndefinedAttrib, sl@0: EGL_NONE sl@0: }; sl@0: iSyncObject1 = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KUnspecifiedAttrib2); sl@0: TEST(iSyncObject1 == EGL_NO_SYNC_KHR); sl@0: TEST(eglGetError() == EGL_BAD_ATTRIBUTE); sl@0: sl@0: INFO_PRINTF1(_L("Call all sync API (with the exception to eglCreateSyncKHR(...), providing invalid EGLSyncKHR as a parameter")); sl@0: res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject1,EGL_UNSIGNALED_KHR ); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); sl@0: res1 = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject1,0,EGL_FOREVER_KHR); sl@0: TEST(res1 == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); sl@0: res = iPfnEglGetSyncAttribKHR(iDisplay,iSyncObject1,EGL_SYNC_STATUS_KHR, &value); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject1); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); sl@0: sl@0: INFO_PRINTF1(_L("Call eglClientWaitSyncKHR(), providing unspecified flags")); sl@0: const TInt KUnspecifiedFlags = 0x002; sl@0: res1 = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,KUnspecifiedFlags,EGL_FOREVER_KHR); sl@0: TEST(res1 == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); sl@0: sl@0: INFO_PRINTF1(_L("Call eglSignalSyncKHR(), providing unspecified status")); sl@0: const EGLint unspecifiedStatus = 0x3fff; sl@0: res = iPfnEglSignalSyncKHR(iDisplay,iSyncObject,unspecifiedStatus); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); sl@0: sl@0: INFO_PRINTF1(_L("Call eglGetSyncAttribSyncKHR(), providing unspecified attributes")); sl@0: const EGLint unspecifiedAttribute = 0x3fff; sl@0: res = iPfnEglGetSyncAttribKHR(iDisplay,iSyncObject,unspecifiedAttribute, &value); sl@0: TEST(res == EGL_FALSE); sl@0: TEST(eglGetError() == EGL_BAD_ATTRIBUTE); sl@0: //close sync object sl@0: res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Negative_WrongParameters::doTestStepL")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-105 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that internal version of the signal function, which is accessible sl@0: via extension mechanism, doesn't generate an error. sl@0: sl@0: @SYMTestActions sl@0: 1. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR. sl@0: 2. Call egl_Private_SignalSyncNOK() on sync object supplying invalid status sl@0: 3. Call eglGetError() sl@0: 4. Call egl_Private_SignalSyncNOK() on sync object with EGL_SIGNALED_KHR flag supplying invalid display sl@0: 5. Call eglGetError() sl@0: 6. Retrieve status attribute sl@0: 7. Call eglQueryString(..) supplying invalid name parameter (for instance, "OpenGL_Wrong" ). sl@0: 8. Call egl_Private_SignalSyncNOK() on sync object with EGL_SIGNALED_KHR flag supplying invalid display sl@0: 9. Call eglGetError() sl@0: 10. Destroy the sync object sl@0: sl@0: @SYMTestExpectedResults sl@0: 2. The function returns EGL_BAD_ PARAMETERS sl@0: 3. An error is set to EGL_SUCCESS sl@0: 4. The function returns EGL_BAD_DISPLAY. sl@0: 5. An error is set to EGL_SUCCESS sl@0: 6. The status attributes indicates that object is still in a signaled state (EGL_UNSIGNALED_KHR) sl@0: 8. The function returns EGL_BAD_DISPLAY. sl@0: 9. An error is set to EGL_BAD_PARAMETER sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Negative_SignalImpl::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-105")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Negative_SignalImpl::doTestStepL")); sl@0: sl@0: if(!iIsSyncObjectExtensionSupported || !iIsSyncObjectPrivateExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extensions (whether EGL_KHR_reusable_sync or EGL_NOK__private__signal_sync or both) \ sl@0: are not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Create the sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: TESTL(iSyncObject != EGL_NO_SYNC_KHR); sl@0: sl@0: INFO_PRINTF1(_L("Call egl_Private_SignalSyncNOK() on sync object supplying invalid status")); sl@0: const EGLint unspecifiedMode = 0x3fff; sl@0: EGLint res1 = iPfnEglPrivateSignalSyncNOK(iDisplay, iSyncObject, unspecifiedMode); sl@0: TEST(res1 == EGL_BAD_PARAMETER); sl@0: TEST(eglGetError() == EGL_SUCCESS); sl@0: sl@0: INFO_PRINTF1(_L("Call egl_Private_SignalSyncNOK() on sync object with EGL_SIGNALED_KHR flag supplying invalid display")); sl@0: const EGLDisplay invalidDisplay = iDisplay + 1; sl@0: res1 = iPfnEglPrivateSignalSyncNOK(invalidDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(res1 == EGL_BAD_DISPLAY); sl@0: TEST(eglGetError() == EGL_SUCCESS); sl@0: CheckSyncAttrib(EGL_SYNC_STATUS_KHR,EGL_UNSIGNALED_KHR); //the status is still "unsignaled" sl@0: sl@0: INFO_PRINTF1(_L("Call eglQueryString(..) supplying invalid name parameter ")); //the actual API doesn't matter, we need to generate an error sl@0: const TInt invalidExtension = 0xffff; sl@0: const char* extensionsString = eglQueryString(iDisplay, invalidExtension); //this should generate EGL_BAD_PARAMETER sl@0: TEST(!extensionsString); sl@0: sl@0: res1 = iPfnEglPrivateSignalSyncNOK(invalidDisplay, iSyncObject, EGL_SIGNALED_KHR); sl@0: TEST(res1 == EGL_BAD_DISPLAY); sl@0: TEST(eglGetError() == EGL_BAD_PARAMETER); //check that error code was not overidden sl@0: sl@0: EGLBoolean res = iPfnEglDestroySyncKHR(iDisplay, iSyncObject); sl@0: TEST(res == EGL_TRUE); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Negative_SignalImpl::doTestStepL")); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID GRAPHICS-EGL-SYNC-OBJECT-110 sl@0: sl@0: @SYMTestPriority 1 sl@0: sl@0: @SYMPREQ 2400 sl@0: sl@0: @SYMREQ 12326 sl@0: sl@0: @SYMTestCaseDesc sl@0: To check that system correctly processing errors in the environment with shortage of memory. sl@0: sl@0: @SYMTestActions sl@0: 1. Run a loop (step 2 to 7) with fail rate counting from 1 upward until sl@0: the following operations succeed sl@0: 2. Set heap failure with the fail rate specifying in step 1 sl@0: 3. Create sync object for the default display. No attributes are specified (containing only EGL_NONE). sl@0: The type parameter is set to EGL_SYNC_REUSABLE_KHR. Skip the following test steps if operation doesn't succeed sl@0: 4. Launch thread A sl@0: 5. Wait on the sync object sl@0: 6. Signal from thread A on the sync object the flag EGL_SIGNALED_KHR sl@0: 7. Destroy the sync object sl@0: 8. Reset heap sl@0: sl@0: @SYMTestExpectedResults sl@0: 3. If memory is not enough to fulfil an operation EGL_NO_SYNC_KHR is returned. Otherwise it should return a handle to a valid sync object sl@0: 5. The main thread should be stalled sl@0: 6. The main thread should be unblocked sl@0: */ sl@0: TVerdict CEglTest_SyncObject_Negative_OOM::doTestStepL() sl@0: { sl@0: SetTestStepID(_L("GRAPHICS-EGL-SYNC-OBJECT-110")); sl@0: INFO_PRINTF1(_L("CEglTest_SyncObject_Negative_OOM::doTestStepL")); sl@0: #ifndef _DEBUG sl@0: WARN_PRINTF1(_L("CEglTest_SyncObject_Negative_OOM can only be run in debug mode")); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: #else sl@0: sl@0: if(!iIsSyncObjectExtensionSupported) sl@0: { sl@0: INFO_PRINTF1(_L("Sync object extension is not supported, the test will not be executed")); sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: return TestStepResult(); sl@0: } sl@0: sl@0: ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY); sl@0: GetDisplayL(); sl@0: CreateEglSessionL(); sl@0: iEglSess->InitializeL(); sl@0: sl@0: INFO_PRINTF1(_L("Retrieving the heapMark functions for memory testing...")); sl@0: TEglDebugHeapMarkStartPtr heapMarkStart = reinterpret_cast(eglGetProcAddress("egliDebugHeapMarkStart")); sl@0: TEglDebugHeapMarkEndPtr heapMarkEnd = reinterpret_cast(eglGetProcAddress("egliDebugHeapMarkEnd")); sl@0: TEglDebugSetBurstAllocFailPtr setSyncObjectAllocFail = reinterpret_cast(eglGetProcAddress("egliDebugSetBurstAllocFail")); sl@0: TESTL(heapMarkStart && heapMarkEnd && setSyncObjectAllocFail); sl@0: sl@0: EGLint err = EGL_BAD_ALLOC; sl@0: for(TUint failAfter=1; (err == EGL_BAD_ALLOC); ++failAfter) sl@0: { sl@0: __UHEAP_MARK; sl@0: heapMarkStart(); sl@0: sl@0: // Set heap failure sl@0: INFO_PRINTF2(_L("Set EGL heap to fail after %u allocations"), failAfter); sl@0: setSyncObjectAllocFail(static_cast(RHeap::EBurstFailNext), failAfter, 742); sl@0: sl@0: INFO_PRINTF1(_L("Create sync object")); sl@0: iSyncObject = iPfnEglCreateSyncKHR(iDisplay, EGL_SYNC_REUSABLE_KHR, KEglSyncAttribsNone); sl@0: err = eglGetError(); sl@0: if(err == EGL_SUCCESS) sl@0: { sl@0: TEST(iSyncObject != EGL_NO_SYNC_KHR); sl@0: //launch threadA sl@0: Test_MultiThreadL(1, EFalse); sl@0: TUint32 timestampBefore = User::NTickCount(); sl@0: EGLint resClientWait = iPfnEglClientWaitSyncKHR(iDisplay,iSyncObject,0,EGL_FOREVER_KHR); sl@0: TUint32 timestampAfter = User::NTickCount(); sl@0: TInt timeElapsed = ElapsedTime(timestampAfter, timestampBefore); sl@0: TEST(resClientWait == EGL_CONDITION_SATISFIED_KHR);//we do not expect failure here, as eglClientWaitSyncKHR function doesn't allocate any memory sl@0: TEST(Abs(timeElapsed - iDelaySignalling) < iThreshold); sl@0: //close sync object sl@0: TEST(iPfnEglDestroySyncKHR(iDisplay, iSyncObject)== EGL_TRUE); sl@0: sl@0: //Wait for the thread to finish before launching the thread with the same index again. sl@0: Test_MultiThread_WaitL(ETrue, TThreadStatus::ELogin); sl@0: } sl@0: else sl@0: { sl@0: TEST(iSyncObject == EGL_NO_SYNC_KHR); sl@0: } sl@0: // Unset heap failure sl@0: setSyncObjectAllocFail(static_cast(RHeap::ENone), 0, 0); sl@0: (void)heapMarkEnd(0); sl@0: __UHEAP_MARKEND; sl@0: } sl@0: TEST(err == EGL_SUCCESS); sl@0: sl@0: CleanAll(); sl@0: RecordTestResultL(); sl@0: CloseTMSGraphicsStep(); sl@0: INFO_PRINTF1(_L("End of CEglTest_SyncObject_Negative_OOM::doTestStepL")); sl@0: return TestStepResult(); sl@0: #endif sl@0: } sl@0: sl@0: void CEglTest_SyncObject_Negative_OOM::doThreadFunctionL(TInt aIdx) sl@0: { sl@0: INFO_PRINTF2(_L("CEglTest_SyncObject_Negative_OOM::doThreadFunctionL, Thread %d"),aIdx); sl@0: ASSERT_TRUE(aIdx==0); sl@0: sl@0: User::After(TTimeIntervalMicroSeconds32(iDelaySignalling)); sl@0: TEST(iPfnEglSignalSyncKHR(iDisplay, iSyncObject, EGL_SIGNALED_KHR) == EGL_TRUE); //we do not expect failure here, as eglSignalSyncKHR function doesn't allocate a memory sl@0: }