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


/**
 @file
 @test
 @internalComponent - Internal Symbian test code
*/


/*
 * To add a new message that can be passed over the message queue:
 * 1. Add the test name to the TTestUid enum.
 * 2. Create a T class to hold the params.
 * 3. Add the T class to the TRemoteTestParams union.
 *
 * These steps are described in more detail below, where the
 * individual bits should be added.
 */


#ifndef __EGLTEST_COMMSCOMMON_H__
#define __EGLTEST_COMMSCOMMON_H__


#include <e32base.h>
#include <graphics/surface.h>
#include <EGL/egl.h>
#include "log.h"
#include "egltest_endpoint_engine_types.h"

#define ENDPOINT_ASSERT_DEBUG(x, y) do { if (!x) { RDebug::Printf("Assertion (%s) failed: %s:%d ", #x, __FILE__, __LINE__); y; } } while(0)

//The maximum size of a message in an async message queue is 256 bytes.
//If these valuses are increased, the maximum size will be exceeded.
const TInt KRSLogMessageLength = 172;
const TInt KRSLogFileLength = 32;


//Names for the Async message queues that are used for
//communication between the TEF driver app and the test
//thread within window server.
_LIT(KResultQueueName, "RemoteTestEnvResultQueue");
_LIT(KParamsQueueName, "RemoteTestEnvParamsQueue");

const TInt KStartTestStepCaseNumber = -1;
const TInt KEndTestStepCaseNumber = -2;

//Uids for all of the tests that the test thread knows about.
enum TTestUid
    {
    //Endpoint Api Exposure Test.
    ETestUidEndpointApiExposure,

    // Common UID for engine code.
    ETestUidEndpointEngine,

    // Endpoint Lifetime test.
    ETestUidEndpointLifetime,

    //Image Tearing Test.
    ETestUidEndpointTearing,
    
    //Multithreaded stress tests.
    ETestUidEndpointThreadStress,
    
    //Release Image with Gles context tests.
    ETestUidEndpointReleaseImageGles,
    
    // vgThreading test.
    ETestUidVgThreading,
    };


//Each test should have a struct with data members to hold
//the test's parameters. The name name should begin
//"TTest..." and should contain no member functions.
//(c-style struct).

//If it is found that many tests use the same params, we should
//create a TTestGeneric class to hold the params and derive
//classes from it.

struct TTestEndpointApiExposure
    {
    };

struct TTestEndpointTearing
    {
    TSurfaceId iSurfaceId;
    };

struct TTestEndpointThreadStress
    {
    TInt iNumThreads;
    };

struct TTestEndpointReleaseImageGles
    {
    TBool iUseValidGlesContext;
    };


//Union for all of the structs that tests use to pass
//params between the local side and the remote side.
union TRemoteTestParams
    {
    //Endpoint Api Exposure Test.
    TTestEndpointApiExposure iTestEndpointApiExposure;

    //Endpoint engine data.
    TTestEndpointEngine iEndpointEngine;
    
    // Endpoint Engine configuration data.
    TTestEndpointEngineConfig iEndpointEngineConfig;

    //Image Tearing Test.
    TTestEndpointTearing iEndpointTearing;
    
    //Multithreaded stress tests.
    TTestEndpointThreadStress iEndpointThreadStress;
    
    //Release Image with Gles context tests.
    TTestEndpointReleaseImageGles iEndpointReleaseImageGles;
    };


//Structure that is passed from local side to remote side
//in the async message queue. It contains the test Uid,
//test case and the params.
class TRemoteTestParamsPacket
    {
public:
    TRemoteTestParamsPacket();
    TRemoteTestParamsPacket(TTestUid aTestUid, TInt aTestCase, const TRemoteTestParams& aParams);
    const TTestUid iUid;
    const TInt iTestCase;
    const TRemoteTestParams iParams;
    };


//The object passed back to the TEF driver app from the test
//thread. It can be used for sending the resuult of a test and
//for logging.
class TRemoteTestResult
    {
public:
    TRemoteTestResult();

    //Constructor for sending logging info.
    TRemoteTestResult(TTestUid aUid, TInt aTestCase, const TDesC8& aFile, TInt aLine, TInt aSeverity, const TDesC& aMessage);

    //Constructor for sending result info.
    TRemoteTestResult(TTestUid aUid, TInt aTestCase, TRemoteTestVerdict aVerdict);

public:
    //If EFalse this is a logging message, else a result message.
    TBool iFinished;
    TTestUid iUid;
    TInt iTestCase;

    //Result message.
    TRemoteTestVerdict iVerdict;

    //Logging message.
    TBuf8<KRSLogFileLength> iFile;
    TInt iLine;
    TInt iSeverity;
    TBuf8<KRSLogMessageLength> iMessage;
    };


//Inline functions --------------------------------------------------------

inline TRemoteTestParamsPacket::TRemoteTestParamsPacket() :
    iUid((TTestUid)0),
    iTestCase(0),
    iParams(TRemoteTestParams())
    {
    }


inline TRemoteTestParamsPacket::TRemoteTestParamsPacket(TTestUid aTestUid, TInt aTestCase, const TRemoteTestParams& aParams) :
    iUid(aTestUid),
    iTestCase(aTestCase),
    iParams(aParams)
    {
    }


inline TRemoteTestResult::TRemoteTestResult()
    {
    }


inline TRemoteTestResult::TRemoteTestResult(TTestUid aUid, TInt aTestCase, const TDesC8& aFile, TInt aLine, TInt aSeverity, const TDesC& aMessage) :
    iFinished(EFalse),
    iVerdict(ERtvInconclusive),
    iUid(aUid),
    iTestCase(aTestCase),
    iLine(aLine),
    iSeverity(aSeverity)
    {
    //Copy the filename to the log object. If the string is too long,
    //truncate the string and append an elipsis to the log.
    //The "-1"s ensure that a free char is left for appending a NULL (in the TEF app).
    TBool truncate = iFile.MaxLength()-1 < aFile.Length();
    TInt numChars = truncate ? iFile.MaxLength()-3-1 : aFile.Length();
    iFile = aFile.Left(numChars);
    if(truncate)
        {
        iFile.Append(_L("..."));
        }

    //Copy the message to the log object. If the string is too long,
    //truncate the string and append an elipsis to the log.
    //Note we convert message from unicode to ascii to conserve space in the message queue.
    truncate = iMessage.MaxLength() < aMessage.Length();
    numChars = truncate ? iMessage.MaxLength()-3 : aMessage.Length();
    iMessage.Copy(aMessage.Left(numChars));
    if(truncate)
        {
        iMessage.Append(_L8("..."));
        }
    }


inline TRemoteTestResult::TRemoteTestResult(TTestUid aUid, TInt aTestCase, TRemoteTestVerdict aVerdict) :
    iFinished(ETrue),
    iUid(aUid),
    iTestCase(aTestCase),
    iVerdict(aVerdict)
    {
    }

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


#endif