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

     {

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

     TInt err = iFs.Delete(KSimLoadConfigFile);

     TEST(err==KErrNone);

     }

 /**

  *    class CTReadWriteMain

  *    A Child of CTReadWrite which contains member data not included in the base class and 

  *    implementations of pure virtual functions.

  *    a) One for each particular test case

  *    b) Support functions MakeCurrentL() and IsFinished()

  *    

  *    The base class is an active object and the implemented virtual functions are invoked

  *    indirectly from the RunL() function

  */

 CTReadWriteMain::CTReadWriteMain(EGLDisplay aDisplay, EGLSurface aSurface, EGLContext aContext, TInt aWidth, TInt aHeight, TInt aByteSize, VGImageFormat aFormat, TBool& aTestPass, TInt& aFinishedCounter, const TTestType& aTestType)

 : CTReadWrite(aWidth, aHeight, aByteSize, aFormat, aTestType, aTestPass),

     iDisplay(aDisplay),

     iSurface(aSurface),

     iContext(aContext),

     iFinishedCounter(aFinishedCounter)

     {

     }

 CTReadWriteMain* CTReadWriteMain::NewL(EGLDisplay aDisplay, EGLSurface aSurface, EGLContext aContext, TInt aWidth, TInt aHeight, TInt aByteSize, VGImageFormat aFormat, TBool& aTestPass, TInt& aFinishedCounter, const TTestType& aTestType, VGImage aVGImage)

     {

     CTReadWriteMain* self = new (ELeave) CTReadWriteMain(aDisplay, aSurface, aContext, aWidth, aHeight, aByteSize, aFormat, aTestPass, aFinishedCounter, aTestType);

     CleanupStack::PushL(self);

     self->ConstructL(aVGImage);

     CleanupStack::Pop(self);

     return self;

     }

 void CTReadWriteMain::ConstructL(VGImage aVGImage)

     {

     //NULL values indicate a programming error

     if( (iDisplay == EGL_NO_DISPLAY) || (iSurface == EGL_NO_SURFACE) || (iContext == EGL_NO_CONTEXT) || (iFinishedCounter == 0) || ((iTestType == EStressVGImage) && (aVGImage == NULL)) )

         {

         User::Leave(KErrArgument);

         }

     iVGImage = aVGImage;

     //Call base class function to complete construction

      CTReadWrite::ConstructL();

     }

 void CTReadWriteMain::MakeCurrentL() const

     {

     EGL_LEAVE_ERROR(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));

     }

 void CTReadWriteMain::ReadImageFuncL()

     {

     vgReadPixels(iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);

     VgLeaveIfErrorL();

     }

 void CTReadWriteMain::ReadFuncL()

     {

     ReadImageFuncL();

     }

 void CTReadWriteMain::WriteImageFuncL()

     {

     vgWritePixels(iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);

     VgLeaveIfErrorL();

     }

 TBool CTReadWriteMain::IsFinished()

     {

     iFinishedCounter--;

     if(iFinishedCounter <= 0)

         {

         return ETrue;

         }

     return EFalse;

     }

 void CTReadWriteMain::VgImageFuncL()

     {

     //Alter the image data, actual pixel values are not important

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

         {

         const TUint32 temp = iBufferSize % iFrameNumber;

         iData[i] = temp + (temp << 8) + (temp << 16) + (temp << 24);

         }

     //Currently panics as context->scanlinebuffer is NULL

     vgImageSubData(iVGImage, iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);

     VgLeaveIfErrorL();

     EGL_LEAVE_ERROR(eglSwapBuffers(iDisplay, iSurface));

     }

 void CTReadWriteMain::PixmapSurfaceFuncL()

     {

     // clear surface background to an arbitrary colour

     VGfloat arbitraryColour = (1.0*iFrameNumber)/KNumberOfFrames;

     VGfloat backgroundColour[] = {1.0 - arbitraryColour/2, arbitraryColour/2, 1.0 - arbitraryColour, arbitraryColour};

     vgSetfv(VG_CLEAR_COLOR, 4, backgroundColour);

     VgLeaveIfErrorL();

     vgClear(0, 0, iWidth, iHeight);

     VgLeaveIfErrorL();

     EGL_LEAVE_ERROR(eglSwapBuffers(iDisplay, iSurface));

     }