// Copyright (c) 2009-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

 @internalComponent - Internal Symbian test code

*/

#include <e32std.h>

#include <e32math.h>

#include <e32atomics.h>

#include "egltest_endpoint_engine.h"

#include "egltest_endpoint_stress_engine.h"

CStressTestEngine * CStressTestEngine::NewL(const TStressTestTable aStressTable[], TUint aNumTables)

    {

    CStressTestEngine *self = new (ELeave) CStressTestEngine;

    CleanupStack::PushL(self);

    self->ConstructL(aStressTable, aNumTables);

    CleanupStack::Pop(self);

    return self;

    }

void CStressTestEngine::ConstructL(const TStressTestTable aStressTable[], TUint aNumCases)

    {

    iStressTable = aStressTable;

    iNumCases = aNumCases;

    }

// DoPreamble - called from framework, set up list of Test IDs, so that we can

// mark them done later on - this is different from the regular 

//  CEglTest_Engine_Local code in that the data structure is different.

//

// Then call the common part with the regular CEglTest_Engine_Local 

void CStressTestEngine::DoPreambleL()

    {

    for(TInt curOuterCase = 0; curOuterCase < iNumCases; curOuterCase++)

        {

        const TTestCaseBase& innerCases = iStressTable[curOuterCase].iTestCaseBase;

        TPtrC testIds(innerCases.iRelatedTestIds);

        RegisterTestIdsL(testIds);

        }

    CommonPreambleL();

    }

// Derived function from CEglTest_Engine_Local, so that we can keep the local

// test result. 

void CStressTestEngine::DoPostambleL()

    {

    // Don't loose the verdict.

    TVerdict v = TestStepResult();

    CEgltest_Local_Engine::DoPostambleL();

    SetTestStepResult(v);

    }

CStressTestEngine::CStressTestEngine()

    {

    }

CStressTestEngine::~CStressTestEngine()

    {

    }

// Check if the entry needs modification, if so modify it. Modification is 

// indicated by presence of a flag bit and an index for which parameter

// to use. 

void CStressTestEngine::DoModifyL(TInt& aItem)

    {

    if (aItem & EExpandParamFlag)

        {

        TInt paramIndex = (aItem & EParamMask) >> EParamShift;

        if (!iParams[paramIndex])

            {

            ERR_PRINTF2(_L("Using undefined parameter PARAM%d"), paramIndex);

            User::Leave(KErrArgument);

            }

        User::LeaveIfNull(iParams[paramIndex]);

        aItem &= ERemoveFlagsMask;

        aItem += iParams[paramIndex]->Value();

        }

    }

// Modification of parameters of the testcase entry.

void CStressTestEngine::ModifyL(TEngineTestCase &aTestCase)

    {

    DoModifyL(aTestCase.iEndpointIndex);

    DoModifyL(aTestCase.iImageIndex);

    DoModifyL(aTestCase.iArg1);

    DoModifyL(aTestCase.iArg2);

    }

// Move to the next parameter for the parameter set.

void CStressTestEngine::NextParams()

    {

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

        {

        // Only update parameters that have been created.

        if (iParams[i])

            {

            iParams[i]->Next();

            }

        }

    }

// Create parameter set.

void CStressTestEngine::CreateParams(const TStressTestSection &aSection)

    {

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

        {

        ENGINE_ASSERT(!iParams[i]);

        iParams[i] = CStressParam::Factory(aSection.iParams[i]);

        }

    }

// Destroy parameter set.

void CStressTestEngine::DestroyParams()

    {

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

        {

        // It is harmless to delete a non-existant parameter, so 

        // no check needed.

        delete iParams[i];

        iParams[i] = NULL;

        }

    }

// Set the verdict for this operation on the local exec thread.

void CStressTestEngine::UpdateVerdict(TVerdict aVerdict)

    {

    TRemoteTestParams params;

    params.iEndpointEngine.iEngineTestCase.iCase = ESetVerdictCase;

    params.iEndpointEngine.iEngineTestCase.iEndpointIndex = EPass;

    TExecResult result;

    RunLocalTestCase(params, result);

    RunRemoteTestCase(ESetVerdictCase, params); 

    SetTestStepResult(aVerdict);

    }

// Look at the error value and update the verdict accordingly.

// Returns true if we should stop the iterating over the rest of the section.

// @param aSection - the section currently being executed.

// @param aCopy - the current iteration of the loop. 

// @param aCopies - total number of iterations to run. 

// @param aCurSection - numeric indication of the section. 

// @param aPreviousCopiesRun - updated according to policy to indicate how

//      many iterations to run the next section. 

TBool CStressTestEngine::HandleError(

        const TStressTestSection &aSection, 

        TInt aCopy, 

        TInt aCopies, 

        TInt aCurSection,

        TInt &aPreviousCopiesRun)

    {

    switch(aSection.iErrorPolicy)

        {

        case EOnErrorPolicyContinue:

            // Just let it pass...

            UpdateVerdict(EPass);

            break;

        case EOnErrorPolicyFail:

            // We should not have errors here.

            UpdateVerdict(EFail);

            break;

        case EOnErrorPolicyBreak:

            // Do not continue after errors.

            INFO_PRINTF4(_L("Ran only %d iterations of %d of section %d [not a failure]"), 

                    aCopy, aCopies, aCurSection);

            aPreviousCopiesRun = aCopy-1;

            UpdateVerdict(EPass);

            return ETrue;

        default:

            ENGINE_ASSERT(0);

            break;

        }

    return EFalse;

    }

// The main loop for the test. 

// Brief pseudo-code: 

// for each testcase

//   for each surface_type

//     for each section

//       for each copy of the section

//         perform engine operation

// Copy is really just an iteration. 

// The above pseudo-code is very simplified, but shows the overall flow. 

// Complications ommitted are:

// 1. We should adjust the number of iterations to run if there are errors.

// 2. We need to check for errors, and depending on circumstances, alter

//    the verdict.

TVerdict CStressTestEngine::doTestStepL()

    {

    INFO_PRINTF2(_L("Executing test with %d cases..."), iNumCases);

    for(TInt tests = 0; tests < iNumCases; tests++)

        {

        TTestCase tc;

        RDebug::Printf("%s:%d: tests = %d", __FILE__, __LINE__, tests);

        tc.iBase = iStressTable[tests].iTestCaseBase;

        TPtrC testIds(tc.iBase.iRelatedTestIds);

        SetCurrentTestIds(testIds);

        for(TInt surfIter= 0; surfIter < tc.iBase.iSurfaceTypeCount; surfIter++)

            {

            TInt previousCopiesRun = 1;

            TSurfaceType surfType = tc.iBase.iSurfaceTypeList[surfIter];

            INFO_PRINTF4(_L("Running testcase GRAPHICS-EGL-%s: %s (surf=%d)"),

                    tc.iBase.iRelatedTestIds, tc.iBase.iName, surfType);

            TRemoteTestParams configParams = {};

            configParams.iEndpointEngineConfig.iLogErrors = EFalse; 

            StartRemoteTestStep(configParams);

            for(TInt curSection = 0; curSection < iStressTable[tests].iNumSections; curSection++)

                {

                INFO_PRINTF3(_L("Section %d, result=%d"), curSection, TestStepResult());

                const TStressTestSection &section = iStressTable[tests].iSections[curSection];

                CreateParams(section);

                TInt copies = section.iIterations;

                if (section.iErrorPolicy == EOnErrorPolicyBreak)

                    {

                    if (section.iIterations != 1 && previousCopiesRun == 1)

                        {

                        previousCopiesRun = section.iIterations;

                        }

                    // We should not run more than iCopies times, but also not 

                    // allow previousCopiesRun to be zero to completely avoid 

                    // running a section.

                    copies = Min(section.iIterations, Max(previousCopiesRun, 1));

                    }

                for(TInt copy = 0; copy < copies; copy++)

                    {

                    // Make a copy and put it into the "tc" variable that we set up earlier....

                    TInt i = 0;

                    for(; section.iEngineTestCase[i].iCase != EFinishedCase; i++)

                        {

                        TEngineTestCase ec = section.iEngineTestCase[i];

                        ModifyL(ec);

                        tc.iEngineTestCase[i] = ec;

                        }

                    tc.iEngineTestCase[i].iCase = EFinishedCase;

                    TRAPD(err, RunSingleCaseL(tc, surfType));

                    if (err != KErrNone)

                        {

                        INFO_PRINTF2(_L("RunSingleCaseL left with an error: %d"), err);

                        }

                    if (err != KErrNone || TestStepResult() != EPass)

                        {

                        if (HandleError(section, copy, copies, 

                                curSection, previousCopiesRun))

                            {

                            break;

                            }

                        }

                    NextParams();

                    }

                DestroyParams();

                }              

            // params are not used in this call, so we just pass some suitable type in.

            // Save the result, as the remote side may have failed, but it's

            // not a real failure in a stress-test.

            TVerdict v = TestStepResult();

            EndRemoteTestStep(configParams);

            SetTestStepResult(v);

            }

        }

    return TestStepResult();

    }

// Derived function to start a thread. 

void CStressTestEngine::StartThreadL(TInt aThreadNumber)

    {

    const TInt KStackSize = 12000;

    const TInt KHeapMinSize = 16000;

    const TInt KHeapMaxSize = 1000000;

    if (aThreadNumber >= KMaxLoadThreads)

        {

        User::Panic(_L("StartThreadL"), __LINE__);

        }

    __e32_atomic_store_rel32(&iStopThreadFlag[aThreadNumber], EFalse);

    TUint32 random = Math::Random();

    TName threadName;

    _LIT(KThreadNameFormat, "%S-%u");

    // Create a loadthread. 

    _LIT(KThreadName, "EpTestLoadThread");

    threadName.Format(KThreadNameFormat, &KThreadName, random);

    TThreadFunction threadFunc = GetThreadFunction(aThreadNumber);

    if (threadFunc == NULL)

        {

        ERR_PRINTF2(_L("Requested thread function %d, got NULL pointer back!"), aThreadNumber);

        User::Leave(KErrArgument);

        }

    TInt err = iLoadThread[aThreadNumber].Create(threadName, threadFunc, 

                    KStackSize, KHeapMinSize, KHeapMaxSize, this, EOwnerThread);

    if(err != KErrNone)

        {

        ERR_PRINTF2(_L("Could not create load thread - err=%d"), err);

        User::Leave(err);

        }

    iLoadThread[aThreadNumber].Resume();

    }

// Terminate a previously started thread.

void CStressTestEngine::EndThread(TInt aThreadNumber)

    {

    TRequestStatus status;

    iLoadThread[aThreadNumber].Logon(status);

    RDebug::Printf("Ending thread %d", aThreadNumber);

    __e32_atomic_store_rel32(&iStopThreadFlag[aThreadNumber], ETrue);

    // Wait for thread to exit.

    User::WaitForRequest(status);

    iLoadThread[aThreadNumber].Close();

    }

// This function is intended to be implemented by a derived class - just print

// an error and return NULL.   

TThreadFunction CStressTestEngine::GetThreadFunction(TInt aThreadNumber)

    {

    ERR_PRINTF2(_L("Should not be called: CStressTestEngine::GetThreadFunction() with %d"), aThreadNumber);

    return NULL;

    }

// Parameter class implementation.

// General description:

// The class uses a virtual interface that has three member functions:

// Initialize(start, end, step) 

//   Setup. The values of start, end and step may be used for other purposes

// Value()

//   Return current value of the parameter. Does not alter the value.

// Next()

//   Update the value to the next one. Where relevant, wrap around to the 

//   starting value if the end has been reached.

// Factory function to create parameter instances.

CStressParam * CStressParam::Factory(const TParamDeclaration &aParamDecl)

    {

    CStressParam *p;

    switch(aParamDecl.iType)

        {

        case EParamTypeNone:

            // Didn't want this parameter - return NULL!

            // We later check if the pointer is NULL and complain if an

            // attempt is made to USE this parameter.

            p = NULL;

            break;

        case EParamTypeIterator:

            p = new CStressParamIterator;

            break;

        case EParamTypeTable:

            p = new CStressParamTable;

            break;

        case EParamTypeRandomizer:

            p = new CStressParamRandomizer;

            break;

        default:

            RDebug::Printf("%s:%d: Type not implemented (type = %d)", 

                    __FILE__, __LINE__, aParamDecl.iType);

            p = NULL;

            break;

        }

    if (p)

        {

        p->Initialize(aParamDecl.iInit, aParamDecl.iEnd, aParamDecl.iStep);

        }

    return p;

    }

CStressParam::~CStressParam()

    {

    }

CStressParamIterator::CStressParamIterator()

    {

    }

CStressParamIterator::~CStressParamIterator()

    {

    }

void CStressParamIterator::Initialize(TInt aInit, TInt aEnd, TInt aStep)

    {

    iInit = aInit;

    iEnd = aEnd;

    iStep = aStep;

    iIterator = iInit;

    }

void CStressParamIterator::Next()

    {

    iIterator += iStep;

    if (iStep > 0)

        {

        if (iIterator >= iEnd)

            {

            iIterator = iInit;

            }

        }

    else

        {

        if (iIterator <= iEnd)

            {

            iIterator = iInit;

            }

        }

    }

TInt CStressParamIterator::Value()

    {

    return iIterator;

    }

CStressParamRandomizer::CStressParamRandomizer()

    {

    }

CStressParamRandomizer::~CStressParamRandomizer()

    {

    }

void CStressParamRandomizer::Initialize(TInt aMin, TInt aMax, TInt aMul)

    {

    iMin = aMin;

    iMax = aMax;

    iMul = aMul;

    // Now, pick a new random number. 

    Next();  

    }

void CStressParamRandomizer::Next()

    {

    iCurrent = (((TInt)Math::Random()) % ((iMax - iMin) + iMin)) * iMul;

    }

TInt CStressParamRandomizer::Value()

    {

    return iCurrent;

    }

CStressParamTable::CStressParamTable()

    {

    }

CStressParamTable::~CStressParamTable()

    {

    }

void CStressParamTable::Initialize(TInt aTable, TInt aCount, TInt /* aUnused */)

    {

    iTable = reinterpret_cast<TInt *>(aTable);

    iCount = aCount;

    iIndex = 0;

    }

void CStressParamTable::Next()

    {

    iIndex = (iIndex + 1) % iCount;

    }

TInt CStressParamTable::Value()

    {

    return iTable[iIndex];

    }