// 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+
−
#ifndef __INIPARSER_H__+
−
#include <cinidata.h>+
−
#endif // __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)+
−
		{+
−
		// If the thread is still running, that's an error, as we waited for the status  +
−
		ERR_PRINTF2(_L("Error in thread %d - status should not be KRequestPending"), aIndex);+
−
		User::Leave(KErrTEFUnitFail);+
−
		}+
−
	// Something went wrong+
−
	switch (aThread.ExitType())+
−
		{+
−
		case EExitPanic:		// The thread or process has been panicked.+
−
			{+
−
			TPtrC ptrExitCategory = aThread.ExitCategory();+
−
			ERR_PRINTF4(_L("Panic in thread %d - category:[%S] reason: %d"), aIndex, &ptrExitCategory, aThread.ExitReason());+
−
			User::Panic(aThread.ExitCategory(), aThread.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 thread %d - code %d"), aIndex, status);+
−
			User::Leave(aStatus.Int());+
−
		}+
−
	// We should not get here!+
−
	ASSERT(0);+
−
	}+
−
+
−
TInt CEglTestStep::ThreadFunction(TAny* aInfo)+
−
// static+
−
	{+
−
	__UHEAP_MARK;+
−
	CTrapCleanup* cleanup = CTrapCleanup::New();+
−
	if(cleanup == NULL)+
−
		{+
−
		return KErrNoMemory;+
−
		}+
−
+
−
	CEglTestStep::TThreadInfo* info = reinterpret_cast<CEglTestStep::TThreadInfo*>(aInfo);+
−
	TRAPD(err, info->iSelf->ThreadFunctionL(*info));+
−
+
−
	delete cleanup;+
−
	__UHEAP_MARKEND;+
−
	return err;+
−
	}+
−
+
−
void CEglTestStep::ThreadFunctionL(TThreadInfo& aInfo)+
−
	{+
−
	// Mark the handle count for this thread+
−
	TInt processHandleMark=0;+
−
	TInt threadHandleMark=0;+
−
	RThread().HandleCount(processHandleMark, threadHandleMark);+
−
	INFO_PRINTF4(_L("MARK: THREAD %d: (%d) process-owned handle(s) / (%d) thread-owned handle(s)"), aInfo.iIdx, processHandleMark, threadHandleMark);	+
−
	+
−
	// Notify the main thread that we are about to launch the extra thread+
−
	RThread::Rendezvous(KErrNone);+
−
	+
−
	// Run the real thread funciton+
−
	aInfo.iSelf->doThreadFunctionL(aInfo.iIdx);+
−
+
−
	// Release EGL thread state+
−
	INFO_PRINTF2(_L("thread %d: Calling eglReleaseThread()"), aInfo.iIdx);+
−
	ASSERT_EGL_TRUE(eglReleaseThread());+
−
	+
−
	// Check the handle count for this thread has not changed+
−
	TInt processHandleMarkEnd=0;+
−
	TInt threadHandleMarkEnd=0;+
−
	RThread().HandleCount(processHandleMarkEnd, threadHandleMarkEnd);+
−
	INFO_PRINTF4(_L("MARK-END: THREAD %d: (%d) process-owned handle(s) / (%d) thread-owned handle(s)"), aInfo.iIdx, processHandleMarkEnd, threadHandleMarkEnd);+
−
	+
−
	//Not testing equality of process-owned handles as these should only be tested from the main thread.+
−
	//Process handlecount is dependent on all threads, therefore process handle imbalances could be the responsibility of other threads.+
−
	ASSERT_EQUALS(threadHandleMark, threadHandleMarkEnd);+
−
	}+
−
+
−
/**+
−
Tests should override this method for multithreaded testing+
−
*/+
−
EXPORT_C void CEglTestStep::doThreadFunctionL(TInt aIdx)+
−
	{+
−
	// Not supported for this test step+
−
	ERR_PRINTF2(_L("thread %d: Calling CEglTestStep::doThreadFunctionL() - should be overriden"), aIdx);+
−
	User::Leave(KErrNotSupported);+
−
	}+
−
+
−
EXPORT_C void CEglTestStep::doThreadFunctionL(TInt aIdx,const TSgDrawableId& aSgId)+
−
	{+
−
	// Not supported for this test step+
−
	ERR_PRINTF3(_L("thread %d: Calling CEglTestStep::doThreadFunctionL() - should be overriden, TSgDrawableId %lu."), aIdx, aSgId.iId);+
−
	User::Leave(KErrNotSupported);+
−
	}+
−
+
−
/**+
−
Tests should override this method for multiprocess testing+
−
*/+
−
EXPORT_C void CEglTestStep::doProcessFunctionL(TInt aIdx)+
−
	{+
−
	// Not supported for this test step+
−
	ERR_PRINTF2(_L("Process %d: Calling CEglTestStep::doProcessFunctionL() - should be overriden"), aIdx);+
−
	User::Leave(KErrNotSupported);+
−
	}+
−
+
−
EXPORT_C void CEglTestStep::doProcessFunctionL(TInt aIdx,const TSgDrawableId& aSgId)+
−
	{+
−
	// Not supported for this test step+
−
	ERR_PRINTF3(_L("Process %d: Calling CEglTestStep::doProcessFunctionL() - should be overriden, TSgDrawableId %lu."), aIdx, aSgId.iId);+
−
	User::Leave(KErrNotSupported);+
−
	}+
−
+
−
+
−
/**+
−
Rendezvous: Ensures that both threads get to this point before continuing+
−
@param aIdx The thread index value that was passed into+
−
			the override of CEglTestStep::doThreadFunctionL()+
−
*/+
−
EXPORT_C void CEglTestStep::Rendezvous(TInt aIdx)+
−
	{+
−
	if(aIdx >= 2)+
−
	    {+
−
	    // Currently Rendezvous is only supported between threads with index 0 and index 1+
−
	    INFO_PRINTF2(_L("CEglTestStep::Rendezvous() - aIdx (%d) is too big!!"), aIdx);+
−
	    ASSERT(0);+
−
	    }+
−
	INFO_PRINTF2(_L("thread %d: ...At Rendezvous..."), aIdx);+
−
	iSemaphore[aIdx].Signal();+
−
	iSemaphore[1-aIdx].Wait();+
−
	}+
−
+
−
+
−
/*****************************************************************************+
−
 ** Egl Helpers+
−
 *****************************************************************************/+
−
 +
−
/**+
−
Temporarily initializes the EGL thread and display in order to check for the +
−
supplied extension string.+
−
The display is then released and terminated.+
−
Use this method to pre-check for the existence of an extension string prior +
−
to starting a test.+
−
There are 2 ways to ask for an extension, via the ID (the default way to do it) +
−
or passing a string containing the full name of the extension (used in some tests only)+
−
@param aExtensions The extension ID to look for+
−
@param aExtensionName The extension name to look for+
−
@return Whether the extension string can be found+
−
*/+
−
EXPORT_C TBool CEglTestStep::CheckForExtensionL(TInt aExtensions, const TDesC& aExtensionName)+
−
	{+
−
	ASSERT_TRUE(iDisplay == EGL_NO_DISPLAY);+
−
	GetDisplayL();+
−
	CTestEglSession* eglSess = CTestEglSession::NewLC(Logger(), iDisplay, -1);+
−
	eglSess->InitializeL();+
−
	+
−
	TBool bFoundExtensions = eglSess->CheckNeededExtensionL(aExtensions, aExtensionName);+
−
	+
−
	// Cleanup EGL Completely+
−
	CleanupStack::PopAndDestroy(eglSess);+
−
	eglSess = NULL;+
−
	TerminateDisplayL();+
−
	ASSERT_EGL_TRUE(eglReleaseThread());+
−
+
−
	// return whether the extension string was found+
−
	return bFoundExtensions;+
−
	}+
−
+
−
/**+
−
Uses eglGetDisplay() to initialise iDisplay, and to check the result of the call+
−
*/+
−
EXPORT_C void CEglTestStep::GetDisplayL()+
−
	{+
−
	INFO_PRINTF1(_L("Calling eglGetDisplay..."));+
−
	+
−
	iDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);+
−
	ASSERT_EGL_TRUE(iDisplay != EGL_NO_DISPLAY);+
−
	}+
−
+
−
/**+
−
If the iDisplay has been initialised then this method uses eglTerminate() +
−
to terminate iDisplay, and to check the result of the call.+
−
This method also resets the value of iDisplay to EGL_NO_DISPLAY to indicate+
−
that the display is no longer initialised.+
−
*/+
−
EXPORT_C void CEglTestStep::TerminateDisplayL()+
−
	{+
−
	if (iDisplay != EGL_NO_DISPLAY)+
−
		{+
−
		INFO_PRINTF1(_L("Calling eglTerminate..."));+
−
		ASSERT_EGL_TRUE(eglTerminate(iDisplay));+
−
		iDisplay = EGL_NO_DISPLAY;+
−
		}+
−
	}+
−
+
−
/**+
−
Cut and paste from CTestStep::SetLogger() - which is not exported+
−
As the name suggests, this is for use by the egl test process wrapper+
−
*/+
−
void CEglTestStep::SetLoggerForProcessWrapperL()+
−
	{+
−
	// Create a cinidata object for parsing the testexecute.ini+
−
	CTestExecuteIniData* parseTestExecuteIni = NULL;+
−
	TBuf<KMaxTestExecuteNameLength> resultFilePath;+
−
	TBuf<KMaxTestExecuteNameLength> xmlFilePath;+
−
	TInt logMode;+
−
	TInt logLevel;+
−
	+
−
	TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL());+
−
	if (err == KErrNone)+
−
		{+
−
		CleanupStack::PushL(parseTestExecuteIni);+
−
		parseTestExecuteIni->ExtractValuesFromIni();+
−
		parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, resultFilePath);+
−
		parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlFilePath);+
−
		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);+
−
		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);+
−
		parseTestExecuteIni->GetKeyValueFromIni(KTEFEnableIniAccessLog, IniAccessLog());+
−
		}+
−
	else+
−
		{+
−
		resultFilePath.Copy(KTestExecuteLogPath);+
−
		xmlFilePath.Copy(KTestExecuteLogPath);+
−
		logMode = TLoggerOptions(ELogHTMLOnly);+
−
		logLevel = RFileFlogger::TLogSeverity(ESevrAll);+
−
		IniAccessLog() = ETrue;+
−
		}+
−
	Logger().SetLoggerOptions(logMode);+
−
		+
−
	// Initialise a handle to the file logger+
−
	User::LeaveIfError(Logger().Connect());+
−
	RFs fS;+
−
	User::LeaveIfError(fS.Connect());+
−
	CleanupClosePushL(fS);+
−
	RFile file;+
−
	TBuf<KMaxTestExecuteNameLength> xmlLogFile(xmlFilePath);+
−
	TBuf<KMaxTestExecuteNameLength> logFile;+
−
	TBuf<KMaxTestExecuteNameLength> logFileNameFile(resultFilePath);+
−
	logFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile);+
−
	if(file.Open(fS,logFileNameFile,EFileRead | EFileShareAny) != KErrNone)+
−
		{+
−
		// For the old flogger we have to create an individual file+
−
		logFile.Copy(TestStepName());+
−
		_LIT(KTxtExtension,".txt");+
−
		logFile.Append(KTxtExtension);+
−
		logMode = TLoggerOptions(0);+
−
		Logger().SetLoggerOptions(logMode);+
−
		}+
−
	else+
−
		{+
−
		CleanupClosePushL(file);+
−
		TBuf8<KMaxTestExecuteNameLength> logFile8;+
−
		TInt fileSize;+
−
		User::LeaveIfError(file.Size(fileSize));+
−
		User::LeaveIfError(file.Read(logFile8,fileSize));+
−
		logFile.Copy(logFile8);+
−
		xmlLogFile.Append(logFile);+
−
		_LIT(KXmlExtension,".xml");+
−
		xmlLogFile.Append(KXmlExtension);+
−
		_LIT(KHtmExtension,".htm");+
−
		logFile.Append(KHtmExtension);+
−
		CleanupStack::Pop(&file);+
−
		file.Close();+
−
		}+
−
	TBuf<KMaxTestExecuteLogFilePath> logFilePath(resultFilePath);+
−
	logFilePath.Append(logFile);+
−
	CleanupStack::Pop(&fS);+
−
	fS.Close();+
−
	+
−
	if (logMode == 0 || logMode == 2)+
−
		{+
−
		User::LeaveIfError(Logger().HtmlLogger().CreateLog(logFilePath,RTestExecuteLogServ::ELogModeAppend));+
−
		Logger().HtmlLogger().SetLogLevel(TLogSeverity(logLevel));+
−
		}+
−
	if (logMode == 1 || logMode == 2)+
−
		{+
−
		User::LeaveIfError(Logger().XmlLogger().CreateLog(xmlLogFile,RFileFlogger::ELogModeAppend));+
−
		Logger().XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(logLevel));+
−
		}+
−
	if (parseTestExecuteIni != NULL)+
−
		{+
−
		CleanupStack::PopAndDestroy(parseTestExecuteIni);+
−
		}+
−
	}+
−
+
−
EXPORT_C void CEglTestStep::PartialInitialiseL(const TDesC& aStepName)+
−
	{+
−
	SetTestStepName(aStepName);	+
−
	SetLoggerForProcessWrapperL();+
−
	// Assume pass+
−
	SetTestStepResult(EPass);+
−
	}+
−
+
−
EXPORT_C void CEglTestStep::CreateEglSessionL(TInt aIdx)+
−
	{+
−
	delete iEglSess; //just in case it was called twice+
−
	iEglSess = CTestEglSession::NewL(Logger(), iDisplay, aIdx);+
−
	}+
−
+
−