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

 @internalTechnology

*/

#include "t_coredumpmonitor.h"

//Names of functions to be tested - referenced from script file

_LIT(KUntrustedAccessToSCMConfig, "UntrustedAccessToSCMConfig");

_LIT(KGatherTraceBuffer, "GatherTraceBuffer");

_LIT(KTrustedAccessToSCMConfig, "TrustedAccessToSCMConfig");

_LIT(KReadDefaultConfigValues, "ReadDefaultConfigValues");

_LIT(KValidateNewestCrash, "ValidateNewestCrash");

/**

 * Constructor for test wrapper

 */

CCoreDumpMonitorWrapper::CCoreDumpMonitorWrapper()

	{

	}

/**

 * Destructor

 */

CCoreDumpMonitorWrapper::~CCoreDumpMonitorWrapper()

	{

	iCoreDumpSession.Close();

	iCrashList.ResetAndDestroy();

	iFsSession.Close();

	}

/**

 * Two phase constructor for CCoreDumpMonitorWrapper

 * @return CCoreDumpMonitorWrapper object

 * @leave

 */

CCoreDumpMonitorWrapper* CCoreDumpMonitorWrapper::NewL()

	{

	CCoreDumpMonitorWrapper* ret = new (ELeave) CCoreDumpMonitorWrapper();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

/**

 * Safe construction

 * @leave

 */

void CCoreDumpMonitorWrapper::ConstructL()

	{

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

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

	}

/**

 * Assign the object

 * @param aObject TAny* to the object to test

 * @leave

 */

void CCoreDumpMonitorWrapper::SetObjectL(TAny* aObject)

	{}

/**

 * Runs a test preamble

 */

void CCoreDumpMonitorWrapper::PrepareTestL()

	{

	SetBlockResult(EPass);

	INFO_PRINTF1(_L("CCoreDumpMonitorWrapper::Ready to start test"));

	}

/**

 * Handle a command invoked from the script

 * @param aCommand Is the name of the command for a TBuf

 * @param aSection Is the .ini file section where parameters to the command are located

 * @param aAsyncErrorIndex Is used by the TEF Block framework to handle asynchronous commands.

 */

TBool CCoreDumpMonitorWrapper::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

	{

	//__UHEAP_MARK;	

	PrepareTestL();

	if (KUntrustedAccessToSCMConfig() == aCommand)

		{

		TestUntrustedAccessToCDSConfigL();

		}

	else if(KGatherTraceBuffer() == aCommand)

		{

		TestTraceBufferAccessL();

		}

	else if(KTrustedAccessToSCMConfig() ==aCommand)

		{

		TestTrustedAccessToCDSConfigL();

		}

	else if (KReadDefaultConfigValues() == aCommand)

		{

		TestReadDefaultConfigValuesL();

		}

else if(KValidateNewestCrash() == aCommand)

		{

		TestValidateNewestCrashL();

		}

	else

		{

		return EFalse;

		}

	//__UHEAP_MARKEND;

	return ETrue;

	}

void CCoreDumpMonitorWrapper::TestTrustedAccessToCDSConfigL()

	{

	INFO_PRINTF1(_L("TestTrustedAccessToCDSConfigL"));

	INFO_PRINTF1(_L("Getting the number of config parameters"));

	TUint numConfigParams = 0;

	TRAPD(err, numConfigParams = iCoreDumpSession.GetNumberConfigParametersL());

	if(KErrNone != err)

		{

		ERR_PRINTF2(_L("Unable to get the number of config parameters. Returned %d"), err);		

		SetBlockResult(EFail);

		return;

		}

	INFO_PRINTF2(_L("Found %d params"), numConfigParams);

	TBool foundScmConfig = EFalse;

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

		{

		COptionConfig* conf;

		conf = iCoreDumpSession.GetConfigParameterL(i);

		if (conf->Source()== COptionConfig::ESCMConfig)

			{

			foundScmConfig = ETrue;

			}

		delete conf;

		}

	if(!foundScmConfig)

		{

		ERR_PRINTF1(_L("Not Able to retrieve a config param for the SCM"));		

		SetBlockResult(EFail);

		return;

		}

	INFO_PRINTF1(_L("Looked at all config parameters and found some SCM params so that is a pass"));

	}

/**

 * Tests that that CDS enforces that untrusted users cannot 

 * access the CDS configuration

 */

void CCoreDumpMonitorWrapper::TestUntrustedAccessToCDSConfigL()

	{

	INFO_PRINTF1(_L("TestUntrustedAccessToCDSConfigL"));

	INFO_PRINTF1(_L("Getting the number of config parameters"));

	TUint numConfigParams = 0;

	TRAPD(err, numConfigParams = iCoreDumpSession.GetNumberConfigParametersL());

	if(KErrNone != err)

		{

		ERR_PRINTF2(_L("Unable to get the number of config parameters. Returned %d"), err);		

		SetBlockResult(EFail);

		return;

		}

	INFO_PRINTF2(_L("Found %d params"), numConfigParams);

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

		{

		COptionConfig* conf;

		conf = iCoreDumpSession.GetConfigParameterL(i);

		if (conf->Source()== COptionConfig::ESCMConfig)

			{

			ERR_PRINTF1(_L("Able to retrieve a config param for the SCM"));		

			SetBlockResult(EFail);

			delete conf;

			return;

			}

		delete conf;

		}

	INFO_PRINTF1(_L("Looked at all config parameters and none were SCM params so that is a pass"));

	}

void CCoreDumpMonitorWrapper::TestTraceBufferAccessL()

	{

	//Step 1: Load the UTRACE formatter and file writter

	INFO_PRINTF1(_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL loading UTRACE Formatter and File Writer"));

	TPluginRequest loadUtracePlugin;

	loadUtracePlugin.iPluginType = TPluginRequest::EFormatter;

	loadUtracePlugin.iLoad = ETrue;

	loadUtracePlugin.iUid = KUtraceUid;	

	TPluginRequest loadWriterReq;

	loadWriterReq.iPluginType = TPluginRequest::EWriter;

	loadWriterReq.iLoad = ETrue;

	loadWriterReq.iUid = KUidFileWriter;

	// loading Symbian ELF formatter

	TRAPD(err, iCoreDumpSession.PluginRequestL(loadUtracePlugin));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL() Could not load UTRACE plugin!, err:%d\n"), err);

		SetBlockResult(EFail);

		User::Leave(err);

		}	

	// loading Symbian File writer

	TRAP(err, iCoreDumpSession.PluginRequestL(loadWriterReq));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL() Could not load writer plugin!, err:%d\n"), err);

		SetBlockResult(EFail);

		User::Leave(err);

		}

	//Configuring the file writer plugin to have a specified crash file name

	TRAP(err, DoConfigureL((TInt)(CCrashDataSave::ECoreFilePath),

			KUidFileWriter.iUid, COptionConfig::EWriterPlugin,

			COptionConfig::ETFileName, KFilePathPrompt, 1, KNullDesC, 0,

			KCrashFileName, 0));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL()() for File Writer Error %d changing param"),

				err);

		SetBlockResult(EFail);

		User::Leave(err);

		}	

	//List crashes in flash

	iCrashList.Reset();

	TRAP(err, iCoreDumpSession.ListCrashesInFlashL(iCrashList));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL() Could not read Crashes in the Flash! err:%d\n"), err);

		SetBlockResult(EFail);

		User::Leave(err);

		}	

	INFO_PRINTF2(_L("Number of crashes present: %d"),	iCrashList.Count());

	if(iCrashList.Count() == 0)

		{

		ERR_PRINTF1(_L("Failed to find any crashes in log for the analysing"));

		SetBlockResult(EFail);

		User::Leave(err);

		}

	//Step 2: Process the crash

	for (TInt i = 0; i < iCrashList.Count(); i++)

		{

		TRAP(err, iCoreDumpSession.ProcessCrashLogL(iCrashList[i]->iCrashId));

		if (err != KErrNone)

			{

			ERR_PRINTF2(_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL() Could not process crash! err:%d\n"), err);

			SetBlockResult(EFail);

			User::Leave(err);

			}

		}

	INFO_PRINTF1(_L("Crashes Processed, Now looking for file generated"));

	//Step 3: Check the trace file has been generated

	//Use wildcard utilities to search for the UTRACE FIle Created

	TBuf<32> buf;

	buf = KDir;

	TUidType uid1;

	TUidType uid2(uid1.MostDerived());

	CFindFileByType* obj = new(ELeave) CFindFileByType(iFsSession);

	CleanupStack::PushL(obj);

	err = obj->FindFirst(KCrashWildCard, buf, uid2);

	if (err != KErrNone)

		{

		ERR_PRINTF2(

				_L("CCoreDumpMonitorWrapper::TestTraceBufferAccessL() Error finding the UTRACE File %d"),

				err);

		SetBlockResult(EFail);

		User::Leave(err);

		}

	INFO_PRINTF2(_L("The UTRACE File Found is E:\\:%S "), &(obj->Entry().iName));	

	CleanupStack::PopAndDestroy(); //CFindFileByType

	//Future improvements: Check contents of file

	}

/**

 * Tests that that after deletion of the entire partition  

 * SCM config values should correspond to the default build time values

 */

void CCoreDumpMonitorWrapper::TestReadDefaultConfigValuesL()

	{

	INFO_PRINTF1(_L("CCoreDumpMonitorWrapper::TestReadDefaultConfigValuesL Match with Build time SCM config values"));

	TInt noConfigParams = 0;

	TInt scmConfigParams = 0;

	// this will ultimateley read the config

    TRAPD(err, noConfigParams = iCoreDumpSession.GetNumberConfigParametersL());

    if(err != KErrNone)

        {

        ERR_PRINTF1(_L("Could not read number of config params"));

		SetBlockResult(EFail);

		User::Leave(KErrGeneral);       

        }

    else

    	{	

    	INFO_PRINTF2(_L("Found %d config params"), noConfigParams);

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

			{

			COptionConfig* conf = iCoreDumpSession.GetConfigParameterL(i);

			CleanupStack::PushL(conf);

			if (conf->Source()== COptionConfig::ESCMConfig)

				{

				//count number of SCM configurations

				scmConfigParams++;

				TConfigItem::TSCMDataType dataType = (TConfigItem::TSCMDataType) conf->Instance();

				//Default SCM Configuration for TConfigItem::EThreadsUsrStack has priority = 0

				if(dataType == TConfigItem::EThreadsUsrStack && conf->Value() != 0)  

					{

					ERR_PRINTF3(_L("TConfigItem::EThreadsUsrStack did not match the ZERO Priority for config data type %d with priority %d"), dataType, conf->Value());

					SetBlockResult(EFail);

					User::Leave(KErrGeneral);

					}

				//Default SCM Configuration for TConfigItem::EThreadsSvrStack has priority = 0

				else if(dataType == TConfigItem::EThreadsSvrStack && conf->Value() != 0)

					{

					ERR_PRINTF3(_L("TConfigItem::EThreadsSvrStack did not match the ZERO Priority for config data type %d with priority %d"), dataType, conf->Value());

					SetBlockResult(EFail);

					User::Leave(KErrGeneral);

					}

				else if (dataType == TConfigItem::EThreadsSvrStack || dataType == TConfigItem::EThreadsUsrStack)

						{

						INFO_PRINTF3(_L("VERIFIED ZERO priority for config data type %d priority %d"), dataType, conf->Value());

						CleanupStack::PopAndDestroy(conf);

						continue;

						}

				//Default SCM Configuration for all has a priority value equal to thier postion in the list + 1

				if(conf->Value() != (dataType + 1) )

					{

					ERR_PRINTF3(_L("Did not match the DEFAULT Configurtion for config data type %d with priority %d"), dataType, conf->Value());

					SetBlockResult(EFail);

					User::Leave(KErrGeneral);			

					}

				//happy to print the value

				INFO_PRINTF3(_L("VERIFIED config data type %d has priority %d"), dataType, conf->Value());

				}

			CleanupStack::PopAndDestroy(conf);//COptionConfig

			}//for loop for noConfigParams

		INFO_PRINTF2(_L("Match with DEFAULT config values Successful for %d SCM Configuration Parameters"),scmConfigParams);

    	}//else for no errors GetNumberConfigParametersL

	}

/**

 * @return void

 * @param aIndex Internal index to the component that owns the object

 * @param aUID UID of the component that owns the object

 * @param aSource Type of component that owns the object

 * @param aType Type of parameter

 * @param aPrompt Prompt to present to user 

 * @param aNumOptions Number of options that the parameter can be set to. Only applies if type is ETMultiEntryEnum.

 * @param aOptions Comma separated list of options. Applies to ETMultiEntryEnum and ETBool

 * @param aVal Integer value. Applies to ETInt, ETUInt, ETBool

 * @param aStrValue String value. Applies to ETString, ETFileName, ETMultiEntry, ETBool

 */

void CCoreDumpMonitorWrapper::DoConfigureL(const TUint32& aIndex,

		const TUint32& aUID, const COptionConfig::TParameterSource& aSource,

		const COptionConfig::TOptionType& aType, const TDesC& aPrompt,

		const TUint32& aNumOptions, const TDesC& aOptions, const TInt32& aVal,

		const TDesC& aStrValue, const TUint aInstance)

	{

	COptionConfig * config;

	config = COptionConfig::NewL(aIndex, aUID, aSource, aType, aPrompt,

			aNumOptions, aOptions, aVal, aStrValue);

	CleanupStack::PushL(config);

	config->Instance(aInstance);

	//Configure now...

	iCoreDumpSession.SetConfigParameterL(*config);

	CleanupStack::PopAndDestroy(config);

	}

void CCoreDumpMonitorWrapper::TestValidateNewestCrashL()

	{

	INFO_PRINTF1(_L("TestValidateNewestCrashL called"));

	//Do list all the Crash Information here

	TRAPD(err, iCoreDumpSession.ListCrashesInFlashL(iCrashList));

	if (err != KErrNone)

		{

		ERR_PRINTF2(

				_L("TestValidateNewestCrashL Could not read Crashes in the Flash! err:%d\n"),

				err);

		SetBlockResult(EFail);

		return;

		//User::Leave(err);

		}

	INFO_PRINTF2(_L("TestValidateNewestCrashL Number of crash information present: %d"),

			iCrashList.Count());

	TInt expectedNewestIndex = 0;

	if( iCrashList.Count() > 0)

		{

		// must be entries for test to potentially fail	

		TInt newestIndex = 0;

		// start with first entry being newest time

		TUint64 newestTime = iCrashList[0]->iTime;

		for (TInt i = 0; i < iCrashList.Count(); i++)

			{		

			INFO_PRINTF3(_L("Crash no: %d, CrashId %d"), i, iCrashList[i]->iCrashId);

			INFO_PRINTF3(_L("Crash no: %d, Type %ld"), i, iCrashList[i]->iType);

			INFO_PRINTF3(_L("Crash no: %d, Time %ld"), i, iCrashList[i]->iTime);

			INFO_PRINTF3(_L("Crash no: %d, Thread ID %ld"), i, iCrashList[i]->iTid);

			// crash time held in the header as TUint64 - highest value should be the newset crash

			if(iCrashList[i]->iTime > newestTime)

				{

				newestIndex = i;

				newestTime = iCrashList[i]->iTime;

				}	

			}

		INFO_PRINTF2(_L("Newest crash is Crash no: %d"), newestIndex);

		if(newestIndex != expectedNewestIndex)

			{

			ERR_PRINTF3(_L("DoCmdValidateNewestCrashL newest crash was not in expected position expected (%d) actual(%d)")

					, expectedNewestIndex, newestIndex);

			SetBlockResult(EFail);

			//User::Leave(err);

			}			

		}

	INFO_PRINTF1(_L("TestValidateNewestCrashL finished"));

	}

//eof