// Copyright (c) 2005-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 Te_LbsApiSuiteStepBase.cpp

 @internalTechnology

*/

#include "te_lbsapisuitestepbase.h"

#include "te_lbsapisuitedefs.h"

#include "lcfsbucommondefinitions.h"

_LIT(KPanicThreadName, "TestPanicThread");

const TInt KTestHeapMinSize = 0x4000;

const TInt KTestHeapMaxSize = 0x8000;

// Device driver constants

TVerdict CTe_LbsApiSuiteStepBase::doTestStepPreambleL()

/**

 * @return - TVerdict

 * Implementation of CTestStep base class virtual

 * It is used for doing all initialisation common to derived classes in here.

 * Make it being able to leave if there are any errors here as there's no point in

 * trying to run a test step if anything fails.

 * The leave will be picked up by the framework.

 */

	{

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CTe_LbsApiSuiteStepBase::doTestStepPostambleL()

/**

 * @return - TVerdict

 * Implementation of CTestStep base class virtual

 * It is used for doing all after test treatment common to derived classes in here.

 * Make it being able to leave

 * The leave will be picked up by the framework.

 */

	{

	//SetTestStepResult(EPass);  // or EFail

	return TestStepResult();

	}

CTe_LbsApiSuiteStepBase::~CTe_LbsApiSuiteStepBase()

	{

	}

CTe_LbsApiSuiteStepBase::CTe_LbsApiSuiteStepBase()

	{

	}

//

//

// TOOL FUNCTIONS

//

//

void CTe_LbsApiSuiteStepBase::StandardPrepareL()

{

    START_ERROR_LOGGING;

}

void CTe_LbsApiSuiteStepBase::StandardCleanup()

{

}

//

// PANIC TEST SUPPORT

//

void TurnJITBackOn(TAny* /*aPtr*/)

	{

	User::SetJustInTime (ETrue);

	}

TInt PanicThreadFunction(TAny* aPtr)

	{

	CTrapCleanup* cs = CTrapCleanup::New ();

	if ( cs == NULL)

		return KErrNoMemory;

	// we may need an ActiveScheduler

	CActiveScheduler scheduler;

	CActiveScheduler::Install (&scheduler);

	SPanicThreadFunctionData* data =

			reinterpret_cast<SPanicThreadFunctionData*>(aPtr);

	TInt err;

	TRAP(err, data->iPanicFunction(data->iPtr)); // should panic

	delete cs;

	User::Exit (err);

	return err;

	}

TInt CTe_LbsApiSuiteStepBase::DoPanicTestL (

		TThreadFunction aThreadFunction, TExitCategoryName aExpectedExitCat,

		TInt aExpectedExitReason, TTimeIntervalMicroSeconds32 aTimeoutValue,

		TAny* aPtr)

	{

	DECLARE_ERROR_LOGGING

	;

#ifdef __WINS__

	User::SetJustInTime (EFalse);

	CleanupStack::PushL (TCleanupItem (TurnJITBackOn));

#endif

	RThread panickingThread;

	SPanicThreadFunctionData threadData;

	threadData.iPanicFunction = aThreadFunction;

	threadData.iPtr = aPtr;

	// check that thread does not already exist

	TInt result = KErrNone;

	TBuf<24> threadName(KPanicThreadName);

	result = panickingThread.Create (threadName, PanicThreadFunction,

			KDefaultStackSize, KTestHeapMinSize, KTestHeapMaxSize, &threadData,

			EOwnerProcess);

	CHECK_EQUAL(result, KErrNone, "Unexpected error while creating panic thread")

	;

	User::LeaveIfError (result);

	CleanupClosePushL (panickingThread);

	RTimer timeoutTimer;

	User::LeaveIfError (timeoutTimer.CreateLocal ());

	CleanupClosePushL (timeoutTimer);

	TRequestStatus timerStatus;

	timeoutTimer.After (timerStatus, aTimeoutValue);

	TRequestStatus threadStatus;

	panickingThread.Rendezvous (threadStatus);

	if ( threadStatus != KRequestPending)

		{

		// logon failed - thread is not yet running, so cannot have terminated

		User::WaitForRequest (threadStatus); // eat signal

		panickingThread.Kill (threadStatus.Int ()); // abort startup

		}

	else

		{

		panickingThread.Resume ();

		User::WaitForRequest (threadStatus, timerStatus);

		}

	TInt exitReason = KErrNone;

	if ( threadStatus == KRequestPending)

		{

		ERR("Thread didn't die. Killing it...");

		panickingThread.Kill (KErrTimedOut);

		User::WaitForRequest (threadStatus);

		}

	else // (timerStatus == KRequestPending)

		{

		// stop timer

		timeoutTimer.Cancel ();

		User::WaitForRequest (timerStatus);

		}

	exitReason = panickingThread.ExitReason ();

	TExitCategoryName exitCat;

	switch (panickingThread.ExitType ())

		{

	case EExitKill:

		message.Format (_L("Thread was Killed with Reason %d"), exitReason);

		LOG_DES(message);

		break;

	case EExitTerminate:

		message.Format (_L("Thread was Terminated with Reason %d"), exitReason);

		LOG_DES(message);

		break;

	case EExitPanic:

		// check exit reasons

		exitCat = panickingThread.ExitCategory ();

		if ( exitCat.Compare (aExpectedExitCat) != 0)

			{

			message.Format (_L("Unexpected panic category: Actual '%S', Expected '%S'"),

			&exitCat, &aExpectedExitCat);

			LOG_DES(message);

			}

		CHECK_EQUAL(exitReason, aExpectedExitReason, "Unexpected panic reason");

		break;

	default:

		CHECK_EQUAL((TInt)EExitPanic, threadStatus.Int(), "Unexpected thread exit type!");

		break;

		}

	CleanupStack::PopAndDestroy (&timeoutTimer);

	CleanupStack::PopAndDestroy (&panickingThread);

#ifdef __WINS__

	CleanupStack::PopAndDestroy (); //TurnJITBackOn

#endif

	// wait a bit to make sure this thread is over

	const TTimeIntervalMicroSeconds32 KThreadDelay = 1000 * 1000; // 1 s

	User::After (KThreadDelay);

	return exitReason;

	}

void CheckPanic(const char* aFileName, TInt aLine)

	{

    TBuf<64> file;

    TBuf<80> panic;

    file.Copy(TPtrC8(_S8(aFileName)).Right(file.MaxLength()));

    file = file.Mid(file.LocateReverse('\\')+1);

    panic.Format(_L("%d-%S"), aLine, &file);

    User::Panic(panic, KErrGeneral);

	}