// 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:

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "egltest_threadedstress.h"

#include "eglendpointwrap.h"

#include "egltest_endpoint_images.h"

#include "egltest_threadmonitor.h"

#include <e32atomics.h>

#include "egltest_endpoint_images.h"

#include <e32math.h>

//Private Helper Class Declarations-----------------------------------------------

class CTightLoopThread : public CBase, public MLog

    {

public:

    ~CTightLoopThread();

    //Control the loop from the controlling thread. 

    //Calling Start() more than once causes panic.

    void Start();

    TRemoteTestVerdict Stop();

    TThreadId ThreadId() const;

protected:

    CTightLoopThread();

    void ConstructL(TBool aSharedHeap);

    MLog& Logger() const;

    void Log(const TText8* aFile, TInt aLine, TInt aSeverity, TRefByValue<const TDesC> aFmt, ...);

    //To be implemented by derived class.

    virtual void SetupInThreadContextL() = 0;

    virtual void TeardownInThreadContextL() = 0;

    virtual TBool ExecuteInnerLoopBody() = 0;

private:

    static TInt ThreadEntryPoint(TAny* aSelf);

    void EnterThreadLoopL();

private:

    RThread iThread;

    TRequestStatus iNotifyStart;

    volatile TBool iNotifyStop;

    TBool iHasBeenStarted;

    TBool iHasBeenStopped;

    };

class CEndpointExercise : public CTightLoopThread

    {

public:

    static CEndpointExercise* NewL(TBool aSharedHeap);

    ~CEndpointExercise();

    void SetupInThreadContextL();

    void TeardownInThreadContextL();

    TBool ExecuteInnerLoopBody();

private:

    CEndpointExercise();

    void ConstructL(TBool aSharedHeap);

    void ExecuteInnerLoopBodyL();

    TInt CheckImage(EGLImageKHR aEglImage);

    //Logging helpers.

    void PanicIfError(TInt aError, const TText8* aFile, TInt aLine) const;

    void PanicIfFalse(TBool aBool, const TText8* aFile, TInt aLine) const;

    void LogAndLeaveIfErrorL(TInt aError, const TText8* aFile, TInt aLine) const;

    void LogAndLeaveIfFalseL(TBool aBool, const TText8* aFile, TInt aLine) const;

    #define PANIC_IF_ERROR(ERROR)           PanicIfError((ERROR), (TText8*)__FILE__, __LINE__)

    #define PANIC_IF_FALSE(BOOL)            PanicIfFalse((BOOL), (TText8*)__FILE__, __LINE__)

    #define LOG_AND_LEAVE_IF_ERROR_L(ERROR) LogAndLeaveIfErrorL((ERROR), (TText8*)__FILE__, __LINE__)

    #define LOG_AND_LEAVE_IF_FALSE_L(BOOL)  LogAndLeaveIfFalseL((BOOL), (TText8*)__FILE__, __LINE__)

private:

    TInt iIteration;

    TInt iCurrentColour;

    RSurfaceManager iSurfaceManager;

    RSurfaceUpdateSession iSurfaceUpdate;

    RSurfaceManager::TSurfaceCreationAttributesBuf iSurfaceAttribs;

    EGLDisplay iDisplay;

    TEglEndpointWrap iEglEp;

    CEglWindowSurface* iDummyWindowSurface;

    };

//--------------------------------------------------------------------------------

//Cleanup Items used through out tests--------------------------------------------

struct TCleanupSurface

    {

    RSurfaceManager* iSurfaceManager;

    TSurfaceId iSurfaceId;

    };

static void CleanupSurface(TAny* aCleanupSurface)

    {

    TCleanupSurface* surface = static_cast<TCleanupSurface*>(aCleanupSurface);

    TInt err = surface->iSurfaceManager->CloseSurface(surface->iSurfaceId);

    ASSERT(err == KErrNone);

    }

struct TCleanupEndpoint

    {

    EGLDisplay iDisplay;

    EGLEndpointNOK iEndpoint;

    };

static void CleanupEndpoint(TAny* aCleanupEndpoint)

    {

    TCleanupEndpoint* endpoint = static_cast<TCleanupEndpoint*>(aCleanupEndpoint);

    TEglEndpointWrap ep;

    ASSERT(ep.Error() == KErrNone);

    EGLBoolean err = ep.DestroyEndpoint(endpoint->iDisplay, endpoint->iEndpoint);

    ASSERT(err);

    }

struct TCleanupImage

    {

    EGLDisplay iDisplay;

    EGLEndpointNOK iEndpoint;

    EGLImageKHR iImage;

    };

static void CleanupImage(TAny* aCleanupImage)

    {

    TCleanupImage* image = static_cast<TCleanupImage*>(aCleanupImage);

    TEglEndpointWrap ep;

    ASSERT(ep.Error() == KErrNone);

    EGLBoolean err = ep.ReleaseImage(image->iDisplay, image->iEndpoint, image->iImage, EGL_NONE);

    ASSERT(err);

    }

static void CleanupPointerArray(TAny* aPointerArray)

    {

    RPointerArray<CEndpointExercise>* array = static_cast<RPointerArray<CEndpointExercise>*>(aPointerArray);

    array->ResetAndDestroy();

    }

//--------------------------------------------------------------------------------

//Utility Functions---------------------------------------------------------------

inline TInt RandomNumberInRange(TInt aMin, TInt aMax)

    {

    if(aMin > aMax)

        {

        TInt temp = aMin;

        aMin = aMax;

        aMax = temp;

        }

    //Scale and offset to put random into the range inclusively.

    TUint range = aMax - aMin;

    TUint random  = Math::Random() % (range + 1);

    return (TInt)random + aMin;

    }

inline TReal Square(TReal aNumber)

    {

    return aNumber * aNumber;

    }

static TBool SamplesAreIncreasing(TInt* aSampledData, TInt aNumSamples)

    {

    //Naive linear least squares to get gradient of fit line and correlation coefficient.

    //Using TReal to avoid worrying about wrap.

    TReal n = aNumSamples;

    TReal sumX = 0.0;

    TReal sumXSq = 0.0;

    TReal sumY = 0.0;

    TReal sumYSq = 0.0;

    TReal sumXTimesY = 0.0;

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

        {

        TReal x = (TReal)(i + 1);

        TReal y = (TReal)aSampledData[i];

        sumX += x;

        sumXSq += Square(x);

        sumY += y;

        sumYSq += Square(y);

        sumXTimesY += x * y;

        }

    TReal xBar = sumX / n;

    TReal yBar = sumY / n;

    TReal gradient = (sumXTimesY - (n * xBar * yBar)) / (sumXSq - (n * Square(xBar)));

    TReal correlation = Square(sumXTimesY - (n * xBar * yBar)) / ((sumXSq - (n * Square(xBar))) * (sumYSq - (n * Square(yBar))));

    //If the gradient is positive and the correlation coefficient is high, the samples are increasing.

    return (correlation > 0.8) && (gradient > 0.0);

    }

//--------------------------------------------------------------------------------

//CTightLoopThread----------------------------------------------------------------

CTightLoopThread::CTightLoopThread() :

    iNotifyStop(EFalse),

    iHasBeenStarted(EFalse),

    iHasBeenStopped(EFalse)

    {

    }

void CTightLoopThread::ConstructL(TBool aSharedHeap)

    {

    //Stack and heap sizes.

    static const TInt KStackSize =   0x2000;      //  8KB

    static const TInt KHeapMinSize = 0x1000;      //  4KB

    static const TInt KHeapMaxSize = 0x1000000;   // 16MB

    //The new thread either has its own heap or shares ours.

    if(aSharedHeap)

        {

        User::LeaveIfError(iThread.Create(KNullDesC, ThreadEntryPoint, KStackSize, NULL, this, EOwnerThread));

        }

    else

        {

        User::LeaveIfError(iThread.Create(KNullDesC, ThreadEntryPoint, KStackSize, KHeapMinSize, KHeapMaxSize, this, EOwnerThread));

        }

    //Resume and rendezvous.

    iThread.Resume();

    TRequestStatus rendezvous;

    iThread.Rendezvous(rendezvous);

    User::WaitForRequest(rendezvous);

    User::LeaveIfError(rendezvous.Int());

    }

MLog& CTightLoopThread::Logger() const

    {

    return *const_cast<CTightLoopThread*>(this);

    }

class TOverflowTruncate : public TDesOverflow

    {

public:

    virtual void Overflow(TDes& /*aDes*/)

        {

        //Do nothing - just let it truncate.

        }

    };

void CTightLoopThread::Log(const TText8* aFile, TInt aLine, TInt aSeverity, TRefByValue<const TDesC> aFmt, ...)

    {

    TOverflowTruncate overflow;

    VA_LIST list;

    VA_START(list, aFmt);

    TBuf<0x100> buf;

    buf.AppendFormatList(aFmt, list, &overflow);

    TPtrC8 file8(aFile);

    TBuf<0x100> file16;

    file16.Copy(file8);

    //Lots of effort is required to pump this into the TEF log file, so for now we just print to debug.

    RDebug::Print(_L("CTightLoopThread: %S:%d, Severity=%d, Message=\"%S\""), &file16, aLine, aSeverity, &buf);

    }

CTightLoopThread::~CTightLoopThread()

    {

    //Shutdown the thread according to the state it is in.

    if(!iHasBeenStarted)

        {

        TRequestStatus* notifyStart = &iNotifyStart;

        iThread.RequestComplete(notifyStart, KErrAbort);

        }

    if(iHasBeenStarted && !iHasBeenStopped)

        {

        Stop();

        }

    iThread.Close();

    }

void CTightLoopThread::Start()

    {

    ASSERT(!iHasBeenStarted);

    TRequestStatus* notifyStart = &iNotifyStart;

    iThread.RequestComplete(notifyStart, KErrNone);

    iHasBeenStarted = ETrue;

    }

TRemoteTestVerdict CTightLoopThread::Stop()

    {

    ASSERT(iHasBeenStarted);

    ASSERT(!iHasBeenStopped);

    TRequestStatus logon;

    iThread.Logon(logon);

    __e32_atomic_store_rel32(&iNotifyStop, ETrue);

    User::WaitForRequest(logon);

    TExitType exitType = iThread.ExitType();

    iThread.Close();

    iHasBeenStopped = ETrue;

    switch(exitType)

        {

        case EExitKill:

            //Terminated normally (since we never call kill).

            return ERtvPass; 

        case EExitPanic:

            //Thread panicked.

            return ERtvPanic;

        default:

            //Any other option should be impossible in our use case.

            ASSERT(0);

        }

    return ERtvAbort;

    }

TThreadId CTightLoopThread::ThreadId() const

    {

    return iThread.Id();

    }

TInt CTightLoopThread::ThreadEntryPoint(TAny* aSelf)

    {

    CTightLoopThread* self = static_cast<CTightLoopThread*>(aSelf);

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TRAPD(err,

        //Create active scheduler.

        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

        CleanupStack::PushL(scheduler);

        CActiveScheduler::Install(scheduler);

        //Setup the draw loop.

        self->EnterThreadLoopL();

        //Clean up.

        CleanupStack::PopAndDestroy(scheduler);

        );

    __ASSERT_ALWAYS(err == KErrNone, User::PanicUnexpectedLeave());

    delete cleanup;

    return KErrNone;

    }

void CTightLoopThread::EnterThreadLoopL()

    {

    //Setup the derived class in this thread context.

    TRAPD(err, SetupInThreadContextL());

    //Set the request to pending, rendezvous with parent and wait for start signal.

    iNotifyStart = KRequestPending;

    RThread().Rendezvous(err);

    User::WaitForRequest(iNotifyStart);

    //Exit immediately if the KErrAbort signal was received.

    TBool keepGoing = ETrue;

    if(iNotifyStart == KErrAbort)

        {

        keepGoing = EFalse;

        }

    else

        {

        ASSERT(iNotifyStart == KErrNone);

        }

    //Loop until we are told to stop.

    while(!__e32_atomic_load_acq32(&iNotifyStop) && keepGoing)

        {

        keepGoing = ExecuteInnerLoopBody();

        }

    //Teardown the derived class in this thread context.

    TeardownInThreadContextL();

    }

//--------------------------------------------------------------------------------

//CEndpointExercise---------------------------------------------------------------

CEndpointExercise* CEndpointExercise::NewL(TBool aSharedHeap)

    {

    CEndpointExercise* self = new (ELeave) CEndpointExercise();

    CleanupStack::PushL(self);

    self->ConstructL(aSharedHeap);

    CleanupStack::Pop(self);

    return self;

    }

CEndpointExercise::CEndpointExercise()

    {

    }

void CEndpointExercise::ConstructL(TBool aSharedHeap)

    {

    CTightLoopThread::ConstructL(aSharedHeap);

    User::LeaveIfError(iEglEp.Error());

    }

CEndpointExercise::~CEndpointExercise()

    {

    }

void CEndpointExercise::PanicIfError(TInt aError, const TText8* aFile, TInt aLine) const

    {

    if(aError != KErrNone)

        {

        Logger().Log(aFile, aLine, ESevrErr, _L("Panicking due to error %d"), aError);

        User::Panic(_L("EPTHREADEDSTRESS"), aLine);

        }

    }

void CEndpointExercise::PanicIfFalse(TBool aBool, const TText8* aFile, TInt aLine) const

    {

    if(!aBool)

        {

        Logger().Log(aFile, aLine, ESevrErr, _L("Panicking due to failing invariant test"));

        User::Panic(_L("EPTHREADEDSTRESS"), aLine);

        }

    }

void CEndpointExercise::LogAndLeaveIfErrorL(TInt aError, const TText8* aFile, TInt aLine) const

    {

    if(aError != KErrNone)

        {

        Logger().Log(aFile, aLine, ESevrWarn, _L("Abandoning iteration due to error %d"), aError);

        User::Leave(aError);

        }

    }

void CEndpointExercise::LogAndLeaveIfFalseL(TBool aBool, const TText8* aFile, TInt aLine) const

    {

    if(!aBool)

        {

        Logger().Log(aFile, aLine, ESevrWarn, _L("Abandoning iteration due to failing invariant test"));

        User::Leave(KErrUnknown);

        }

    }

TInt CEndpointExercise::CheckImage(EGLImageKHR aEglImage)

    {

    TRAPD

        (err,

        //Convert the image to a CTestVgEglImage

        CTestVgEglImage* vgEglImage = CTestVgEglImage::NewL(aEglImage);

        CleanupStack::PushL(vgEglImage);

        //Check the corners and center pixel are the same colour.

        //Since this test is focussed on correct OOM behaviour, 

        //we panic if the functionality is incorrect.

        PANIC_IF_FALSE(vgEglImage->IsSolidColourL());

        CleanupStack::PopAndDestroy(vgEglImage);

        );

    return err;

    }

void CEndpointExercise::SetupInThreadContextL()

    {

    //Colour to fill surface with (this is incremented every frame).

    iCurrentColour = 0x88CC44;

    //Connections to SUS and surface manager.

    User::LeaveIfError(iSurfaceManager.Open());

    User::LeaveIfError(iSurfaceUpdate.Connect(5));

    //Surface attribs to create surface with.

    iSurfaceAttribs().iSize = TSize(100, 100);

    iSurfaceAttribs().iBuffers = 2;

    iSurfaceAttribs().iPixelFormat = EUidPixelFormatARGB_8888_PRE;

    iSurfaceAttribs().iStride = 100 * 4;

    iSurfaceAttribs().iOffsetToFirstBuffer = 0;

    iSurfaceAttribs().iAlignment = 32;

    iSurfaceAttribs().iContiguous = EFalse;

    iSurfaceAttribs().iCacheAttrib = RSurfaceManager::ECached;

    iSurfaceAttribs().iOffsetBetweenBuffers = 0;

    iSurfaceAttribs().iSurfaceHints = NULL;

    iSurfaceAttribs().iHintCount = 0;

    iSurfaceAttribs().iMappable = ETrue;

    iDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    //Create an EglWindowSurface so we have a current context for vg operations.

    iDummyWindowSurface = CEglWindowSurface::NewL();

    iDummyWindowSurface->CreateL(EStandardSurface, TPoint(0, 0));

    iDummyWindowSurface->ActivateL();

    }

void CEndpointExercise::TeardownInThreadContextL()

    {

    delete iDummyWindowSurface;

    iSurfaceUpdate.Close();

    iSurfaceManager.Close();

    }

TBool CEndpointExercise::ExecuteInnerLoopBody()

    {

    TRAPD(err, ExecuteInnerLoopBodyL());

    if(err != KErrNone)

        {

        Logger().Log((TText8*)__FILE__, __LINE__, ESevrWarn, _L("Iteration %d did not run to completion, due to an acceptable error in low memory conditions"), iIteration);

        }

    iIteration++;

    return ETrue;

    }

void CEndpointExercise::ExecuteInnerLoopBodyL()

    {

    //Create a surface.

    TCleanupSurface surface = {&iSurfaceManager, TSurfaceId::CreateNullId()};

    LOG_AND_LEAVE_IF_ERROR_L(iSurfaceManager.CreateSurface(iSurfaceAttribs, surface.iSurfaceId));

    CleanupStack::PushL(TCleanupItem(CleanupSurface, &surface));

    //Map surface and get pointer to buffer 0.

    RChunk surfaceChunk;

    TInt offset;

    PANIC_IF_ERROR(iSurfaceManager.MapSurface(surface.iSurfaceId, surfaceChunk));

    CleanupClosePushL(surfaceChunk);

    PANIC_IF_ERROR(iSurfaceManager.GetBufferOffset(surface.iSurfaceId, 0, offset));

    TUint32* buffer = (TUint32*)(surfaceChunk.Base() + offset);

    //Fill surface with current colour. This could

    //be much faster but its good enough for testing.

    TUint32 fillColour = TRgb(iCurrentColour, 255)._Color16MAP();

    for(TInt y=0; y < iSurfaceAttribs().iSize.iHeight; ++y)

        {

        for(TInt x=0; x < iSurfaceAttribs().iSize.iWidth; ++x)

            {

            buffer[x] = fillColour;

            }

        buffer += iSurfaceAttribs().iStride >> 2;

        }

    //Create an endpoint for the surface.

    TCleanupEndpoint endpoint = {iDisplay, EGL_NO_ENDPOINT_NOK};

    endpoint.iEndpoint = iEglEp.CreateEndpoint(iDisplay, EGL_ENDPOINT_TYPE_CONSUMER_NOK, EGL_TSURFACEID_NOK, &surface.iSurfaceId, NULL);

    LOG_AND_LEAVE_IF_FALSE_L(endpoint.iEndpoint != EGL_NO_ENDPOINT_NOK);

    CleanupStack::PushL(TCleanupItem(CleanupEndpoint, &endpoint));

    //Submit buffer 0 to surface update server.

    TRequestStatus displayed;

    iSurfaceUpdate.NotifyWhenDisplayedXTimes(1, displayed);

    LOG_AND_LEAVE_IF_ERROR_L(iSurfaceUpdate.SubmitUpdate(KAllScreens, surface.iSurfaceId, 0, NULL));

    User::WaitForRequest(displayed);

    //Begin streaming. Should not fail since we have submitted a buffer since creating ep.

    LOG_AND_LEAVE_IF_FALSE_L(iEglEp.EndpointBeginStreaming(iDisplay, endpoint.iEndpoint));

    //Acquire an image from the endpoint.

    TCleanupImage image = {iDisplay, endpoint.iEndpoint, EGL_NO_IMAGE_KHR};

    image.iImage = iEglEp.AcquireImage(iDisplay, endpoint.iEndpoint);

    LOG_AND_LEAVE_IF_FALSE_L(image.iImage != EGL_NO_IMAGE_KHR);

    CleanupStack::PushL(TCleanupItem(CleanupImage, &image));

    //Check that the image we acquired is coherrent.

    LOG_AND_LEAVE_IF_ERROR_L(CheckImage(image.iImage));

    //Release image, destroy endpoint, close chunk and close surface.

    CleanupStack::PopAndDestroy(4);

    //Modify the colour that we draw.

    iCurrentColour += 16;

    }

//--------------------------------------------------------------------------------

//Remote test step----------------------------------------------------------------

CEglTest_RemoteTestStep_EndpointThreadStress::CEglTest_RemoteTestStep_EndpointThreadStress() :

    CRemoteTestStepBase(ETestUidEndpointThreadStress)

    {

    }

CEglTest_RemoteTestStep_EndpointThreadStress::~CEglTest_RemoteTestStep_EndpointThreadStress()

    {

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointThreadStress::DoStartRemoteTestStepL(const TRemoteTestParams& /*aMessageIn*/)

    {

    REMOTE_INFO_PRINTF1(_L("Starting Remote Test Step."));

    EglStartL();

    return ERtvPass;

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointThreadStress::DoEndRemoteTestStepL(const TRemoteTestParams& /*aMessageIn*/)

    {

    REMOTE_INFO_PRINTF1(_L("Ending Remote Test Step."));

    EglEndL();

    return ERtvPass;

    }

TInt CEglTest_RemoteTestStep_EndpointThreadStress::Timeout() const

    {

    return 120 * 1000000; //2 min.

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointThreadStress::DoRunRemoteTestCaseL(TInt aTestCase, const TRemoteTestParams& aParams)

    {

    switch(aTestCase)

        {

        case 0:     return CrazyThreadingTestCaseL(aParams);

        case 1:     return OutOfHeapMemoryTestCaseL(aParams);

        default:    return ERtvAbort;

        }

    }

//For a detailed description of this test case (GRAPHICS-EGL-594), see the local side cpp file.

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointThreadStress::CrazyThreadingTestCaseL(const TRemoteTestParams& /*aParams*/)

    {

    //Create the exercises. These run an endpoint exercise in a tight loop in a private thread.

    CEndpointExercise* exercise1 = CEndpointExercise::NewL(EFalse);

    CleanupStack::PushL(exercise1);

    CEndpointExercise* exercise2 = CEndpointExercise::NewL(EFalse);

    CleanupStack::PushL(exercise2);

    //Create a monitor to cleanup if any of the threads panic. The controller thread 

    //must be at index zero in the array. This will even work if a deadlock occurs 

    //between the  exercise threads, since the call to stop the exercise will never 

    //return and the framework will eventually time us out. The monitor will notice

    //that the controller thread has panicked and will forward the panic to the exercises.

    RArray<TThreadId> threads;

    CleanupClosePushL(threads);

    threads.AppendL(RThread().Id());

    threads.AppendL(exercise1->ThreadId());

    threads.AppendL(exercise2->ThreadId());

    CThreadMonitor* monitor = CThreadMonitor::NewL(threads);

    CleanupStack::PushL(monitor);

    //Start the exercises.

    exercise1->Start();

    exercise2->Start();

    //Let the exercises run for 20 seconds.

    User::After(20 * 1000000);

    //Stop the exercises and record the results.

    TRemoteTestVerdict result1 = exercise1->Stop();

    TRemoteTestVerdict result2 = exercise2->Stop();

    CleanupStack::PopAndDestroy(4, exercise1);

    return (result1 != ERtvPass) ? result1 : result2;

    }

class THeapGobbler

    {

public:

    static THeapGobbler* New(TInt aSize)

        {

        THeapGobbler* self = (THeapGobbler*)new TUint8[sizeof(THeapGobbler) - sizeof(TUint8) + aSize];

        if(!self)

            {

            return NULL;

            }

        self->iSize = aSize;

        self->iNext = NULL;

        return self;

        }

public:

    THeapGobbler* iNext;

    TInt iSize;

    TUint8 iMemory[1];

    };

//For a detailed description of this test case (GRAPHICS-EGL-601), see the local side cpp file.

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointThreadStress::OutOfHeapMemoryTestCaseL(const TRemoteTestParams& aParams)

    {

    const TInt KHeapSizeMin = 0x100000;   //1MB.

    const TInt KHeapSizeMax = 0x10000000; //256MB.

    RHeap* testHeap = User::ChunkHeap(NULL, KHeapSizeMin, KHeapSizeMax, KMinHeapGrowBy, 4);

    if(!testHeap)

        {

        REMOTE_ERR_PRINTF1(_L("Failed to create chunk heap. Aborting."));

        return ERtvAbort;

        }

    RHeap* oldHeap = User::SwitchHeap(testHeap);

    CTrapCleanup *cleanUpStack = CTrapCleanup::New();

    if (!cleanUpStack)

        {

        User::SwitchHeap(oldHeap);

        testHeap->Close();

        User::Leave(KErrNoMemory);

        }

    TRemoteTestVerdict verdict = ERtvPass;

    TRAPD(err, verdict = DoOutOfHeapMemoryTestCaseL(aParams));

    delete cleanUpStack;

    User::SwitchHeap(oldHeap);

    testHeap->Close();

    User::LeaveIfError(err);

    return verdict;

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointThreadStress::DoOutOfHeapMemoryTestCaseL(const TRemoteTestParams& aParams)

    {

    const TInt numExercises = aParams.iEndpointThreadStress.iNumThreads;

    const TInt KMinCellSize = 500;

    const TInt KMaxCellSize = 2000;

    const TInt KNumIterations = 20;

    TInt heapAllocSize[KNumIterations];

    TRemoteTestVerdict exerciseResult = ERtvPass;

    //One iteration of the outer loop results in one data point for deciding if the heap is leaking or not. 

    for(TInt x=0; x < KNumIterations; x++)

        {

        //Reserving space in these arrays ahead of time to 

        //make cleanup stack manipulation more staightforward.

        RPointerArray<CEndpointExercise> exercises;

        CleanupStack::PushL(TCleanupItem(CleanupPointerArray, &exercises));

        exercises.ReserveL(numExercises);

        RArray<TThreadId> threads;

        CleanupClosePushL(threads);

        threads.ReserveL(numExercises + 1);

        //Save the controller thread id for the monitor.

        threads.Append(RThread().Id());

        //Create endpoint exercise threads and save the thread Ids for the monitor.

        for(TInt j=0; j < numExercises; j++)

            {

            //Appends can't fail since we have already reserved space.

            //Note that the exercises all share the same heap as this thread.

            exercises.Append(CEndpointExercise::NewL(ETrue));

            threads.Append(exercises[j]->ThreadId());

            }

        //Create a monitor to handle thread cleanup if something panics or deadlocks.

        CThreadMonitor* monitor = CThreadMonitor::NewL(threads);

        //Nothing can leave after this.

        CleanupStack::Pop(2);

        //Start the exercises.

        for(TInt j=0; j < numExercises; j++)

            {

            exercises[j]->Start();

            }

        THeapGobbler* firstCell = NULL;

        THeapGobbler* lastCell = NULL;

        TInt numberOfCells = 0;

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

            {

            //Allocate random sizes until full.

            THeapGobbler* newCell = THeapGobbler::New(RandomNumberInRange(KMinCellSize, KMaxCellSize));

            while(newCell)

                {

                if(lastCell)

                    lastCell->iNext = newCell;

                if(!firstCell)

                    firstCell = newCell;

                lastCell = newCell;

                numberOfCells++;

                newCell = THeapGobbler::New(RandomNumberInRange(KMinCellSize, KMaxCellSize));

                }

            //Let exercise run while heap is full.

            User::After(1 * 1000);

            //Deallocate n/4 cells.

            for(TInt n = numberOfCells / 4; n >= 1; --n)

                {

                THeapGobbler* oldCell = firstCell;

                firstCell = oldCell->iNext;

                delete oldCell;

                numberOfCells--;

                if(!firstCell)

                    {

                    lastCell = NULL;

                    ASSERT(numberOfCells == 0);

                    break;

                    }

                }

            //Let exercise run while heap is not full.

            User::After(1 * 1000);

            }

        //Deallocate all cells.

        while(firstCell)

            {

            THeapGobbler* oldCell = firstCell;

            firstCell = oldCell->iNext;

            delete oldCell;

            }

        lastCell = NULL;

        numberOfCells = 0;

        //Stop the exercises and save the result.

        for(TInt j=0; j < numExercises; j++)

            {

            TRemoteTestVerdict ret = exercises[j]->Stop();

            exerciseResult = (exerciseResult == ERtvPass) ? ret : exerciseResult;

            }

        delete monitor;

        threads.Close();

        exercises.ResetAndDestroy();

        if(exerciseResult != ERtvPass)

            {

            REMOTE_ERR_PRINTF2(_L("Aborting because the endpoint exercise failed for iteration %d"), x);

            return exerciseResult;

            }

        //Save the heap size.

        User::Heap().AllocSize(heapAllocSize[x]);

        }

    //Work out if any memory has leaked and return a verdict.

    TBool memoryIsLeaking = SamplesAreIncreasing(heapAllocSize, KNumIterations);

    if(memoryIsLeaking)

        {

        REMOTE_ERR_PRINTF1(_L("Heap memory is increasing over time with high certainty, there is probably a memory leak."));

        }

    else

        {

        REMOTE_INFO_PRINTF1(_L("No heap memory leak detected."));

        }

    return memoryIsLeaking ? ERtvFail : ERtvPass;

    }

//--------------------------------------------------------------------------------