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

// Example CTestStep derived implementation

// 

//

/**

 @file te_uloggerapiteststep.cpp

 @internalTechnology

*/

#include "te_uloggerapiteststep.h"

#include "te_uloggermclsuitedefs.h"

using namespace Ulogger;

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

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

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

CULoggerAPIPrimTestStep::~CULoggerAPIPrimTestStep()

/**

 * Destructor

 */

	{

	}

CULoggerAPIPrimTestStep::CULoggerAPIPrimTestStep()

/**

 * Constructor

 */

	{

	SetTestStepName(KULoggerAPIPrimTestStep);

	}

TVerdict CULoggerAPIPrimTestStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("Testing ULogger API/uloggerclient.h setting Primary filter functionality, for negative testing edit source"));

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CULoggerAPIPrimTestStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only logger.GetS called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test Result value will be EPass.

 */

	{

	  if (TestStepResult()==EPass)

		{

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

		TInt Result=0;

		RULogger logger;

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

		setfilter->AppendL(UTracePrimary);

		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("connect err %d"), Result);

		CClearConfig configIni;

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

		Result=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);

		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 primary filter set above************/

		logger.GetPrimaryFiltersEnabled(*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);

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

			logger.GetPrimaryFiltersEnabled(*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 multiple filters***/

		if(Result==1)

			SetTestStepResult(EFail);

		else

		{

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

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

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

			{

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

			}

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

			Result=logger.SetPrimaryFiltersEnabled(*setfilters,ETrue);

			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 primary filter set above************/

			logger.Connect();

			logger.GetPrimaryFiltersEnabled(*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!=MaxNumberOfPrimaryFilters;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);

			//	getfilter.Append(removefilter);

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

				logger.GetPrimaryFiltersEnabled(*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);

			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)=((TPrimaryFilter)(MaxNumberOfPrimaryFilters));

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

				TInt r=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);

				if((r==KErrNone)&&(setfilter->At(0)==MaxNumberOfPrimaryFilters-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),MaxNumberOfPrimaryFilters );

					Result=0;

				}

				else if((r==KErrNone)&&(setfilter->At(0)!=MaxNumberOfPrimaryFilters-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),MaxNumberOfPrimaryFilters );

					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), MaxNumberOfPrimaryFilters);

					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)=((TPrimaryFilter)(MaxNumberOfPrimaryFilters-1));

						Result=logger.SetPrimaryFiltersEnabled(*setfilter,ETrue);

						if((Result==KErrNone)&&(setfilter->At(0)!=MaxNumberOfPrimaryFilters-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)

				SetTestStepResult(EFail);

			else

				SetTestStepResult(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 TestStepResult();

	}

TVerdict CULoggerAPIPrimTestStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("Completed Primary Filter test"));

	return TestStepResult();

	}

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

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

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

CULoggerAPISecondTestStep::~CULoggerAPISecondTestStep()

/**

 * Destructor

 */

	{

	}

CULoggerAPISecondTestStep::CULoggerAPISecondTestStep()

/**

 * Constructor

 */

	{

	SetTestStepName(KULoggerAPISecondTestStep);

	}

TVerdict CULoggerAPISecondTestStep::doTestStepPreambleL()

/** * @return - TVerdict code

 * Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("Testing ULogger API/uloggerclient.h setting Secondary filter functionality, for negative testing edit source"));

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CULoggerAPISecondTestStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only logger.GetS called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test Result value will be EPass.

 */

	{

	  if (TestStepResult()==EPass)

		{

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

			TInt Result=0;

			RULogger logger;

			RArray<TUint32> setfilter;

			setfilter.Append((TUint32) UTraceSecondary);

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

			logger.Connect();

			CClearConfig configIni;

			Result = logger.SetSecondaryFiltersEnabled(setfilter,ETrue);

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

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

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

				logger.GetSecondaryFiltersEnabled(getfilter);

				if(getfilter.Count()==0)

				{

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

					Result=0;

				}

				else

				{

					if(Result!=0)

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

					else

						INFO_PRINTF1(_L("Remove Secondary 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)

				SetTestStepResult(EFail);

			else

			{

				RArray<TUint32> setfilters;

				RArray<TUint32> getfilters;

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

				for(TInt i=0;i<MaxNumberOfSecondaryFilters;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);

				if(Result==KErrNone)

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

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

				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++)//MaxNumberOfSecondaryFilters;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);

				}

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

				if(Result==0)

				{

					logger.SetSecondaryFiltersEnabled(removefilter, EFalse);

				//	getfilter.Append(removefilter);

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

					logger.GetSecondaryFiltersEnabled(getfilters);

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

					{

						if(getfilters[i]==removefilter[0])

						{

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

							Result=1;

						}

						else

							Result=0;

					}

					if(Result==0)

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

					else

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

				}

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

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

				setfilter[0]=removefilter[0];

				logger.SetSecondaryFiltersEnabled(setfilter,ETrue);

				if(Result==0)

				{

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

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

					setfilter[0]=((TSecondaryFilter)(MaxNumberOfSecondaryFilters-1));

					INFO_PRINTF2(_L("setfilter is %d"), setfilter[0]);

					TInt r= logger.SetSecondaryFiltersEnabled(setfilter,ETrue);

					if((r==KErrNone)&&(setfilter[0]==MaxNumberOfSecondaryFilters-1))

					{

						INFO_PRINTF3(_L("Secondary filter has been set with filter %d,corresponding to the passed value %d, this is allowed as is duplicate. Passed"), setfilter[0],MaxNumberOfSecondaryFilters-1 );

						Result=0;

					}

					if((r==KErrNone)&&(setfilter[0]!=MaxNumberOfSecondaryFilters-1))

					{

						INFO_PRINTF3(_L("Secondary filter has been set with filter %d,corresponding to the passed value %d, this is not allowed. Failed"), setfilter[0],MaxNumberOfSecondaryFilters-1 );

						Result=1;

					}

					else

					{

						INFO_PRINTF3(_L("Secondary filter has not been set with filter %d, corresponding to the passed value %d , this is as expected as otherwise duplicate. Passed"), setfilter[0], MaxNumberOfSecondaryFilters-1);

						Result=0;