// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "egltest_endpointimage.h"

#include "egltest_surface.h"

#include "egltest_endpoint_util.h"

CEglTest_LocalTestStep_EndpointImageLifetimeProcess::CEglTest_LocalTestStep_EndpointImageLifetimeProcess()

    {

    TRAPD(err, TEndpointUtil::SetLoggerForProcessWrapperL(Logger()));

    if (err != KErrNone)

        {

        RDebug::Printf("Logging is not set up... Err = %d. Panicking...", err);

        ENGINE_ASSERT(0);

        }

    }

//function used for creating the queues.

TVerdict CEglTest_LocalTestStep_EndpointImageLifetimeProcess::doTestStepPreambleL()

    {

    //Open the queues.

    User::LeaveIfError(iResultOutQueue.OpenGlobal(KResultProcessQueueName));

    User::LeaveIfError(iParamsInQueue.OpenGlobal(KParamsProcessQueueName));

    SetTestStepResult(EPass);

    return EPass;

    }

TVerdict CEglTest_LocalTestStep_EndpointImageLifetimeProcess::doTestStepPostambleL()

    {

    iResultOutQueue.Close();

    iParamsInQueue.Close();

    return EPass;

    }

CEglTest_LocalTestStep_EndpointImageLifetimeProcess::~CEglTest_LocalTestStep_EndpointImageLifetimeProcess()

    {

    //closing an already closed handle is harmless

    iResultOutQueue.Close();

    iParamsInQueue.Close();

    }

TVerdict CEglTest_LocalTestStep_EndpointImageLifetimeProcess::doTestStepL()

    {

    EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    if (!eglInitialize(dpy, NULL, NULL))

        {

        INFO_PRINTF2(_L("EglInitialize failed, error %x"), eglGetError());

        User::Leave(KErrNotFound);

        }

    TInt surfType;

    iResultOutQueue.ReceiveBlocking(surfType);

    CSurface *surface = CSurface::SurfaceFactoryL(static_cast<TSurfaceType>(surfType));

    CleanupStack::PushL(surface);

    surface->CreateL(EStandardSurface);

    INFO_PRINTF2(_L("Using surface type %s"), surface->GetSurfaceTypeStr());

    TSurfaceId id = surface->SurfaceId();

    iParamsInQueue.SendBlocking(id);

    TInt result;

    iResultOutQueue.ReceiveBlocking(result);

    // Draw something.

    surface->DrawContentL(0);

    surface->SubmitContentL(EFalse);

    if (result)

        {

        User::Panic(_L("Expected Panic"), 1);

        }

    eglTerminate(dpy);

    eglReleaseThread();

    CleanupStack::PopAndDestroy(surface);

    return EPass;

    }

// static

void CEglTest_LocalTestStep_EndpointImageLifetimeProcess::MainL()

    {

#ifdef __WINS__

    // Construct and destroy a process-wide state object in emulator builds.

    // This will cause initialisation of PLS for EGL and SgDriver

    // and allow checking for leaks in tests

    eglReleaseThread();

#endif //__WINS__

    // Create test step and perform CTestStep style initialisation (e.g. logging)

    CEglTest_LocalTestStep_EndpointImageLifetimeProcess* testStep = new CEglTest_LocalTestStep_EndpointImageLifetimeProcess();

    if (testStep == NULL)

        {

        User::Leave(KErrNotFound);

        }

    CleanupStack::PushL(testStep);

    // perform CTestStep pre-amble

    User::LeaveIfError(testStep->doTestStepPreambleL());

    testStep->doTestStepL();

    // perform CTestStep post-amble

    User::LeaveIfError(testStep->doTestStepPostambleL());

    //clean-up

    CleanupStack::PopAndDestroy(testStep);

    }

GLDEF_C TInt E32Main()

    {

    //When EGL Logging is enabled this causes a file server session to be allocated

    //Which needs to be done before any allocation checks otherwise the test will fail

    eglReleaseThread();

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if(cleanup == NULL)

        {

        return KErrNoMemory;

        }

    TRAPD(err, CEglTest_LocalTestStep_EndpointImageLifetimeProcess::MainL());

    delete cleanup;

    __UHEAP_MARKEND;

    return err;

    }