// Copyright (c) 2010 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 <s32file.h>

#include <test/t_simload.h>

#include <test/tefunit.h>    //ASSERT_TRUE

#include "egltest_stress_sgimage.h"

TVerdict CEglTest_Stress::doTestStepL()

    {

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

    TBuf<100> testCaseId;

    TestCaseName(testCaseId);

    SetTestStepID(testCaseId);

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    __UHEAP_MARK;

    //File server is used to generate simload ini file

    User::LeaveIfError(iFs.Connect());

    TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KVG_KHR_EGL_image | KEGL_KHR_image_pixmap);

    if(!ret)

        {

        // The extension is not supported

        RecordTestResultL();

        CloseTMSGraphicsStep();

        return TestStepResult();

        }

    //Create a config file and launch the simulated load app

    ReadIniValuesL();

    PrintConfigDataL();

    CreateSimLoadAppL();

    INFO_PRINTF1(_L("Creating a Semaphore to signal all child processes at once"));

    RSemaphore sem;

    User::LeaveIfError(sem.CreateGlobal(KEglStressTest(), iNumberChildProcesses));

    CleanupClosePushL(sem);

    //Information to be passed to the child process

    TSgImageInfo info;

    TSize size(iRSgImageWidth, iRSgImageHeight);

    info.iUsage = ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface;

    info.iPixelFormat = iFormat;

    info.iSizeInPixels = size;

    //Utilise egl helper functions

    CreateEglSessionL();

    //Create a display and initialise it

    GetDisplayL();

    iEglSess->InitializeL();

    //Open RSGImage driver    

    iEglSess->OpenSgDriverL();

    EGL_LEAVE_ERROR(eglBindAPI(EGL_OPENVG_API));

    EGLContext context;

    for(TInt i=0; i<iNumberRSgImages; i++)

        {

        RSgImage image;

        iSgImageArray.InsertL(image, i);

        User::LeaveIfError(iSgImageArray[i].Create(info, NULL, NULL));

        EGLConfig config;

        if(i == 0)

            {

            //Only need to determine a matching configuration once

            ChooseConfigAndCreateContextL(iDisplay, context, config, iSgImageArray[i], KStressTestMainAppPanic, iAlphaPre);

            }

        EGLSurface surface = EGL_NO_SURFACE; //remove arm warning

        EGL_LEAVE_NULL(surface, CreatePixmapSurfaceL(iDisplay, config, iSgImageArray[i], iAlphaPre));

        EGL_LEAVE_ERROR(eglMakeCurrent(iDisplay, surface, surface, context));

        PaintSurfaceL(iDisplay, surface, context);

        EGL_LEAVE_ERROR(eglSwapBuffers(iDisplay, surface));

        if(iTestType == EStressVGImage)

            {

            EGL_LEAVE_ERROR(eglMakeCurrent(iDisplay, surface, surface, context));

            EGLImageKHR eglImage = 0; //removes arm compiler warning

            VGImage vgImage;

            EGL_LEAVE_NULL(eglImage, iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &iSgImageArray[i], (int*)KEglImageAttribsPreservedTrue));

            EGL_LEAVE_NULL(vgImage, iEglSess->vgCreateImageTargetKHR(eglImage));

            //Close the EGLImage

            EGL_LEAVE_ERROR(iEglSess->DestroyEGLImage(iDisplay, eglImage));

            User::LeaveIfError(iVGImageArray.Insert(vgImage, i));

            }

        User::LeaveIfError(iSurfaceArray.Insert(surface, i));

        }

    /* Create and install the active scheduler */

    CActiveScheduler* sched = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(sched);

    CleanupStack::PushL(sched);

    TInt exitCounter = iNumberMainImages;

    TBool testResult = ETrue;

    //Create an active object for each RSgImage accessed in the main process

    CTReadWriteMain* painter = 0;

    for(TInt i=0; i<iNumberMainImages; i++)

        {

        if(iTestType == EStressVGImage)

            {

            painter = CTReadWriteMain::NewL(iDisplay, iSurfaceArray[i], context, iRSgImageWidth, iRSgImageHeight, iByteSize, iVgFormat, testResult, exitCounter, iTestType, iVGImageArray[i]);

            }

        else

            {

            painter = CTReadWriteMain::NewL(iDisplay, iSurfaceArray[i], context, iRSgImageWidth, iRSgImageHeight, iByteSize, iVgFormat, testResult, exitCounter, iTestType);            

            }

        CleanupStack::PushL(painter);

        painter->After(TTimeIntervalMicroSeconds32(0));

        }

    CreateChildProcessesL();

    INFO_PRINTF1(_L("Signaling all child processes at once - starts data access in the child processes"));

    sem.Signal(iNumberChildProcesses);

    //Start the active scheduler - starts data access in the main process

    sched->Start();

    if(testResult == EFalse)

        {

		if (iTestType == EStressReadWriteSingleImage || iTestType == EStressReadWriteMultiImage)

			{

			// For GRAPHICS-EGL-0428 and GRAPHICS-EGL-0437 data integrity cannot be guaranteed on 

			// all implementations, so the pixel value checking aspects of these tests are regarded as optional   

			WARN_PRINTF1(_L("Unexpected pixel colour"));

			}

		else

			{

			ERR_PRINTF1(_L("Unexpected pixel colour"));

			SetTestStepResult(EFail);

			}

        }

    //Check that each child process has completed without error

    for(TInt i=0; i<iNumberChildProcesses; i++)

       {

       TRequestStatus status;

       iProcessArray[i].Logon(status);

       User::WaitForRequest(status);

       if(status != KErrNone)

           {

		   if (status == KTestStressUnexpectedPixelError && (iTestType == EStressReadWriteSingleImage || iTestType == EStressReadWriteMultiImage))

			   {

			   // For GRAPHICS-EGL-0428 and GRAPHICS-EGL-0437 data integrity cannot be guaranteed on 

			   // all implementations, so the pixel value checking aspects of these tests are regarded as optional

			   // So check that if it fails, it fails for the expected reason of no matching pixel.

			   WARN_PRINTF2(_L("Child Process completed with code %d, expected KErrNone"), status.Int());

			   }

		   else

			   {

			   ERR_PRINTF2(_L("Child Process completed with code %d, expected KErrNone"), status.Int());

			   SetTestStepResult(EFail);

			   }

           }

       }

    DestroySimLoadProcess();

    DeleteConfigData();

    ClearDownArraysL(iDisplay);

    EGL_LEAVE_ERROR(eglDestroyContext(iDisplay, context));

    CleanupStack::PopAndDestroy(iNumberMainImages + 2, &sem); //(iNumberMainImages + 1) active objects, sched, sem

    iEglSess->CloseSgDriver();

    CleanAll();

    iFs.Close();

    __UHEAP_MARKEND;

#else

    INFO_PRINTF2(_L("%S can only be run with SgImage-Lite"), &testCaseId);

#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    //Comply with the terrific TMS

    RecordTestResultL();

    CloseTMSGraphicsStep();

    return TestStepResult();

    }

CEglTest_Stress::~CEglTest_Stress()

    {

    //Free memory and close handles in case of panic in the doTestStepL()

    delete iEglSess;

    iFs.Close();

    iSurfaceArray.Close();

    iProcessArray.Close();

    iSgImageArray.Close();

    iVGImageArray.Close();

    }

void CEglTest_Stress::PaintSurfaceL(EGLDisplay aDisplay, EGLSurface aSurface, EGLContext aContext)

    {

    //Clear surface background, format of the constant is ARGB

    //Match the colour to that of the defined constant

    VGfloat red = 0.0;

    VGfloat green = 0.0;

    VGfloat blue = 0.0;

    VGfloat alpha = 0.0;

    //Care taken to avoid fixed width -> floating point -> fixed width rounding errors

    if(iByteSize == 4)

        {

        red = 1.0 * ((KColourInitial32 & 0x00FF0000) >> 16)/255;

        green = 1.0 * ((KColourInitial32 & 0x0000FF00) >> 8)/255;

        blue = 1.0 * (KColourInitial32 & 0x000000FF)/255;

        alpha = 1.0 * ((KColourInitial32 & 0xFF000000) >> 24)/255;        

        }

    else //iByteSize == 2

        {

        red = 1.0 * ((KColourInitial16 & 0x7C00) >> 11)/31;

        green = 1.0 * ((KColourInitial16 & 0x0480) >> 5)/63;

        blue = 1.0 * (KColourInitial16 & 0x001F)/31;

        }

    //Format of the constant is RGBA (32 bit) 

    VGfloat bgColor[] = {red, green, blue, alpha};

    EGL_LEAVE_ERROR(eglMakeCurrent(aDisplay, aSurface, aSurface, aContext));

    vgSetfv(VG_CLEAR_COLOR, 4, bgColor);

    ASSERT_VG_TRUE(vgGetError() == VG_NO_ERROR);

    vgClear(0, 0, iRSgImageWidth, iRSgImageHeight);

    ASSERT_VG_TRUE(vgGetError() == VG_NO_ERROR);

    }

void CEglTest_Stress::CreateChildProcessL(TInt aProcessNumber, TTestType aTestType, TSgDrawableId aDrawableId)

    {

    TRequestStatus status;

    RProcess client;

    User::LeaveIfError(client.Create(KStressTestClientApp, KNullDesC));

    //Pass image and test information to the child process

    TStressProcessInfo info;

    info.iTestType = aTestType;

    info.iSgId = aDrawableId;

    info.iByteSize = iByteSize;

    info.iAlphaPre = iAlphaPre;

    TPckg<TStressProcessInfo> pckgInfo(info);

    User::LeaveIfError((client.SetParameter(KMultiProcessSlot, pckgInfo)));

    client.Rendezvous(status);

    client.Resume();

    User::WaitForRequest(status);

    TEST(status == KErrNone);

    //Store image handle for cleanup

    iProcessArray.InsertL(client, aProcessNumber);

    }

void CEglTest_Stress::CreateChildProcessesL()

    {

    for(TInt i=0; i<iNumberChildProcesses; i++)

        {

        switch(iTestType)

            {

            case EStressReadWriteMultiImage:

            case EStressPixmapSurface:

                {

                //Each child process accesses one SgImage

                CreateChildProcessL(i, iTestType, iSgImageArray[i].Id());

                break;

                }

            case EStressRead:

            case EStressReadWriteSingleImage:

            case EStressVGImage:

                {

                //All child processes access the same SgImage

                CreateChildProcessL(i, iTestType, iSgImageArray[0].Id());

                break;

                }

            default:

                User::Panic(KStressTestMainAppPanic, KErrNotFound);

                break;

            }

        }

    }

void CEglTest_Stress::ClearDownArraysL(EGLDisplay aDisplay)

    {

    for(TInt i=0; i<iSurfaceArray.Count(); i++)

        {

        ASSERT_EGL_TRUE(eglDestroySurface(aDisplay, iSurfaceArray[i]));

        }

    for(TInt i=0; i<iVGImageArray.Count(); i++)

        {

        vgDestroyImage(iVGImageArray[i]);

        ASSERT_VG_TRUE(vgGetError() == VG_NO_ERROR);

        }

    for(TInt i=0; i<iProcessArray.Count(); i++)

        {

        iProcessArray[i].Close();

        }

    for(TInt i=0; i<iSgImageArray.Count(); i++)

        {

        iSgImageArray[i].Close();

        }

    iSurfaceArray.Close();

    iProcessArray.Close();

    iSgImageArray.Close();

    iVGImageArray.Close();

    }

void CEglTest_Stress::CreateSimLoadAppL()

    {

    TInt index = 1;

    TBuf<100> tempStore;

    //Three simload processes need to be launched t_simloadapp1.exe - t_simloadapp3.exe

    while(index <= KNumSimLoadApps)

        {

        tempStore.Format(KSimLoadApp, index++);

        CreateSimLoadProcessL(tempStore);

        }

    }

void CEglTest_Stress::CreateSimLoadProcessL(const TDesC& aApp)

    {

    INFO_PRINTF2(_L("Starting App: %S"), &aApp);

    RProcess process;

    User::LeaveIfError(process.Create(aApp, KNullDesC));

    //Give the simulated load high priority to be sure it does its job

    process.SetPriority(EPriorityHigh);

    TEST(process.Priority() == EPriorityHigh);

    INFO_PRINTF3(_L("Process Priority: Actual: %d, Expected: %d"), process.Priority(), EPriorityHigh);

    process.Resume();

    iProcessList.AppendL(process);

    }

void CEglTest_Stress::DestroySimLoadProcess()

    {

    for (TInt index = 0; index < iProcessList.Count(); index++)

        {

        // check process

        INFO_PRINTF3(_L("Process Check: Actual: %d, Expected: %d"), iProcessList[index].ExitReason(), KErrNone);

        TEST(iProcessList[index].ExitReason( )== KErrNone);

        // kill process

        iProcessList[index].Kill(KErrGeneral);

        INFO_PRINTF3(_L("Process Exit Reason: Actual: %d, Expected: %d"), iProcessList[index].ExitReason(), KErrGeneral);

        TEST(iProcessList[index].ExitReason() == KErrGeneral);

        iProcessList[index].Close();

        }

    iProcessList.Close();

    }

void CEglTest_Stress::ReadIniValueL(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult)

    {

    if(!GetIntFromConfig(aSectName, aKeyName, aResult))

        {

        ERR_PRINTF2(_L("Error reading %S value from ini file"), &aKeyName);

        User::Leave(KErrNotFound);

        }

    INFO_PRINTF3(_L("Ini file value %S = %d"), &aKeyName, aResult);

    }

void CEglTest_Stress::ReadIniValuesL()

    {

    ReadIniValueL(ConfigSection(), KNumberRSgImages, iNumberRSgImages);

    ReadIniValueL(ConfigSection(), KNumberMainImages, iNumberMainImages);

    ReadIniValueL(ConfigSection(), KNumberChildProcesses, iNumberChildProcesses);

    ReadIniValueL(ConfigSection(), KRSgImageWidth, iRSgImageWidth);

    ReadIniValueL(ConfigSection(), KRSgImageHeight, iRSgImageHeight);

    ReadIniValueL(ConfigSection(), KConfigSimLoadValue, iSimLoadValue);

    //Check for erroneous ini values

    ASSERT_TRUE(iNumberChildProcesses <= iNumberRSgImages);

    ASSERT_TRUE(iNumberMainImages <= iNumberRSgImages);

    ASSERT_TRUE(iRSgImageWidth >= 0);

    ASSERT_TRUE(iRSgImageHeight >= 0);

    ASSERT_TRUE(iSimLoadValue >= 0);

    ASSERT_TRUE(iSimLoadValue <= 100);

    TBuf16<100> buffer;

    TPtrC16 ptrBuffer(buffer);

    if(!GetStringFromConfig(ConfigSection(), KPixelFormat, ptrBuffer))

        {

        ERR_PRINTF2(_L("Error reading %S value from ini file"), &KPixelFormat);

        User::Leave(KErrNotFound);

        }

    INFO_PRINTF3(_L("Ini file value %S = %S"), &KPixelFormat, &ptrBuffer);

    //Derive information from the pixel format

    if(ptrBuffer == KUidPixelFormatARGB_8888)

        {

        iFormat = EUidPixelFormatARGB_8888;

        iVgFormat = VG_sARGB_8888;

        iAlphaPre = EFalse;

        iByteSize = 4;

        }

    else if(ptrBuffer == KUidPixelFormatARGB_8888_PRE)

        {

        iFormat = EUidPixelFormatARGB_8888_PRE;

        iVgFormat = VG_sARGB_8888_PRE;

        iAlphaPre = ETrue;

        iByteSize = 4;

        }

    else if(ptrBuffer == KUidPixelFormatRGB_565)

        {

        iFormat = EUidPixelFormatRGB_565;

        iVgFormat = VG_sRGB_565;

        iAlphaPre = EFalse;

        iByteSize = 2;

        }

    else

        {

        ERR_PRINTF2(_L("Unsupported pixel format %S"), &ptrBuffer);

        User::Leave(KErrNotFound);

        }

     //Determine the test type from the ini file section name

     if(ConfigSection().Find(KStressReadOnly) != KErrNotFound)

         {

         iTestType = EStressRead;

         }

     else if(ConfigSection().Find(KEStressReadWriteSingleImage) != KErrNotFound)

         {

         iTestType = EStressReadWriteSingleImage;

         }

     else if(ConfigSection().Find(KStressReadWriteMultiImage) != KErrNotFound)

         {

         iTestType = EStressReadWriteMultiImage;

         }

     else if(ConfigSection().Find(KStressVGImage) != KErrNotFound)

         {

         iTestType = EStressVGImage;

         }

     else if(ConfigSection().Find(KStressPixmapSurface) != KErrNotFound)

         {

         iTestType = EStressPixmapSurface;

         }

     else

         {

         ERR_PRINTF2(_L("Unknown test case %S"), &ptrBuffer);

         User::Leave(KErrNotFound);

         }

    }

/** 

 *   This function generates an ini file for the simulated load application

 *   containing two lines to determine

 *   1. The type of load (static or spiked, in this case always static)

 *   2. The simulated load level

 */

void CEglTest_Stress::PrintConfigDataL()

    {

    RFileWriteStream writer;

    writer.PushL();

    TInt err = iFs.MkDirAll(KSimLoadConfigFile);

    TEST(err == KErrNone || err == KErrAlreadyExists);

    INFO_PRINTF2(_L("Create Config File: %S"), &KSimLoadConfigFile);

    User::LeaveIfError(writer.Replace(iFs, KSimLoadConfigFile, EFileStreamText|EFileWrite));

    writer.CommitL();

    CleanupStack::PopAndDestroy(&writer);

    CIniData* data=CIniData::NewL(KSimLoadConfigFile);

    CleanupStack::PushL(data);

    INFO_PRINTF3(_L("Config Name: %S, \t\tConfig Data: %S"), &KConfigSimLoadType, &KConfigSimLoadStatic);

    err = data->AddValue(KDefaultSectionName, KConfigSimLoadType, KConfigSimLoadStatic);

    INFO_PRINTF3(_L("AddValue - Expected: %d, Actual: %d"), KErrNone, err);

    TEST(err == KErrNone);

    TBuf16<100> buffer;

    TPtrC16 ptrBuffer(buffer);

    User::LeaveIfError(GetStringFromConfig(ConfigSection(), KConfigSimLoadValue, ptrBuffer));

    INFO_PRINTF3(_L("Config Name: %S, \t\tConfig Data: %S"), &KConfigSimLoadValue, &ptrBuffer);

    err = data->AddValue(KDefaultSectionName, KConfigSimLoadValue, ptrBuffer);

    INFO_PRINTF3(_L("AddValue - Expected: %d, Actual: %d"), KErrNone, err);

    TEST(err == KErrNone);

    data->WriteToFileL();

    CleanupStack::PopAndDestroy(data);

    }

void CEglTest_Stress::DeleteConfigData()

    {