// 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_tracecollectorclient.h"

#include "te_ostv2integsuite_defs.h"

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

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

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

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

_LIT(KTextsetting, "output_path");

CTCMGroupIDFilteringWrapper::~CTCMGroupIDFilteringWrapper()

/**

 * Destructor

 */

	{

	}

CTCMGroupIDFilteringWrapper::CTCMGroupIDFilteringWrapper()

/**

 * Constructor

 */

	{

	}

CTCMGroupIDFilteringWrapper* CTCMGroupIDFilteringWrapper::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTCMGroupIDFilteringWrapper* CTCMGroupIDFilteringWrapper::NewL()

	{

	CTCMGroupIDFilteringWrapper* self=CTCMGroupIDFilteringWrapper::NewLC();

	CleanupStack::Pop(); // self;

	return self;

	}

void CTCMGroupIDFilteringWrapper::ConstructL()

	{

	}

TAny* CTCMGroupIDFilteringWrapper::GetObject()

	{

	return NULL;

	}

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

					const TTEFSectionName& /*aSection*/, 

					const TInt /*aAsyncErrorIndex*/)

	{

	  if (BlockResult()==EPass)

		{

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

		TInt result=0;

		RULogger logger;

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

		setfilter->AppendL(KGroupId);

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

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

		removefilter->AppendL(setfilter->At(0));

		/**************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);

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

		if(result==KErrNone)

			INFO_PRINTF2(_L("Primary filter has been set with single filter, %d, check log"), setfilter->At(0));

		else

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

		/**************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->At(0))

		{

			result=0;

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

		}

		else

		{

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

			result=1;

		}

		getfilter->Reset();

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

		if(result==0)

		{

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

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

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

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

			{

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

				result=0;

			}

			else

			{

				if(result!=KErrNone)

					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 multiple filters***/

		if(result==1)

			SetBlockResult(EFail);

		else

		{

			CArrayFixFlat<TUint8> *setfilters = new (ELeave)CArrayFixFlat<TUint8>(10);

			CArrayFixFlat<TUint8> *getfilters = new (ELeave)CArrayFixFlat<TUint8>(10);

			for(TInt i=0;i!=KMaxNumberOfGroupIds;i++)

			{

				setfilters->AppendL((TUint8)(i));

			}

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

			result=logger.SetPrimaryFiltersEnabled(*setfilters,ETrue);//C.A. previously:result=logger.EnableClassifications(*setfilters);

			if(result==KErrNone)

				INFO_PRINTF1(_L("Primary filter has been set with multiple filters,from 0 to 255"));

			else

				INFO_PRINTF2(_L("Multiple primary filters have not been set succesfully, error code %d"), result);

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

			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;

						}

                   }

		 	    }

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

			if(getfilters->Count()==setfilters->Count())

				INFO_PRINTF1(_L("setfilter and getfilter have the same count"));

			else

			{

				INFO_PRINTF1(_L("setfilter and getfilter have different counts"));

				INFO_PRINTF2(_L("setfilter has %d"), setfilters->Count());

				INFO_PRINTF2(_L("getfilter has %d"), getfilters->Count());

				result=1;

			}

			if(result==0)

			{

				for(TInt i=0;i!=getfilters->Count() && result==0;i++)

				{

					for(TInt j=0;j!=setfilters->Count() && result!=0;j++)

					{

						if(getfilters->At(i)==setfilters->At(j))

							result=0;

						else

							result=1;

					}

				}

			}

			if(result==0)

				INFO_PRINTF1(_L("Get multiple primary filters successful"));

			else

				INFO_PRINTF1(_L("Get multiple primary filters failed"));

			INFO_PRINTF1(_L("Get Primary filters returns multiple filters"));

		//	for(int i=0;i!=KMaxNumberOfGroupIds;i++)

		//		INFO_PRINTF2(_L(" %d"), getfilters->operator[](i));	//uncomment to verify get filters test correct

			getfilters->Reset();

			/*****************Given this is successful, now remove the above set filter***************/

			if(result==0)

			{

				logger.Connect();

				logger.SetPrimaryFiltersEnabled(*removefilter,EFalse);//C.A. previously:logger.DisableClassifications(*removefilter);

			//	getfilter.Append(removefilter);

			//	logger.EnableClassifications(getfilter);//uncomment these to negative test the test suite

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

				for(TInt i=0; i!=getfilters->Count() && result==0;i++)

				{

					if(getfilters->At(i)==removefilter->At(0))

					{

						INFO_PRINTF1(_L("Remove primary filter in multiple test failed"));

						result=1;

					}

					else

						result=0;

				}

				if(result==0)

					INFO_PRINTF1(_L("Remove primary filter in multiple test successful"));

				else

					INFO_PRINTF1(_L("Remove primary filter in multiple test failed"));

			}

			INFO_PRINTF1(_L("Now, given that the above tests have passed, negative test the primary filter options"));

			INFO_PRINTF1(_L("First reset the removed filter, then proceed"));

			setfilter->At(0)=removefilter->At(0);

			logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);//C.A. previously:logger.EnableClassifications(*setfilter);

			if(result==0)

			{

				INFO_PRINTF1(_L("Removed filter has been reset"));

				/************Now try to set a primary filter value greater than that allowed***/

				setfilter->At(0)=((TGroupId)(KMaxNumberOfGroupIds));

				INFO_PRINTF2(_L("setfilter is %d"), setfilter->At(0));

				TInt r=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);//C.A. previously:TInt r=logger.EnableClassifications(*setfilter);

				if((r==KErrNone)&&(setfilter->At(0)==KMaxNumberOfGroupIds-256))

				{

					INFO_PRINTF3(_L("Primary filter has been set with filter %d,corresponding to the passed value %d, this is allowed as duplicate! Passed"), setfilter->At(0),KMaxNumberOfGroupIds );

					result=0;

				}

				else if((r==KErrNone)&&(setfilter->At(0)!=KMaxNumberOfGroupIds-256))

				{

					INFO_PRINTF3(_L("Primary filter has been set with filter %d,corresponding to the passed value %d, this is not allowed as not duplicate! Failed"), setfilter->At(0),KMaxNumberOfGroupIds );

					result=1;

				}

				else

				{

					INFO_PRINTF3(_L("Primary filter has not been set with filter %d, corresponding to the passed value %d. Passed"), setfilter->At(0), KMaxNumberOfGroupIds);

					result=0;

				}

				/************Now try to set more primary filter values greater than available***/

				{

					INFO_PRINTF1(_L("Now try to set more filter than available using a duplicate"));

					if(result==0)

					{

						setfilter->At(0)=((TGroupId)(KMaxNumberOfGroupIds-1));

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

						if((result==KErrNone)&&(setfilter->At(0)!=KMaxNumberOfGroupIds-1))

						{

							INFO_PRINTF1(_L("More primary filters than available can be set. Failed"));

							result=1;

						}

						else

						{

							INFO_PRINTF1(_L("More primary filters than available cannot be set OR the filter being set is a duplicate. Passed"));

							result=0;

						}

					}

				}

			}

			if(result==1)

				SetBlockResult(EFail);

			else

				SetBlockResult(EPass);

			if(setfilters)

			{

				delete setfilters;

				setfilters=NULL;

			}

			setfilter->Reset();

			if(getfilters)

			{

				delete getfilters;

				getfilters=NULL;

			}

		}

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

		logger.Close();

		if(setfilter)

			delete setfilter;

		if(getfilter)

			delete getfilter;

		}

	  return ETrue;

	}

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

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

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

CTCMComponentIDFilteringWrapper::~CTCMComponentIDFilteringWrapper()

/**

 * Destructor

 */

	{

	}

CTCMComponentIDFilteringWrapper::CTCMComponentIDFilteringWrapper()

/**

 * Constructor

 */

	{

	}

CTCMComponentIDFilteringWrapper* CTCMComponentIDFilteringWrapper::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTCMComponentIDFilteringWrapper* CTCMComponentIDFilteringWrapper::NewL()

	{

	CTCMComponentIDFilteringWrapper* self=CTCMComponentIDFilteringWrapper::NewLC();

	CleanupStack::Pop(); // self;

	return self;

	}

void CTCMComponentIDFilteringWrapper::ConstructL()

	{

	}

TAny* CTCMComponentIDFilteringWrapper::GetObject()

	{

	return NULL;

	}

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

					const TTEFSectionName& /*aSection*/, 

					const TInt /*aAsyncErrorIndex*/)

	{

	  if (BlockResult()==EPass)

		{

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

            INFO_PRINTF1(_L("do stepL"));

			TInt result=0;

			RULogger logger;

			RArray<TUint32> setfilter;

			setfilter.Append((TUint32) KComponentId);

			RArray<TUint32> dupfilter;

			RArray<TUint32> getfilter;

			RArray<TUint32> removefilter;

			removefilter.Append(setfilter[0]);

		//	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(setfilter,ETrue);//C.A. previously:result = logger.EnableModuleUids(setfilter);

			INFO_PRINTF2(_L("Secondary filter has been set with single filter, %d, check log"), setfilter[0]);

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

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

			result = logger.GetSecondaryFiltersEnabled(getfilter);//C.A. 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[0])

			{

				result=0;

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

			}

			else

			{

				INFO_PRINTF1(_L("Get Secondary filter failed"));

				result=1;

			}

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

			{

				getfilter.Remove(0);

			}

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

			if(result==0)

			{

				result=logger.SetSecondaryFiltersEnabled(removefilter,EFalse);//C.A. previously:result=logger.DisableModuleUids(removefilter);

				INFO_PRINTF2(_L("Remove Module Uid filters single filter, 0 if succesful, -1 if failed: %d"), result);//logger.RemoveSingleSecondary);

				logger.GetSecondaryFiltersEnabled(getfilter);//C.A. previously:logger.GetEnabledModuleUids(getfilter);

				if(getfilter.Count()==0)

				{

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

					result=0;

				}

				else

				{

					if(result!=0)

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

					else

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

					result=1;

				}

			}

			/****Now if the above steps have passed proceed to testing multiple filters***/

			if(result==1)

				SetBlockResult(EFail);

			else

			{

				RArray<TUint32> setfilters;

				RArray<TUint32> getfilters;

				INFO_PRINTF2(_L("maxsecondary %d"),KMaxNumberOfComponentIds);

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

				{

					setfilters.Append((TUint32)(i));

				}

				INFO_PRINTF1(_L("initialising values for multiple secondary filters ok, now set the filters etc"));

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

				result=logger.SetSecondaryFiltersEnabled(setfilters,ETrue);//C.A. previously:result=logger.EnableModuleUids(setfilters);

				if(result==KErrNone)

				INFO_PRINTF2(_L("Secondary filter has been set with multiple filters,from 0 to %d"), KMaxNumberOfComponentIds);

				else

					INFO_PRINTF2(_L("Multiple secondary filters have not been set succesfully, error code %d"), result);

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

				INFO_PRINTF2(_L("before get, getfilter has %d"), getfilters.Count());

				logger.GetSecondaryFiltersEnabled(getfilters);//C.A. previously:logger.GetEnabledModuleUids(getfilters);

				if(getfilters.Count()==setfilters.Count())

				{

					INFO_PRINTF1(_L("setfilter and getfilter have the same count"));

					INFO_PRINTF2(_L("setfilter has %d"), setfilters.Count());

					INFO_PRINTF2(_L("getfilter has %d"), getfilters.Count());

				}

				else

				{

					INFO_PRINTF1(_L("setfilter and getfilter have different counts"));

					result=1;

						INFO_PRINTF2(_L("setfilter has %d"), setfilters.Count());

						INFO_PRINTF2(_L("getfilter has %d"), getfilters.Count());

				}

				for(TInt i=0;i!=getfilters.Count() && result==0;i++)

				{

					for(TInt j=0;j!=getfilters.Count() && result!=0;j++)

					{

						if(getfilters[i]==setfilters[j])

							result=0;

						else

							result=1;

					}

				}

				if(result==0)

					INFO_PRINTF1(_L("Get multiple Secondary filters successful"));

				else

					INFO_PRINTF1(_L("Get multiple Secondary filters failed"));

				INFO_PRINTF1(_L("Get Secondary filters returns multiple filters"));

			//	for(int i=0;i!=getfilters.Count();i++)//KMaxNumberOfComponentIds;i++)

			//		INFO_PRINTF2(_L(" %d"), getfilters[i]);	//uncomment to verify get filters test correct - WARNING-loadsa data if use true maximum for secondary filters-will break TEF!!

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

				{

					getfilters.Remove(0);