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

//

// Description:

//

/**

 @file

 @test

*/

#include <test/tefunit.h> // for ASSERT macros

#include <iniparser.h>

#include <apgtask.h>

#include <e32math.h>

#include <e32msgqueue.h> 

#include "egltestcommonstep.h"

#include "egltestcommonsession.h"

#include "egltestcommonutils.h"

#include "egltestcommonprocess.h"

static const TUint KDefaultHeapSize = 0x100000;

CEglTestStep::TThreadStatus::TThreadStatus()

    {

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

        {

        iStatus[i] = 0;

        }

    }

EXPORT_C CEglTestStep::CEglTestStep() : 

    iWaitForCompletionOnPostamble(EFalse),

	iSourceFormat(KDefaultSourceFormat),

	iSurfaceFormat(KDefaultSurfaceFormat)

	{

	}

EXPORT_C CEglTestStep::~CEglTestStep()

	{

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

		{

		iProcessStatus[i].iProcess.Close();

		}

	TInt countThread = iThreadStatus.Count();

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

		{

		iThreadStatus[i].iThread.Close();

		}

	iThreadStatus.Close();

    iSemaphore[0].Close();

    iSemaphore[1].Close();

    CleanAll();

    CloseWsSession();

	}

EXPORT_C TVerdict CEglTestStep::doTestStepPreambleL()

	{

	User::LeaveIfError(Logger().ShareAuto());

	//When EGL Logging is enabled this causes a file server session to be allocated

	//Which needs to be done before any handle checks otherwise the test will fail

	ASSERT_EGL_TRUE(eglReleaseThread());	

	__UHEAP_MARK;

	HandleMark();

	return TestStepResult();

	}

EXPORT_C TVerdict CEglTestStep::doTestStepPostambleL()

	{

	if(iWaitForCompletionOnPostamble && (iThreadStatus.Count() > 0))

        {

        INFO_PRINTF1(_L("Main thread waits for other threads to be terminated!!"));

        Test_MultiThread_WaitL(ETrue, TThreadStatus::ELogin);

        }	

	if (iDisplay != EGL_NO_DISPLAY)

		{

		// Output a warning because this should be done by the test

		WARN_PRINTF1(_L("Terminating Display during doTestStepPostambleL"));

		ASSERT_EGL_TRUE(eglTerminate(iDisplay));

		iDisplay = EGL_NO_DISPLAY;

		}

	ASSERT_EGL_TRUE(eglReleaseThread());

	HandleMarkEnd();

 	__UHEAP_MARKEND;

	return TestStepResult();

	}

EXPORT_C void CEglTestStep::CleanAll()

	{

	delete iEglSess;

	iEglSess = NULL;

	if (iDisplay != EGL_NO_DISPLAY)

		{

		ASSERT_EGL_TRUE(eglTerminate(iDisplay));

		iDisplay = EGL_NO_DISPLAY;

		}

	ASSERT_EGL_TRUE(eglReleaseThread());

	}

/*****************************************************************************

 ** Utility methods

 *****************************************************************************/

void CEglTestStep::HandleMark()

	{

	RThread().HandleCount(iProcHandleMark, iThreadHandleMark);

	INFO_PRINTF3(_L("MARK: (%d) process-owned handle(s) / (%d) thread-owned handle(s)"), iProcHandleMark, iThreadHandleMark);

	}

void CEglTestStep::HandleMarkEnd()

	{

	RThread().HandleCount(iProcHandleMarkEnd, iThreadHandleMarkEnd);

	INFO_PRINTF3(_L("MARK-END: (%d) process-owned handle(s) / (%d) thread-owned handle(s)"), iProcHandleMarkEnd, iThreadHandleMarkEnd);

#ifdef __WINS__

	WARN_PRINTF1(_L("Process-owned handle test is ignored on WINS build due to Pls() behaviour."));

#endif

	// When using Pls() on WINS build, it inteferes with handle count assert here due to Pls() behaviour which initialises PLS object

	// on first call of Pls() rather than during DLL loading, which cause extra count into iProcHandleMark.

	// ARMV5 build does not suffer this problem as proper WSD support is used.

#ifndef __WINS__

	ASSERT_EQUALS(iProcHandleMarkEnd, iProcHandleMark);

#endif

	ASSERT_EQUALS(iThreadHandleMarkEnd, iThreadHandleMark);

	}

/** Initialises the window server session and window group objects. */

EXPORT_C void CEglTestStep::OpenWsSessionL(TInt aGroupId)

	{

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

	iWindowGroup = RWindowGroup(iWsSession);

	User::LeaveIfError(iWindowGroup.Construct(aGroupId));

	}

/** Uninitialises the window group object and the window server session. */

EXPORT_C void CEglTestStep::CloseWsSession()

	{

	iWindowGroup.Close();

	iWsSession.Close();

	}

/**

Uses the Eikon Environment to construct a window and put it on top.

@param aWindow A non-constructed window object

@param aRect The intial position and size of the window

@leave Standard system errors

*/

EXPORT_C void CEglTestStep::ConstructWindowL(RWindow& aWindow, const TRect& aRect)

	{

	INFO_PRINTF1(_L("CEglTestStep::CreateWindowL()"));

	const TUint32 ENullWsHandle = 0xFFFFFFFF;	// Events delivered to this handle are thrown away

	aWindow = RWindow(iWsSession);

	CleanupClosePushL(aWindow);

	User::LeaveIfError(aWindow.Construct(iWindowGroup, ENullWsHandle));

	aWindow.SetExtent(aRect.iTl, aRect.Size());

	aWindow.Activate();

	CleanupStack::Pop(&aWindow);

	}

/**

Prints both the Source pixel format and the target pixel format

*/

EXPORT_C void CEglTestStep::PrintUsedPixelConfiguration()

	{

	INFO_PRINTF1(_L("******UsedPixelConfiguration******"));

	INFO_PRINTF1(_L("Source Pixel Format"));

	PrintPixelFormat(iSourceFormat);	

	INFO_PRINTF1(_L("Target Format"));

	PrintVGImageFormat(iSurfaceFormat);

	INFO_PRINTF1(_L("**********************************"));

	}

EXPORT_C void CEglTestStep::PrintPixelFormat(TUidPixelFormat aFormat)

	{

	switch(aFormat)

		{

        case EUidPixelFormatA_8:

            INFO_PRINTF1(_L("EUidPixelFormatA_8"));

            break;

		case EUidPixelFormatRGB_565:

			INFO_PRINTF1(_L("EUidPixelFormatRGB_565"));

			break;

		case EUidPixelFormatXRGB_8888:

			INFO_PRINTF1(_L("EUidPixelFormatXRGB_8888"));

			break;

		case EUidPixelFormatARGB_8888:

			INFO_PRINTF1(_L("EUidPixelFormatARGB_8888"));

			break;

		case EUidPixelFormatARGB_8888_PRE:

			INFO_PRINTF1(_L("EUidPixelFormatARGB_8888_PRE"));

			break;

		default:

			ERR_PRINTF2(_L("Unsupported pixel format (%d)"), aFormat);

			ASSERT_TRUE(EFalse);

		}

	}

EXPORT_C void CEglTestStep::PrintVGImageFormat(VGImageFormat aAttr)

	{

	switch(aAttr)

		{

		case VG_sRGB_565:

			INFO_PRINTF1(_L("VG_sRGB_565"));

			break;

		case VG_sXRGB_8888:

			INFO_PRINTF1(_L("VG_sXRGB_8888"));

			break;

		case VG_sARGB_8888:

			INFO_PRINTF1(_L("VG_sARGB_8888"));

			break;

		case VG_sARGB_8888_PRE:

			INFO_PRINTF1(_L("VG_sARGB_8888_PRE"));

			break;

		default:

			ERR_PRINTF2(_L("Unsupported VGImage format (%d)"), aAttr);

			ASSERT_TRUE(EFalse);

		}

	}

/*****************************************************************************

 ** Multiprocess test utils

 *****************************************************************************/

/**

Launches the specified number of processes, where each process will perform the actions specified in 

the doProcessFunctionL of the calling test. As no images TSgDrawableId has been passed, an 

an array of one (NULL) TSgDrawableId will be created.

@param aProcessCount Number of processes

@param aTestName Name of the calling test case (so that it can call it's doProcessFunctionL method 

@leave Standard system errors

*/  

EXPORT_C void CEglTestStep::Test_MultiProcessL(const TDesC& aTestDllName, TInt aProcessCount, const TDesC& aTestStepName)

	{

	TSgDrawableId sgId;

	Mem::FillZ(&sgId, sizeof(TSgDrawableId));

	Test_MultiProcessL(aTestDllName, aProcessCount, aTestStepName, sgId);

	}

/**

Launches the specified number of processes, where each process will perform the actions specified in 

the doProcessFunctionL of the calling test.

@param aProcessCount Number of processes

@param aTestName Name of the calling test case (so that it can call it's doProcessFunctionL method 

@param aSgId Images TSgDrawableId which will be used to create an array of one TSgDrawableId

@leave Standard system errors

*/  

EXPORT_C void CEglTestStep::Test_MultiProcessL(const TDesC& aTestDllName, TInt aProcessCount, const TDesC& aTestStepName, const TSgDrawableId& aSgId)

	{

	// we assume we pass the same Id to all the processes (array of one)

	RArray<TSgDrawableId> sgIdList;

	ASSERT_EQUALS(sgIdList.Insert(aSgId,0), KErrNone);

	Test_MultiProcessL(aTestDllName, aProcessCount, aTestStepName, sgIdList);

	sgIdList.Close();

	}

/**

Launches the specified number of processes, where each process will perform the actions specified in 

the doProcessFunctionL of the calling test. The association of images and processes is done via the

predefined ImageIndexFromProcessId() method.

@param aProcessCount Number of processes

@param aTestName Name of the calling test case (so that it can call it's doProcessFunctionL method 

@param aSgIdList Array containing the list of images' TSgDrawableId 

@leave Standard system errors

*/  

EXPORT_C void CEglTestStep::Test_MultiProcessL(const TDesC& aTestDllName, TInt aProcessCount, const TDesC& aTestStepName, const RArray<TSgDrawableId>& aSgIdList)

	{

	TInt imageCount = aSgIdList.Count();

	if(aProcessCount <= 0 || imageCount <=0 || aProcessCount > KMaxProcessNumber || imageCount > aProcessCount)

		{

		ERR_PRINTF1(_L("Invalid process request!"));

		User::Leave(KErrArgument);

		}

    // create MsgQueue (only used in some test to pass data between 2 processes)

	RMsgQueue<TSgDrawableId> messageQueueSgId;

	TInt ret = messageQueueSgId.CreateGlobal(KNullDesC, 1, EOwnerProcess);

	ASSERT_EQUALS(ret, KErrNone);

	CleanupClosePushL(messageQueueSgId);

	RMsgQueue<TProcessId> messageQueueProcId;

	ret = messageQueueProcId.CreateGlobal(KNullDesC, 1, EOwnerProcess);

	ASSERT_EQUALS(ret, KErrNone);

	CleanupClosePushL(messageQueueProcId);

    // Create semphores that can be shared (only used in some test to synch between 2 process)

    ret = iSemaphore[0].CreateGlobal(KNullDesC(), 0, EOwnerProcess);

    ASSERT_EQUALS(ret, KErrNone);

    ret = iSemaphore[1].CreateGlobal(KNullDesC(), 0, EOwnerProcess);

    ASSERT_EQUALS(ret, KErrNone);

    // create MsgQueue (only used in some tests to pass data from client processes to the main process)

    RMsgQueue<TEglStepMessageBuffer> messageQueueClientProcParam;

    ret = messageQueueClientProcParam.CreateGlobal(KNullDesC, 1, EOwnerProcess);

    ASSERT_EQUALS(ret, KErrNone);

    CleanupClosePushL(messageQueueClientProcParam);

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

		{

		TProcessInfo info;

		info.iIdx=i;

		info.iSgId=	aSgIdList[ImageIndexFromProcessId(i, imageCount)];

		ret = iProcessStatus[i].iProcess.Create(KEglTestServerWrapperProcess, KNullDesC);

		User::LeaveIfError(ret);

		// Specify the test for the process

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotTestDllName, aTestDllName);

		User::LeaveIfError(ret);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotTestStepName, aTestStepName);

		User::LeaveIfError(ret);	

		// Specify the non-handle params passed to the process

		TPckg<TProcessInfo> pckgInfo(info);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotParams, pckgInfo);

		User::LeaveIfError(ret);

		// Pass in the semaphores

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotSemaphore0, iSemaphore[0]);

		User::LeaveIfError(ret);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotSemaphore1, iSemaphore[1]);

		User::LeaveIfError(ret);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotMsgQueueSgId, messageQueueSgId);

		User::LeaveIfError(ret);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotMsgQueueProcId, messageQueueProcId);

		User::LeaveIfError(ret);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotSourceFormat, static_cast<TInt>(iSourceFormat));

		User::LeaveIfError(ret);

		ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotSurfaceFormat, static_cast<TInt>(iSurfaceFormat));

		User::LeaveIfError(ret);

        ret = iProcessStatus[i].iProcess.SetParameter(EProcSlotCustomClientParam, messageQueueClientProcParam);

        User::LeaveIfError(ret);

		iProcessStatus[i].iProcess.Logon(iProcessStatus[i].iStatus); 

		iProcessStatus[i].iProcess.Resume();

		}

	//by default an empty implementation

    ReceiveMessageFromClient(messageQueueClientProcParam);

	// wait for all processes to complete (not worried about the order)

	// This is needed, as the only way to determine whether the process step has failed is to check

	//  the return value (using TEST(EFalse) has no effect on the spawned process)

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

		{

		User::WaitForRequest(iProcessStatus[i].iStatus);

		CheckProcessStatusL(i, iProcessStatus[i].iStatus, iProcessStatus[i].iProcess);

		RDebug::Print(_L(">>>>>(%d)>> status :%d"), i, iProcessStatus[i].iStatus.Int());

		iProcessStatus[i].iProcess.Close();

		}

	// close MsgQueue and semaphores (as used in some test with 2 spawned processes)

	CleanupStack::PopAndDestroy(3, &messageQueueSgId); //messageQueueClientProcParam, messageQueueProcId

	iSemaphore[1].Close();

	iSemaphore[0].Close();

	}

/**

Check the status of a process running as part of the current teststep. 

@param aIndex Index of the process

@param aStatus The request status of the process in question. 

@param aProcess The process object itself.  

@leave Standard system errors

*/  

void CEglTestStep::CheckProcessStatusL(TInt aIndex, const TRequestStatus& aStatus, const RProcess& aProcess)

	{

	TInt status = aStatus.Int();

	if (status == KErrNone)

		{

		return;

		}

	if (status == KRequestPending)

		{

		// If the process is still running, that's an error, as we waited for the status  

		ERR_PRINTF2(_L("Error in process %d - status should not be KRequestPending"), aIndex);

		User::Leave(KErrTEFUnitFail);

		}

	// Something went wrong

	switch (aProcess.ExitType())

		{

		case EExitPanic:		// The thread or process has been panicked.

			{

			TPtrC ptrExitCategory = aProcess.ExitCategory();

			ERR_PRINTF4(_L("Panic in process %d - category:[%S] reason: %d"), aIndex, &ptrExitCategory, aProcess.ExitReason());

			// Propagate the panic

			User::Panic(aProcess.ExitCategory(), aProcess.ExitReason());

			}

			// follow through

		case EExitKill: 		// The thread or process has ended as a result of a kill, i.e. Kill() has been called on the RThread or RProcess handle. Or a thread was ended as a result of calling User::Exit(). 

		case EExitTerminate: 	// The thread or process has ended as a result of a terminate, i.e. Terminate() has been called on the RThread or RProcess handle. 

		case EExitPending:		// The thread or process is alive. 

		default:

			// Propagate the error

			ERR_PRINTF3(_L("Error in process %d - code %d"), aIndex, aStatus.Int());

			User::Leave(aStatus.Int());

		}

	ASSERT(0);

	}

/*****************************************************************************

 ** Multithread test utils

 *****************************************************************************/

/**

Launches the specified number of threads, where each thread will perform the actions specified in 

the doThreadFunctionL of the calling test. 

@param aThreadCount Number of threads

@param aWaitForCompletion To wait until the launched thread has completed 

@leave Standard system errors

*/  

EXPORT_C void CEglTestStep::Test_MultiThreadL(TInt aThreadCount, TBool aWaitForCompletion)

	{

	if(aThreadCount <= 0 || aThreadCount > KMaxThreadNumber)

		{

		ERR_PRINTF1(_L("Invalid thread request!"));

		User::Leave(KErrArgument);

		}

	iWaitForCompletionOnPostamble = !aWaitForCompletion;

	//we just care for these 2 semaphores

	ASSERT_EQUALS(iSemaphore[0].CreateLocal(0, EOwnerProcess), KErrNone);

	ASSERT_EQUALS(iSemaphore[1].CreateLocal(0, EOwnerProcess), KErrNone);

	_LIT(KThread, "CEglTestStep_Thread");

	_LIT(KUnderScore, "_");

	TInt ret = KErrNone;

	ASSERT_EQUALS(iThreadStatus.Count(),0);

	// Reserve space to avoid reallocation of iThreadStatus.iStatus

	iThreadStatus.ReserveL(aThreadCount);

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

		{

		iThreadInfos[i].iSelf=this;

		iThreadInfos[i].iIdx=i;

		TTime tm;

		TBuf<32> bufTime;

		tm.UniversalTime();

	    tm.FormatL(bufTime, _L("_%H%T%S%C_"));

		// guaranteed unique thread name (useful if several threads are created with aWaitForCompletion = false)

		TName threadName(KThread);

		threadName.Append(KUnderScore);

		threadName.AppendNum(i, EDecimal);

		threadName.Append(KUnderScore);

		threadName.Append(bufTime); 

	    threadName.AppendNum(Math::Random(), EHex);

	    iThreadStatus.AppendL(TThreadStatus());

		ret = iThreadStatus[i].iThread.Create(threadName, ThreadFunction, KDefaultStackSize, KMinHeapSize, KDefaultHeapSize, &iThreadInfos[i], EOwnerProcess);

		User::LeaveIfError(ret);

		if(!aWaitForCompletion)

			{

			// We want to wait for the notification that the extra thread is about to be launched

			// Improves timing issues within a hardware WDP environment

			iThreadStatus[i].iThread.Rendezvous(iThreadStatus[i].iStatus[TThreadStatus::ERendezvous]);

			}

		iThreadStatus[i].iThread.Logon(iThreadStatus[i].iStatus[TThreadStatus::ELogin]);

		iThreadStatus[i].iThread.Resume();

		}

    Test_MultiThread_WaitL(aWaitForCompletion, aWaitForCompletion ? TThreadStatus::ELogin : TThreadStatus::ERendezvous);

   	}

EXPORT_C void CEglTestStep::Test_MultiThread_WaitL(TBool aCloseThreads, TThreadStatus::TStatusId aStatusId)

    {

    // Close handles and wait for all threads to complete (not worried about the order). Note that some 

    //   tests do not require to wait for completion. Nevertheless, care should be taken to ensure that the 

    //   spawned thread is capable of modifying the main TEF process TestStepResult.

    TInt countThread = iThreadStatus.Count();

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

        {

        User::WaitForRequest(iThreadStatus[i].iStatus[aStatusId]);

        CheckThreadStatusL(i, iThreadStatus[i].iStatus[aStatusId], iThreadStatus[i].iThread);

        INFO_PRINTF3(_L(">>>>>(%d)>> status :%d"), i, iThreadStatus[i].iStatus[aStatusId].Int());

        if(aCloseThreads)

            {

            iThreadStatus[i].iThread.Close();

            }

        }

    if(aCloseThreads)

        {

        iThreadStatus.Reset();

        iSemaphore[0].Close();

        iSemaphore[1].Close();

        }

    }

/**

Check the status of a thread running as part of the current teststep. 

@param aIndex Index of the thread

@param aStatus The request status of the thread in question. 

@param aThread The thread object itself.  

@leave Standard system errors

*/ 

void CEglTestStep::CheckThreadStatusL(TInt aIndex, const TRequestStatus& aStatus, const RThread& aThread)

	{

	TInt status = aStatus.Int();

	if (status == KErrNone)

		{

		// All went well

		return;

		}

	if (status == KRequestPending)

		{