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

// Example CTestStep derived implementation

//

/**

 @file te_tracecollectorclient.cpp

 @internalTechnology

*/

#include "te_advancedfiltering.h"

#include "te_ostv2integsuite_defs.h"

#include "te_instrumentationpoints.h"

#include "te_tracecontrolcmds.h"

#include "te_advancedfilteringTraces.h"

#include <opensystemtrace.h>

#include <uloggerclient.h>

using namespace Ulogger; //CA:added so can use old ulogger api

#ifdef TE_UPT_TRACE_ENABLED

_LIT(KTextvalue, "C:\\logs\\ULoggerStartFileTestLog.utf");

#endif

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

/*********************************Primary Filter Test***************************/

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

CTCMAdvancedGroupIDFilteringWrapper::~CTCMAdvancedGroupIDFilteringWrapper()

/**

 * Destructor

 */

	{

	}

CTCMAdvancedGroupIDFilteringWrapper::CTCMAdvancedGroupIDFilteringWrapper()

/**

 * Constructor

 */

	{

	}

CTCMAdvancedGroupIDFilteringWrapper* CTCMAdvancedGroupIDFilteringWrapper::NewLC()

	{

	CTCMAdvancedGroupIDFilteringWrapper* self = new (ELeave)CTCMAdvancedGroupIDFilteringWrapper();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTCMAdvancedGroupIDFilteringWrapper* CTCMAdvancedGroupIDFilteringWrapper::NewL()

	{

	CTCMAdvancedGroupIDFilteringWrapper* self=CTCMAdvancedGroupIDFilteringWrapper::NewLC();

	CleanupStack::Pop(); // self;

	return self;

	}

void CTCMAdvancedGroupIDFilteringWrapper::ConstructL()

	{

	}

TAny* CTCMAdvancedGroupIDFilteringWrapper::GetObject()

	{

	return NULL;

	}

TBool CTCMAdvancedGroupIDFilteringWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,

					const TTEFSectionName& /*aSection*/,

					const TInt /*aAsyncErrorIndex*/)

	{

	  if(BlockResult()==EPass)

		{

		//  ************** Delete the Block, the block start ****************

		TBool OstStatus=EFalse;

#ifdef TE_UPT_TRACE_ENABLED

		EmptyFile(KTextvalue);

		OstStatus=ETrue;

#endif

		TInt result=0;

		RULogger logger;

		/**************First set primary filter*************/

		result=logger.Connect();

        INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);

            if (result!=KErrNone)

            {

            INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));

            for (TInt i=2; i<12;i++)

               {

               User::After(1000);

               result = logger.Connect();

               INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);

               if (result==KErrNone)

                    {

                    break;

                    }

               }

            }

		CClearConfig configIni;

		INFO_PRINTF2(_L("connect err %d"), result);

		INFO_PRINTF1(_L("Test setting a single primary filter with the filter, rather than an array"));

		CArrayFixFlat<TUint8> *setfilterarray = new (ELeave)CArrayFixFlat<TUint8>(1); //CA:added so can use old ulogger api

		CleanupStack::PushL(setfilterarray); //CA:added

		TGroupId setfilter = KGroupId;

		setfilterarray->AppendL(setfilter); //CA:added so can use old ulogger api

		CArrayFixFlat<TUint8> *getfilter = new (ELeave)CArrayFixFlat<TUint8>(1);

		CleanupStack::PushL(getfilter); //CA:added

		CArrayFixFlat<TUint8> *removefilterarray = new (ELeave)CArrayFixFlat<TUint8>(1); //CA:added so can use old ulogger api

		CleanupStack::PushL(removefilterarray); //CA:added

		TGroupId removefilter = setfilter;

		removefilterarray->AppendL(removefilter); //CA:added so can use old ulogger api

		result=logger.SetPrimaryFiltersEnabled(*setfilterarray,ETrue);//C.A. previously:Result=logger.EnableClassification(setfilter);

		if(result==KErrNone)

			INFO_PRINTF2(_L("Set single Primary filter has been set with single filter, %d, check log"), setfilter);

		else

			INFO_PRINTF2(_L("Set single Primary filter was not set, error returned, %d"), result);

		//logger.EnableClassificationFiltering();//C.A.: already enabled by default in old ulogger

		/**************Now get the GroupId filter set above************/

		logger.GetPrimaryFiltersEnabled(*getfilter);//C.A.: previously:logger.GetEnabledClassifications(*getfilter);

		INFO_PRINTF1(_L("Get Primary filter returns the following filters"));

		for(TInt i=0;i!=getfilter->Count();i++)

		{

			INFO_PRINTF2(_L("get filter returns %d "),getfilter->At(i));

		}

		if(getfilter->At(0)==setfilter)

		{

            result=0;

			INFO_PRINTF1(_L("Get primary filter successful"));

		}

		else

		{

			INFO_PRINTF2(_L("Get primary filter failed.\n NB: getfilter->Count is %d"), getfilter->Count());

			result=1;

		}

		getfilter->Reset();

		/*****************Now remove the above set filter***************/

		if(result==0)

		{

			INFO_PRINTF1(_L("Test disabling a single primary filter with the filter, rather than an array"));

			result=logger.SetPrimaryFiltersEnabled(*removefilterarray,EFalse);//C.A previously:Result=logger.DisableClassification(removefilter);

			INFO_PRINTF2(_L("Remove GroupId filters single filter with single filter not array, 0 if succesful: %d"), result);

			logger.GetPrimaryFiltersEnabled(*getfilter);//CA previously:logger.GetEnabledClassifications(*getfilter);

			if(getfilter->Count()==0&&result==KErrNone)

			{

				INFO_PRINTF1(_L("Remove primary filter successful"));

				result=0;

			}

			else

			{

				if(result!=0)

					INFO_PRINTF1(_L("Remove primary filter failed, as filter has not been set in the config file"));

				else

					INFO_PRINTF1(_L("Remove primary filter failed, as able to pass same filter option to RemovePrimaryFilter"));

				result=1;

			}

		}

		getfilter->Reset();

		/****Now if the above steps have passed proceed to testing enable/disable primary filtering***/

		if(result==1)

			SetBlockResult(EFail);

		else

		{

			INFO_PRINTF1(_L(" Testing GroupId filtering enabled/ disabled "));

			//reset config file

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

			/***enable GroupId, enable GroupId filtering*/

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

			INFO_PRINTF1(_L("\n\n Enable test GroupId, enable GroupId filtering.\n Testing error returns and ensuring a trace statement IS carried out "));

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

			/***enable GroupId, disable GroupId filtering*/

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

			if(BlockResult()==EPass)

				{

				INFO_PRINTF1(_L("\n\n Enable test GroupId, disable GroupId filtering.\n Testing error returns and ensuring a trace statement IS carried out + lots of kernel traces "));

				}

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

			/***disable GroupId, disable GroupId filtering*/

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

			if(BlockResult()==EPass)

				{

				INFO_PRINTF1(_L("\n\n Disable test GroupId, disable GroupId filtering.\n Testing error returns and ensuring a trace statement IS carried out + lots of kernel traces"));

				}

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

			/***disable GroupId, enable GroupId filtering*/

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

			if(BlockResult()==EPass)

				{

				INFO_PRINTF1(_L("\n\n Disable test GroupId, enable GroupId filtering.\n Testing error returns and ensuring a trace statement IS NOT carried out "));

				}

		}

		if (BlockResult()==EPass&&OstStatus)

			{

#ifdef TE_UPT_TRACE_ENABLED

			if(!ReadFromLogFile(KTextvalue))

				{

				TInt err=CompareTraces();

				if(err)

					{

					INFO_PRINTF2(_L("ERROR: Error when comparing traces, error %i"), err);

					SetBlockResult(EFail);

					}

				else

					SetBlockResult(EPass);

				}

#endif

			}

		//  **************   Block end ****************

		logger.Close();

		CleanupStack::Pop(3);

		if(getfilter)

			delete getfilter;

		if(setfilterarray)

			delete setfilterarray;

		if(removefilterarray)

			delete removefilterarray;

		}

	  return ETrue;

	}

/**

 * @return - TVerdict code

 * standard function to test error returns and GroupId filtering

 */

	{

 	TInt Result = 0;

	CArrayFixFlat<TUint8> *setfilterarray = new (ELeave)CArrayFixFlat<TUint8>(256); //CA:added so can use old ulogger api

	CleanupStack::PushL(setfilterarray); //CA:added

	setfilterarray->AppendL(KGroupId); //CA:added so can use old ulogger api

	//enable/disable filter

	aLogger.SetPrimaryFiltersEnabled(*setfilterarray,aFilter);

	//C.A. previously this but only need line above:

/*	if(aFilter)

		aLogger.EnableClassification(KGroupId);

	else

		aLogger.DisableClassification(KGroupId);*/

	//enable/disabled filtering

	if(aFiltering){}

		//Result = aLogger.EnableClassificationFiltering();//CA:enabled by default

	else //enable all GroupIds between 0 and 255

		//C.A. previously just :Result = aLogger.DisableClassificationFiltering();

		{

		TInt i;

		setfilterarray->Delete(0,setfilterarray->Count());

		for (i=0;i<=255;i++)

			{

			setfilterarray->AppendL((TUint8)i);

			}

		Result = aLogger.SetPrimaryFiltersEnabled(*setfilterarray,ETrue);

		}

	if(Result==KErrNone)

		SetBlockResult(EPass);

	else

		{

		INFO_PRINTF2(_L("Enable/disable GroupId filtering test FAILED, returning error %d"), Result);

		SetBlockResult(EFail);

		}

	if(BlockResult()==EPass)

		{

		INFO_PRINTF1(_L("Enable/disable GroupId filtering a second time to ensure correct error return"));

		//enable/disable filtering again

		if(aFiltering){}

			//Result = aLogger.EnableClassificationFiltering();//CA:enabled by default

		else //enable all GroupIds between 0 and 255

			//C.A. previously just :Result = aLogger.DisableClassificationFiltering();

			{

			//setfilterarray should not have changed i.e still contains all filters between 0 and 255

			Result = aLogger.SetPrimaryFiltersEnabled(*setfilterarray,ETrue);

			}

		if(Result==KErrNone)

			SetBlockResult(EPass);

		else

			{

			INFO_PRINTF2(_L("Duplicate enable/disable GroupId filtering test FAILED, returning error %d"), Result);

			SetBlockResult(EFail);

			}

		}

	if(BlockResult()==EPass)

		{

		//initialise filtering enabled boolean

//		TBool enabled = EFalse;

		INFO_PRINTF1(_L("Check IsClassificationFilteringEnabled() returns correct boolean accordingly"));

//		CA: filtering is always enabled and besides, can't check with this api

//		aLogger.IsClassificationFilteringEnabled(enabled);

//		if(enabled==aFiltering)

//			SetBlockResult(EPass);

//		else

//			{

//			INFO_PRINTF2(_L("IsClassificationFilteringEnabled test FAILED, returning bool %d"), enabled);

//			SetBlockResult(EFail);

//			}

		}

	if(BlockResult()==EPass)

		{

		INFO_PRINTF1(_L("Now call a trace statement to confirm correct full implementation"));

		CUptULogger loggerCommand;

		Result=loggerCommand.StartFileL(aLogger, aFiltering, ETrue, aFilter, ETrue);

		if(Result==KErrNone)

			SetBlockResult(EPass);

		else

			{

			INFO_PRINTF2(_L("Ulogger didnt start-> FAILED, returning error %d"), Result);

			SetBlockResult(EFail);

			}

		if(BlockResult()==EPass)

			{

			//initialise boolean return from trace call

			TBool ret = EFalse;

			//create a trace

			//need to change KPcNotIncluded to KPc so program counter can be included in tests

			TTraceContext testtrace(KComponentId, KGroupId, KContextId, KPcNotIncluded);

			ret = OstTrace(testtrace, KTraceId);

			OstTrace0(TEST_GROUP, OstTesting, "EOstTraceDef0" ) ;

			loggerCommand.Stop(aLogger);

			TBool OstStatus=0;

#ifdef TE_UPT_TRACE_ENABLED

			OstStatus = 1;

			INFO_PRINTF1(_L("TRACING HAS BEEN ENABLED!"));

#else

			OstStatus = 0;

			INFO_PRINTF1(_L("TRACING HAS BEEN DISABLED! All Log files should be empty/not exist"));

#endif // trace enabled

			if(ret&&OstStatus)

				{

				if((aFilter&&aFiltering)||(aFilter&&!aFiltering)||(!aFilter&&!aFiltering))

					{

					//create trace information object

					SetBlockResult(EPass);

					//need to change KPcNotIncluded to KPc so program counter can be included in tests

					StoreTraceInfo(EFalse,(TUPTApiUsed)0,KComponentId, KGroupId,KContextId, KPcNotIncluded);

					}

				else

					{

					INFO_PRINTF2(_L("trace call test FAILED, returning bool %d"), ret);

					SetBlockResult(EFail);

					}

				}

			else if(!ret)

				{

				if(!OstStatus||(!aFilter&&aFiltering))

					SetBlockResult(EPass);

				else

					{

					INFO_PRINTF2(_L("trace call test FAILED, returning bool %d"), ret);

					SetBlockResult(EFail);

					}

				}

			else

				{

				INFO_PRINTF2(_L("trace call test FAILED, returning bool %d"), ret);

				SetBlockResult(EFail);

				}

			}

		}

	CleanupStack::Pop(); //setfilterarray

	if(setfilterarray)

		delete setfilterarray;

		return BlockResult();

	}

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

/*********************************Secondary Filter Test***************************/

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

CTCMAdvancedComponentIDFilteringWrapper::~CTCMAdvancedComponentIDFilteringWrapper()

/**

 * Destructor

 */

	{

	}

CTCMAdvancedComponentIDFilteringWrapper::CTCMAdvancedComponentIDFilteringWrapper()

/**

 * Constructor

 */

	{

	}

CTCMAdvancedComponentIDFilteringWrapper* CTCMAdvancedComponentIDFilteringWrapper::NewLC()

	{

	CTCMAdvancedComponentIDFilteringWrapper* self = new (ELeave)CTCMAdvancedComponentIDFilteringWrapper();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTCMAdvancedComponentIDFilteringWrapper* CTCMAdvancedComponentIDFilteringWrapper::NewL()

	{

	CTCMAdvancedComponentIDFilteringWrapper* self=CTCMAdvancedComponentIDFilteringWrapper::NewLC();

	CleanupStack::Pop(); // self;

	return self;

	}

void CTCMAdvancedComponentIDFilteringWrapper::ConstructL()

	{

	}

TAny* CTCMAdvancedComponentIDFilteringWrapper::GetObject()

	{

	return NULL;

	}

TBool CTCMAdvancedComponentIDFilteringWrapper::DoCommandL(	const TTEFFunction& /*aCommand*/,

					const TTEFSectionName& /*aSection*/,

					const TInt /*aAsyncErrorIndex*/)

	{

	  if (BlockResult()==EPass)

		{

		//  ************** Delete the Block, the block start ****************

		TBool OstStatus=EFalse;

#ifdef TE_UPT_TRACE_ENABLED

		EmptyFile(KTextvalue);

		OstStatus=ETrue;

#endif

		TInt result=0;

		RULogger logger;

		TComponentId setfilter = KComponentId;

		RArray<TUint32> dupfilter;

		RArray<TUint32> getfilter;

		RArray<TUint32> setfilterarray,removefilterarray; //CA added for old ulogger api

		setfilterarray.Append(setfilter); //CA added for old ulogger api

		TComponentId removefilter=setfilter;

		removefilterarray.Append(removefilter);

	//	removefilter=32; //uncomment to negative test the remove filter option

		/**************First set Secondary filter*************/

		result=logger.Connect();

        INFO_PRINTF2(_L("Connection to Ulogger: %d, attempt: 1"), result);

            if (result!=KErrNone)

            {

            INFO_PRINTF1(_L("Connection to Ulogger failed. Will try to connect max. 10 times"));

            for (TInt i=2; i<12;i++)

               {

               User::After(1000);

               result = logger.Connect();

               INFO_PRINTF3(_L("Connection to Ulogger: %d, attempt: %d"), result, i);

               if (result==KErrNone)

                    {

                    break;

                    }

               }

            }

		CClearConfig configIni;

		result = logger.SetSecondaryFiltersEnabled(setfilterarray,ETrue);//CA previously:Result = logger.EnableModuleUid(setfilter);

		INFO_PRINTF2(_L("Setting single Secondary filter with filter rather than array has been set with single filter, %d, check log"), setfilter);

		INFO_PRINTF2(_L("code: %d"), result);

		/**************Now get the Secondary filter set above************/

		result = logger.GetSecondaryFiltersEnabled(getfilter);//CA previously:Result = logger.GetEnabledModuleUids(getfilter);

		INFO_PRINTF1(_L("Get Secondary filter returns the following filters"));

		INFO_PRINTF2(_L("code: %d"), result);

		for(TInt i=0;i!=getfilter.Count();i++)

		{

			INFO_PRINTF2(_L("%d "),getfilter[i]);

		}

		if(getfilter[0]==setfilter)

		{

			result=0;

			INFO_PRINTF1(_L("Get single Secondary filter successful"));

		}

		else

		{

			INFO_PRINTF2(_L("Get Secondary filter failed. \n NB: getfilter.Count = %d"), getfilter.Count());

			result=1;

		}

		for(TInt i=0;i!=getfilter.Count();)//i++)

		{