diff -r 000000000000 -r 5d03bc08d59c egl/egltest/src/egltest_geterroranddisplay.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/src/egltest_geterroranddisplay.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1276 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+/**
+ @file
+ @test
+*/
+#include "egltest_geterroranddisplay.h"
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0507
+
+@SYMPREQ 2400
+
+@SYMTestPriority 1
+
+@SYMTestCaseDesc
+Test eglGetError behavior
+
+@SYMTestExpectedResults
+Error code is set according to EGL specification
+
+@SYMTestActions
+Call eglGetError
+Check error is EGL_SUCCESS
+
+Get default display
+Check error code is EGL_SUCCESS
+
+Query string for version
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Call eglGetError
+Check error is EGL_SUCCESS
+
+Query string for vendor
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Release thread
+Call eglGetError
+Check error is EGL_SUCCESS
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_GetError::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0507"));
+    INFO_PRINTF1(_L("CEglTest_GetError::doTestStepL"));
+
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Query string for version
+    const char* strEglVersion = eglQueryString(iDisplay, EGL_VERSION);
+    TEST_EGL_ERROR(strEglVersion == NULL, EGL_NOT_INITIALIZED);
+
+    // Query string for vendor
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+
+    TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0508
+
+@SYMPREQ 2400
+
+@SYMTestPriority 1
+
+@SYMTestCaseDesc
+Test eglGetError behavior and to prove that error is specific to each thread
+
+@SYMTestExpectedResults
+Error code is set according to EGL specification
+
+@SYMTestActions
+Main Thread
+Call eglGetError
+Check error is EGL_SUCCESS
+
+Get default display
+Check error code is EGL_SUCCESS
+
+Query string for version
+Check return value is null but do not check error code
+
+Launch thread A
+Wait for thread A to exit
+    Thread A
+    Call eglGetError
+    Check error is EGL_SUCCESS
+
+    Get default display
+    Check error code is EGL_SUCCESS
+
+    Release thread
+    Check return value is true
+    Exit
+
+Main Thread
+Check error code is EGL_NOT_INITIALIZED
+
+Query string for version
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Release thread
+Check return value is true
+Exit
+*/
+TVerdict CEglTest_GetErrorMultiThread::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0508"));
+    INFO_PRINTF1(_L("CEglTest_GetErrorMultiThread::doTestStepL"));
+
+    TEST(eglGetError() == EGL_SUCCESS);
+
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    INFO_PRINTF1(_L("Query string for version..."));
+    const char* strEglVersion = eglQueryString(iDisplay, EGL_VERSION);
+    TEST(strEglVersion == NULL);
+    
+    INFO_PRINTF1(_L("Launch thread A"));
+    Test_MultiThreadL(1, ETrue);
+    
+    // Check that eglGetError is specific to each thread
+    TEST(eglGetError() == EGL_NOT_INITIALIZED);
+    
+    INFO_PRINTF1(_L("Query string for vendor..."));
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+void CEglTest_GetErrorMultiThread::doThreadFunctionL(TInt aIdx)
+    {
+    INFO_PRINTF2(_L("CEglTest_GetErrorMultiThread::doThreadFunctionL, Thread %d"),aIdx);
+    
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    INFO_PRINTF2(_L("Create display object from thread: %d"), aIdx);
+    EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);    
+    TEST_EGL_ERROR(dpy == iDisplay, EGL_SUCCESS);
+    
+    TEST(eglReleaseThread() == EGL_TRUE);
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0509
+
+@SYMPREQ 2400
+
+@SYMTestPriority 1
+
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from a single thread
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Basic positive test
+
+@SYMTestActions
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Query string for vendor
+Check return value is not null and error code is EGL_SUCCESS
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_Display_Positive_Basic::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0509"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_Basic::doTestStepL"));
+
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+    
+    // Query string for vendor
+    INFO_PRINTF1(_L("Query string for vendor..."));
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+
+    // Terminate display
+    TerminateDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0510
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize and eglTerminate behaviors from a single thread
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Invalid display test
+
+@SYMTestActions
+Get display other than default
+Check return value is EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is false, error code is EGL_BAD_DISPLAY and version is not updated
+
+Terminate display
+Check return value is false and error code is EGL_BAD_DISPLAY
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_Display_Negative_InvalidDisplay::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0510"));
+    INFO_PRINTF1(_L("CEglTest_Display_Negative_InvalidDisplay::doTestStepL"));
+
+    // Get display other than default
+    const NativeDisplayType nonDefaultDisplay = -1;
+    iDisplay = eglGetDisplay(nonDefaultDisplay);
+    TEST_EGL_ERROR(iDisplay == EGL_NO_DISPLAY, EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor) == EGL_FALSE, EGL_BAD_DISPLAY);
+    TEST(major == -1 && minor == -1);   // Version is Not updated
+
+    // Terminate display
+    TEST_EGL_ERROR(eglTerminate(iDisplay) == EGL_FALSE, EGL_BAD_DISPLAY);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0511
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from a single thread
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Un-initialised display usage test
+
+@SYMTestActions
+Get default display
+Check return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Query string for vendor
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_Display_Negative_NotInitializedDisplay::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0511"));
+    INFO_PRINTF1(_L("CEglTest_Display_Negative_NotInitializedDisplay::doTestStepL"));
+
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Query string for vendor
+    INFO_PRINTF1(_L("Query string for vendor"));
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+
+    // Terminate display
+    TerminateDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0512
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from a single thread
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Reinitialise display test
+
+@SYMTestActions
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Query string for version
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Query string for version
+Check return value is not null and error code is EGL_SUCCESS
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_Display_Positive_ReinitializeDisplay::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0512"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_ReinitializeDisplay::doTestStepL"));
+
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+    
+    // Terminate display
+    INFO_PRINTF1(_L("Calling eglTerminate..."));
+    TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+    
+    // Query string for version
+    INFO_PRINTF1(_L("Query string for version..."));
+    const char* strEglVersion = eglQueryString(iDisplay, EGL_VERSION);
+    TEST_EGL_ERROR(strEglVersion == NULL, EGL_NOT_INITIALIZED);
+    
+    // Re-Initialise display object
+    major = -1;
+    minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+    
+    // Query string for version
+    INFO_PRINTF1(_L("Query string for version..."));
+    strEglVersion = eglQueryString(iDisplay, EGL_VERSION);
+    TEST_EGL_ERROR(strEglVersion != NULL, EGL_SUCCESS);
+
+    // Terminate display
+    TerminateDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0513
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize and eglTerminate behavior from a single thread
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Multiple initialisation test
+
+@SYMTestActions
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Query string for version
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_Display_Positive_MultipleInitialization::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0513"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_MultipleInitialization::doTestStepL"));
+
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+    
+    // Initialise display object
+    major = -1; 
+    minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+    
+    // Terminate display
+    INFO_PRINTF1(_L("Calling eglTerminate..."));
+    TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+    
+    // Query string for version
+    INFO_PRINTF1(_L("Query string for version..."));
+    const char* strEglVersion = eglQueryString(iDisplay, EGL_VERSION);
+    TEST_EGL_ERROR(strEglVersion == NULL, EGL_NOT_INITIALIZED);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0514
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize and eglTerminate behavior from a single thread
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Multiple termination test
+
+@SYMTestActions
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Query string for extensions
+Check return value is not null and error code is EGL_SUCCESS
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Query string for extensions
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Release thread
+Check return value is true
+
+Release thread
+Check return value is true
+*/
+TVerdict CEglTest_Display_Positive_MultipleTermination::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0514"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_MultipleTermination::doTestStepL"));
+
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+    
+    // Query string for extensions
+    INFO_PRINTF1(_L("Query string for extensions..."));
+    const char* strEglExtensions = eglQueryString(iDisplay, EGL_EXTENSIONS);
+    TEST_EGL_ERROR(strEglExtensions != NULL, EGL_SUCCESS);
+    
+    // Terminate display
+    INFO_PRINTF1(_L("Calling eglTerminate..."));
+    TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+    
+    // Terminate display
+    INFO_PRINTF1(_L("Calling eglTerminate..."));
+    TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+
+    // Query string for extensions
+    INFO_PRINTF1(_L("Query string for extensions..."));
+    strEglExtensions = eglQueryString(iDisplay, EGL_EXTENSIONS);
+    TEST_EGL_ERROR(strEglExtensions == NULL, EGL_NOT_INITIALIZED);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0515
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from multiple threads within a process
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Basic multi threaded test
+
+@SYMTestActions
+Main Thread
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Query string for vendor
+Check return value is not null and error code is EGL_SUCCESS
+
+Launch thread A
+Wait for thread A to exit
+    Thread A
+    Get default display
+    Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+    
+    Initialise display
+    Check return value is true, error code is EGL_SUCCESS and version is updated
+    
+    Query string for vendor
+    Check return value is not null and error code is EGL_SUCCESS
+    
+    Terminate display
+    Check return value is true and error code is EGL_SUCCESS
+    
+    Release thread
+    Check return value is true
+    Exit
+
+Main Thread
+Query string for vendor
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Release thread
+Check return value is true
+Exit
+*/
+TVerdict CEglTest_Display_Positive_Multithread_Basic::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0515"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_Multithread_Basic::doTestStepL"));
+
+    // Create display object
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);
+        
+    // Query string for vendor
+    INFO_PRINTF1(_L("Query string for vendor..."));
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+
+    INFO_PRINTF1(_L("Launch extra thread..."));
+    Test_MultiThreadL(1, ETrue);
+
+    // Query string for vendor
+    INFO_PRINTF1(_L("Query string for vendor..."));
+    strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+  
+    // Terminate display
+    TerminateDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Release thread
+    TEST(eglReleaseThread() == EGL_TRUE);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+void CEglTest_Display_Positive_Multithread_Basic::doThreadFunctionL(TInt aIdx)
+    {
+    INFO_PRINTF2(_L("CEglTest_Display_Positive_Multithread_Basic::doThreadFunctionL, Thread %d"),aIdx);
+    
+    INFO_PRINTF2(_L("Create display object from thread: %d"), aIdx);
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+
+    // Query string for vendor
+    INFO_PRINTF1(_L("Query string for vendor..."));
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+    
+    // Terminate display
+    INFO_PRINTF1(_L("Calling eglTerminate..."));
+    TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+    
+    TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0516
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize and eglTerminate behavior from multiple threads within a process
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Initialise and terminate display from one thread only
+
+@SYMTestActions
+Main Thread
+Launch thread A and B
+Wait for both thread A and B to exit
+
+    Thread A
+    Get default display
+    Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+    
+    Initialise display
+    Check return value is true, error code is EGL_SUCCESS and version is 1.4
+    
+    Rendezvous
+    
+    Thread A and B
+    Query string for vendor
+    Check return value is not null and error code is EGL_SUCCESS
+    
+    Rendezvous
+    
+    Thread A
+    Terminate display
+    Check return value is true and error code is EGL_SUCCESS
+    
+    Rendezvous
+    
+    Thread A and B
+    Query string for vendor
+    Check return value is null and error code is EGL_NOT_INITIALIZED
+    
+    Release thread
+    Check return value is true
+    Exit
+
+Main Thread
+Exit
+*/
+TVerdict CEglTest_Display_Positive_Multithread_InitTerminateInOneTread::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0516"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_Multithread_InitTerminateInOneTread::doTestStepL"));
+
+    INFO_PRINTF1(_L("Launch two threads"));
+    Test_MultiThreadL(2, ETrue);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+void CEglTest_Display_Positive_Multithread_InitTerminateInOneTread::doThreadFunctionL(TInt aIdx)
+    {
+    INFO_PRINTF2(_L("CEglTest_Display_Positive_Multithread_InitTerminateInOneTread::doThreadFunctionL, Thread %d"),aIdx);
+    
+    if(aIdx == 0)
+        {
+        INFO_PRINTF2(_L("Create display object from thread: %d"), aIdx);
+        GetDisplayL();
+        TEST(eglGetError() == EGL_SUCCESS);
+            
+        // Initialise display object
+        EGLint major = -1, minor = -1;
+        INFO_PRINTF2(_L("Calling eglInitialize from thread %d"),aIdx);
+        TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+        TEST(major != -1 && minor != -1);   // Version is updated
+        }
+    
+    Rendezvous(aIdx);
+    
+    // Query string for vendor
+    INFO_PRINTF2(_L("Query string for vendor from thread %d"), aIdx);
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+    
+    Rendezvous(aIdx);
+    
+    if(aIdx == 0)
+        {
+        INFO_PRINTF2(_L("Calling eglTerminate... from thread: %d"), aIdx);
+        TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+        }
+    
+    Rendezvous(aIdx);
+    
+    // Query string for vendor
+    INFO_PRINTF2(_L("Query string for vendor from thread %d"), aIdx);
+    strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+    
+    TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+    }
+
+/*
+@SYMTestCaseID GRAPHICS-EGL-0517
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from multiple threads within a process
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Initialise display from one thread and terminate from another thread
+
+@SYMTestActions
+Main Thread
+Launch thread A and B
+Wait for both thread A and B to exit
+
+    Thread A
+    Get default display
+    Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+    
+    Initialise display
+    Check return value is true, error code is EGL_SUCCESS and version is 1.4
+    
+    Rendezvous
+    
+    Thread A and B
+    Query string for vendor
+    Check return value is not null and error code is EGL_SUCCESS
+    
+    Rendezvous
+    
+    Thread B
+    Terminate display
+    Check return value is true and error code is EGL_SUCCESS
+    
+    Rendezvous
+    
+    Thread A and B
+    Query string for vendor
+    Check return value is null and error code is EGL_NOT_INITIALIZED
+    
+    Release thread
+    Check return value is true
+    Exit
+
+Main Thread
+Exit
+*/
+TVerdict CEglTest_Display_Positive_Multithread_InitTerminateFromDifferentThread::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0517"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_Multithread_InitTerminateFromDifferentThread::doTestStepL"));
+
+    INFO_PRINTF1(_L("Launch two threads"));
+    Test_MultiThreadL(2, ETrue);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+void CEglTest_Display_Positive_Multithread_InitTerminateFromDifferentThread::doThreadFunctionL(TInt aIdx)
+    {
+    INFO_PRINTF2(_L("CEglTest_Display_Positive_Multithread_InitTerminateFromDifferentThread::doThreadFunctionL, Thread %d"),aIdx);
+    
+    if(aIdx == 0)
+        {
+        INFO_PRINTF2(_L("Create display object from thread: %d"), aIdx);
+        GetDisplayL();
+        TEST(eglGetError() == EGL_SUCCESS);
+            
+        // Initialise display object
+        EGLint major = -1, minor = -1;
+        INFO_PRINTF2(_L("Calling eglInitialize from thread %d"),aIdx);
+        TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+        TEST(major != -1 && minor != -1);
+        }
+    
+    Rendezvous(aIdx);
+    
+    // Query string for vendor
+    INFO_PRINTF2(_L("Query string for vendor from thread %d"), aIdx);
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+
+    Rendezvous(aIdx);
+    
+    if(aIdx == 1)
+        {
+        INFO_PRINTF2(_L("Calling eglTerminate... from thread: %d"), aIdx);
+        TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+        }
+    
+    Rendezvous(aIdx);
+    
+    // Query string for vendor
+    INFO_PRINTF2(_L("Query string for vendor from thread %d"), aIdx);
+    strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+    
+    TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0518
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from multiple threads within a process
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Test large number of threads
+
+@SYMTestActions
+Main thread
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Launch 100 threads
+Wait for all threads to exit
+
+From each spawned thread
+Get default display
+Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+
+Initialise display
+Check return value is true, error code is EGL_SUCCESS and version is updated
+
+Query string for vendor
+Check return value is not null and error code is EGL_SUCCESS
+            
+Release thread
+Check return value is true
+Exit
+
+Main thread
+Terminate display
+Check return value is true and error code is EGL_SUCCESS
+
+Query string for vendor
+Check return value is null and error code is EGL_NOT_INITIALIZED
+
+Release thread
+Check return value is true
+Exit
+*/
+TVerdict CEglTest_Display_Positive_Multithread_Stress::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0518"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_Multithread_Stress::doTestStepL"));
+
+    INFO_PRINTF1(_L("Create display object from main thread"));
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    // launch 100 threads.
+    Test_MultiThreadL(100, EFalse);
+    
+    INFO_PRINTF1(_L("Calling eglTerminate from main thread"));
+    TEST_EGL_ERROR(eglTerminate(iDisplay), EGL_SUCCESS);
+    
+    // Query string for vendor
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor == NULL, EGL_NOT_INITIALIZED);
+    
+    TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+void CEglTest_Display_Positive_Multithread_Stress::doThreadFunctionL(TInt aIdx)
+    {
+    INFO_PRINTF2(_L("CEglTest_Display_Positive_Multithread_Stress::doThreadFunctionL, Thread %d"),aIdx);
+
+    //Create display objec
+    GetDisplayL();
+    TEST(eglGetError() == EGL_SUCCESS);
+        
+    // Initialise display object
+    EGLint major = -1, minor = -1;
+    INFO_PRINTF1(_L("Calling eglInitialize..."));
+    TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+    TEST(major != -1 && minor != -1);   // Version is updated
+
+    // Query string for vendor
+    const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+    TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+    
+    TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0519
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test eglGetDisplay, eglInitialize, eglTerminate and eglQueryString behaviors from multiple processes
+
+@SYMTestExpectedResults
+Return value and error code shall conform to EGL specification
+
+@SYMTestCaseDesc
+Basic multi process test
+
+@SYMTestActions
+Main Process
+Launch process A and B
+Wait until process A and B are terminated
+
+    Process A
+    Get default display
+    Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+    
+    Initialise display
+    Check return value is true, error code is EGL_SUCCESS and version is updated
+    
+    Query string for vendor
+    Check return value is not null and error code is EGL_SUCCESS
+    
+    Rendezvous
+    
+    Process B
+    Get default display
+    Check the return value is not EGL_NO_DISPLAY and error code is EGL_SUCCESS
+    
+    Initialise display
+    Check return value is true, error code is EGL_SUCCESS and version is updated
+    
+    Query string for vendor
+    Check return value is not null and error code is EGL_SUCCESS
+    
+    Terminate display
+    Check return value is true and error code is EGL_SUCCESS
+    
+    Release thread
+    Check return value is true
+    Exit
+    
+    Rendezvous
+    
+    Process A
+    Query string for vendor
+    Check return value is not null and error code is EGL_SUCCESS
+    
+    Terminate display
+    Check return value is true and error code is EGL_SUCCESS
+    
+    Release thread
+    Check return value is true
+    Exit
+
+Main Process
+Exit
+*/
+TVerdict CEglTest_Display_Positive_Multiprocess_Basic::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-0519"));
+    INFO_PRINTF1(_L("CEglTest_Display_Positive_Multiprocess_Basic::doTestStepL"));
+
+    INFO_PRINTF1(_L("Launch two processes"));
+    Test_MultiProcessL(KEglTestStepDllName, 2, KDisplay_Positive_Multiprocess_Basic);
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+void CEglTest_Display_Positive_Multiprocess_Basic::doProcessFunctionL(TInt aIdx)
+    {
+    INFO_PRINTF2(_L("CEglTest_Display_Positive_Multiprocess_Basic::doThreadFunctionL, Thread %d"),aIdx);
+    
+    if(aIdx == 0)
+        {
+        INFO_PRINTF2(_L("Create display object from Process: %d"), aIdx);
+        GetDisplayL();
+        TEST(eglGetError() == EGL_SUCCESS);
+        
+        // Initialise display object
+        EGLint major = -1, minor = -1;
+        INFO_PRINTF2(_L("Calling eglInitialize from Process %d"),aIdx);
+        TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+        TEST(major != -1 && minor != -1);   // Version is updated
+        
+        // Query string for vendor
+        INFO_PRINTF2(_L("Query string for vendor from Process %d"),aIdx);
+        const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+        TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+        }
+    
+    Rendezvous(aIdx);
+    
+    if(aIdx == 1)
+        {
+        INFO_PRINTF2(_L("Create display object from Process: %d"), aIdx);
+        GetDisplayL();
+        TEST(eglGetError() == EGL_SUCCESS);
+        
+        // Initialise display object
+        EGLint major = -1, minor = -1;
+        INFO_PRINTF2(_L("Calling eglInitialize from Process %d"),aIdx);
+        TEST_EGL_ERROR(eglInitialize(iDisplay, &major, &minor), EGL_SUCCESS);
+        TEST(major != -1 && minor != -1);   // Version is updated
+        
+        // Query string for vendor
+        INFO_PRINTF2(_L("Query string for vendor from Process %d"),aIdx);
+        const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+        TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+    
+        // Terminate display object
+        INFO_PRINTF2(_L("Terminate display from Process %d"),aIdx);
+        TerminateDisplayL();
+        TEST(eglGetError() == EGL_SUCCESS);
+        
+        TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+        }
+    
+    Rendezvous(aIdx);
+    
+    if(aIdx == 0)
+        {
+        // Query string for vendor
+        INFO_PRINTF2(_L("Query string for vendor from Process %d"),aIdx);
+        const char* strEglVendor = eglQueryString(iDisplay, EGL_VENDOR);
+        TEST_EGL_ERROR(strEglVendor != NULL, EGL_SUCCESS);
+    
+        // Terminate display object
+        INFO_PRINTF2(_L("Terminate display from Process %d"),aIdx);
+        TerminateDisplayL();
+        TEST(eglGetError() == EGL_SUCCESS);
+        
+        TEST_EGL_ERROR(eglReleaseThread() == EGL_TRUE, EGL_SUCCESS);
+        }    
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0520
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test the behaviour of eglGetDisplay in a Client heap OOM situation.
+
+@SYMTestExpectedResults
+No memory or handle leaks.
+
+@SYMTestCaseDesc
+Client heap OOM test
+
+@SYMTestActions
+Within a for loop that iterates through increasing memory failure at failAt:
+    *mark client heap with __UHEAP_SETFAIL(RHeap::EDeterministic,failAt)
+    *mark client heap with __UHEAP_MARK
+    *call eglGetDisplay()
+    *call eglGetError()
+    *reset client heap with __UHEAP_RESET
+    *If either egl function call fails and raises EGL_BAD_ALLOC, increase the failAt and restart the loop.
+If the procedure was successful release all the resources and check the client heap for memory leaks.
+No memory or handle leaks.
+*/
+TVerdict CEglTest_Display_OOM_ClientHeap::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-520"));
+    INFO_PRINTF1(_L("CEglTest_OOM_ClientHeap::doTestStepL"));
+    
+    EGLint errorCode = EGL_BAD_ALLOC;
+    for(TInt failAt=1; errorCode == EGL_BAD_ALLOC; ++failAt)
+        {
+        INFO_PRINTF2(_L("Set Client heap to fail at %u allocations"), failAt);
+        
+        __UHEAP_SETFAIL(RHeap::EDeterministic, failAt);
+        __UHEAP_MARK;
+        EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+        errorCode = eglGetError();
+        __UHEAP_RESET;
+        
+        if(display == EGL_NO_DISPLAY)
+            {
+            // If it's not EGL_BAD_ALLOC, loop will exit naturally.
+            TEST(errorCode == EGL_BAD_ALLOC);
+            __UHEAP_MARKEND;
+            }
+        else
+            {
+            // All memory failure points have been tested. So can exit the test.
+            TEST(errorCode == EGL_SUCCESS);
+            eglReleaseThread();
+            __UHEAP_MARKEND;
+            break;            
+            }        
+        }
+    
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+
+/**
+@SYMTestCaseID GRAPHICS-EGL-0521
+@SYMPREQ 2400
+@SYMTestPriority 1
+@SYMTestPurpose
+Test the behaviour of eglInitialize in a Client heap OOM situation.
+
+@SYMTestExpectedResults
+No memory or handle leaks.
+
+@SYMTestCaseDesc
+Client heap OOM test
+
+@SYMTestActions
+Get the display without setting memory failure.
+
+Within a for loop that iterates through increasing memory failure at failAt:
+    *mark client heap with __UHEAP_SETFAIL(RHeap::EDeterministic,failAt)
+    *mark client heap with __UHEAP_MARK
+    *call eglInitialize()
+    *call eglGetError()
+    *reset client heap with __UHEAP_RESET
+    *If either egl function call fails and raises EGL_BAD_ALLOC, increase the failAt and restart the loop.
+If the procedure was successful release all the resources and check the client heap for memory leaks.
+No memory or handle leaks.
+*/
+TVerdict CEglTest_Display_OOM_ClientHeap_Initialize::doTestStepL()
+    {
+    SetTestStepID(_L("GRAPHICS-EGL-521"));
+    INFO_PRINTF1(_L("CEglTest_Display_OOM_ClientHeap_Initialize::doTestStepL"));
+    
+    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    TEST(eglGetError() == EGL_SUCCESS);
+    
+    TEST(display != EGL_NO_DISPLAY);
+    if(display != EGL_NO_DISPLAY)
+        {
+        EGLint errorCode = EGL_BAD_ALLOC;
+        for(TInt failAt=1; errorCode == EGL_BAD_ALLOC; ++failAt)
+            {       
+            INFO_PRINTF2(_L("Set Client heap to fail at %u allocations"), failAt);
+            __UHEAP_SETFAIL(RHeap::EDeterministic, failAt);
+            __UHEAP_MARK;
+            EGLBoolean res = eglInitialize(display, NULL, NULL);
+            errorCode = eglGetError();
+            __UHEAP_RESET;
+                    
+            if(res == EGL_TRUE)
+                {
+                // All memory failure points have been tested. So can exit the test.
+                TEST(errorCode == EGL_SUCCESS);
+                TEST_EGL_ERROR(eglTerminate(display), EGL_SUCCESS);
+                __UHEAP_MARKEND;
+                 break;            
+                }
+            else
+                {
+                // If it's not EGL_BAD_ALLOC, loop will exit naturally.
+                TEST(errorCode == EGL_BAD_ALLOC);
+                __UHEAP_MARKEND;
+                }                                
+            }
+        }
+    
+    eglReleaseThread();
+  
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+    return TestStepResult();
+    }
+