// 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 testruloggerapi_ext.cpp

 @internalTechnology

*/

#include "testruloggerapi_ext.h"

#include "te_uloggerclientsuitedefs.h"

#include <uloggerdatatypes.h>

CTestRULoggerAPIStep::~CTestRULoggerAPIStep()

/**

 * Destructor

 */

	{

	}

CTestRULoggerAPIStep::CTestRULoggerAPIStep()

/**

 * Constructor

 */

	{

	// **MUST** call SetTestStepName in the constructor as the controlling

	// framework uses the test step name immediately following construction to set

	// up the step's unique logging ID.

	SetTestStepName(KTestRULoggerAPIStep);

	}

TVerdict CTestRULoggerAPIStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("CTestRULoggerAPIStep -Extended API tests- started"));

	TInt errCode = iUlogger.Connect();

	if(errCode != KErrNone)

		{

		TBuf<64> b;

		b.AppendFormat(_L("connect error: %d"), errCode);

		SetTestStepResult(EFail);

		}

	else

		SetTestStepResult(EPass);

	CTestUloggerClientApiStepBase::doTestStepPreambleL();

	return TestStepResult();

	}

TVerdict CTestRULoggerAPIStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only 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)

		{

		TInt errors = 0;

		errors += SetGetPrimaryFiletr_TestL();

		errors += SetGetSecondaryFiletr_TestL();

		errors += SetGetSecondaryFiltering_TestL();

		errors += SetGetOutputPlugin_TestL();

		errors += GetInstalledOutputPlugins_TestL();

		errors += SetGetInputPlugin_TestL();

		errors += GetInstalledInputPlugins_TestL();

		errors += SetGetRemovePluginConf_TestL();

		errors += SetGetTraceBuffer_TestL();

		//check errors

		if(errors)

			{

			SetTestStepResult(EFail);

			TBuf<64> b;

			b.AppendFormat(_L("%d errors were found !!!!"), errors);

			INFO_PRINTF1(b);

			}

		else

			{

			SetTestStepResult(EPass);

			INFO_PRINTF1(_L("CTestRULoggerAPIStep completed without problems."));

			}

		}

	return TestStepResult();	

}

TVerdict CTestRULoggerAPIStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

		INFO_PRINTF1(_L("CTestRULoggerAPIStep completed"));

		CTestUloggerClientApiStepBase::doTestStepPostambleL();	

		iUlogger.Close();

		return TestStepResult();

	}

TInt CTestRULoggerAPIStep::SetGetPrimaryFiletr_TestL()

{

	TInt err = 0;

	TInt i;

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

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

	TInt test;

	//set 256 filters

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

		filters->AppendL((TUint8)i);	

	test = iUlogger.SetPrimaryFiltersEnabled(*filters, ETrue);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set 256 filters - failed"));

		err++;

		}

	//get 256 filetrs

	test = iUlogger.GetPrimaryFiltersEnabled(*gFilters);

	if(test!=KErrNone && gFilters->Count()!=256)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get 256 filters - failed!"));

		err++;

		}

	//set 257 filetrs

	filters->AppendL((TUint8)257); //value doesn't matter

	test = iUlogger.SetPrimaryFiltersEnabled(*filters, ETrue);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set 257 filters - failed!"));

		err++;

		}

	//get 257 filetrs (should be 256 vin array)

	gFilters->Reset();

	test = iUlogger.GetPrimaryFiltersEnabled(*gFilters);

	if(test!=KErrNone && gFilters->Count()!=256)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get 257 filters - failed!"));

		err++;

		}

	//remove 256 filetrs

	test = iUlogger.SetPrimaryFiltersEnabled(*gFilters, EFalse);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("remove 256 filetrs - failed!"));

		err++;

		}

	//remove 257 filetrs

	test = iUlogger.SetPrimaryFiltersEnabled(*filters, EFalse);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("remove 257 filetrs - failed!"));

		err++;

		}

	filters->Reset();

	gFilters->Reset();

	//set empty array ETrue test

	test = iUlogger.SetPrimaryFiltersEnabled(*filters, ETrue);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set empty array ETrue test - failed!"));

		err++;

		}

	//set empty array EFalse test

	test = iUlogger.SetPrimaryFiltersEnabled(*filters, EFalse);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set empty array EFalse test - failed!"));

		err++;

		}

	//getting empty array

	gFilters->Reset();

	test = iUlogger.GetPrimaryFiltersEnabled(*gFilters);

	if(test!=KErrNone && gFilters->Count()!=0)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("getting empty array - failed!"));

		err++;

		}

	//summary

	TBuf<64> b;

	if(err)

		b.AppendFormat(_L("SetGetPrimaryFiletr_TestL failed with %d errors!!!"), err);

	else

		b.Append(_L("SetGetPrimaryFiletr_TestL passed"));

	delete gFilters;

	gFilters = NULL;

	delete filters;

	filters = NULL;

	return err;

}

TInt CTestRULoggerAPIStep::SetGetSecondaryFiletr_TestL()

{

	TInt err = 0;

	TInt i;

	RArray<TUint32> filters;

	RArray<TUint32> gFilters;

	TInt test;

	//clean

	iUlogger.GetSecondaryFiltersEnabled(gFilters);

	iUlogger.SetSecondaryFiltersEnabled(gFilters, EFalse);

	gFilters.Reset();

	//set 4096 filters

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

		filters.AppendL((TUint32)i);	

	test = iUlogger.SetSecondaryFiltersEnabled(filters, ETrue);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set 4096 filters - failed"));

		err++;

		}

	//get 4096 filetrs

	test = iUlogger.GetSecondaryFiltersEnabled(gFilters);

	if(test!=KErrNone && gFilters.Count()!=4096)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get 4096 filters - failed!"));

		err++;

		}

	//set 4096+1 filetrs

	filters.AppendL(4097); //value doesn't matter

	test = iUlogger.SetSecondaryFiltersEnabled(filters, ETrue);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set 4096+1 filters - failed!"));

		err++;

		}

	//get 4096+1 filetrs (should be 4096 in array)

	gFilters.Reset();

	test = iUlogger.GetSecondaryFiltersEnabled(gFilters);

	if(test!=KErrNone && gFilters.Count()!=4096)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get 4096+1 filters - failed!"));

		err++;

		}

	//remove 4096 filetrs

	test = iUlogger.SetSecondaryFiltersEnabled(gFilters, EFalse);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("remove 4096 filetrs - failed!"));

		err++;

		}

	//remove 4096+1 filetrs

	test = iUlogger.SetSecondaryFiltersEnabled(filters, EFalse);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("remove 4096+1 filetrs - failed!"));

		err++;

		}

	filters.Reset();

	gFilters.Reset();

	//set empty array ETrue test

	test = iUlogger.SetSecondaryFiltersEnabled(filters, ETrue);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set empty array ETrue test - failed!"));

		err++;

		}

	//set empty array EFalse test

	test = iUlogger.SetSecondaryFiltersEnabled(filters, EFalse);

	if(test != KErrArgument)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set empty array EFalse test - failed!"));

		err++;

		}

	//getting empty array

	gFilters.Reset();

	test = iUlogger.GetSecondaryFiltersEnabled(gFilters);

	if(test!=KErrNone && gFilters.Count()!=0)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("getting empty array - failed!"));

		err++;

		}

	//summary

	TBuf<64> b;

	if(err)

		b.AppendFormat(_L("SetGetSecondaryFiletr_TestL failed with %d errors!!!"), err);

	else

		b.Append(_L("SetGetSecondaryFiletr_TestL passed"));

	INFO_PRINTF1(b);

	gFilters.Close();

	filters.Close();

	return err;

}

TInt CTestRULoggerAPIStep::SetGetSecondaryFiltering_TestL()

{

	TInt err = 0;

	TInt test = 0;

	TBool val = ETrue;

	//set secondary filtering as ETrue

	iUlogger.SetSecondaryFilteringEnabled(EFalse);

	test = iUlogger.SetSecondaryFilteringEnabled(ETrue);

	if(test!=KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set secondary filtering as ETrue - failed!"));

		err++;

		}

	//set secondary filtering as ETrue again

	test = iUlogger.SetSecondaryFilteringEnabled(ETrue);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set secondary filtering as ETrue again - failed!"));

		err++;

		}

	//get secondary filtering ETrue

	test = iUlogger.GetSecondaryFilteringEnabled(val);

	if(test != KErrNone || !val)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get secondary filtering ETrue - failed!"));

		err++;

		}

	//set secondary filtering as EFalse

	test = iUlogger.SetSecondaryFilteringEnabled(EFalse);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set secondary filtering as EFalse - failed!"));

		err++;

		}

	//set secondary filtering as EFalse again

	test = iUlogger.SetSecondaryFilteringEnabled(EFalse);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set secondary filtering as EFalse again - failed!"));

		err++;

		}

	//get secondary filtering EFalse

	test = iUlogger.GetSecondaryFilteringEnabled(val);

	if(test != KErrNone || val)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get secondary filtering EFalse - failed!"));

		err++;

		}

	//summary

	TBuf<64> b;

	if(err)

		b.AppendFormat(_L("SetGetSecondaryFiltering_TestL failed with %d errors!!!"), err);

	else

		b.Append(_L("SetGetSecondaryFiltering_TestL passed"));

	INFO_PRINTF1(b);

	return err;

}

TInt CTestRULoggerAPIStep::SetGetOutputPlugin_TestL()

{

	TInt err = 0;

	TInt test = KErrNone;

	TBuf8<256> plugin;

	_LIT8(KFilePlugin, "uloggerfileplugin");

	_LIT8(KSerialPlugin, "uloggerserialplugin");

	iUlogger.ActivateOutputPlugin(KSerialPlugin); //initial settings

	//set uloggerfileplugin as output

	test = iUlogger.ActivateOutputPlugin(KFilePlugin);

	if(test!=KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set uloggerfileplugin as output - failed!"));

		err++;

		}

	//get uloggerfileplugin

	test = iUlogger.GetActiveOutputPlugin(plugin);

	if(plugin.Compare(KFilePlugin) != 0 || test!=KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get uloggerfileplugin - failed!"));

		err++;

		}

	//set uloggerfileplugin as output again

	test = iUlogger.ActivateOutputPlugin(KFilePlugin);

	if(test != KErrNone) //dont return an error although already exists isnt a "failure"

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set uloggerfileplugin as output again - failed!"));

		err++;

		}

	TBuf8<2> smallBuf;

	//get uloggerfileplugin to small buf

	test = iUlogger.GetActiveOutputPlugin(smallBuf);

	if(test!=KErrOverflow)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("get uloggerfileplugin to small buf - failed!"));

		err++;

		}

	//summary

	TBuf<64> b;

	if(err)

		b.AppendFormat(_L("SetGetOutputPlugin_TestL failed with %d errors!!!"), err);

	else

		b.Append(_L("SetGetOutputPlugin_TestL passed"));

	INFO_PRINTF1(b);

	return err;

}

TInt CTestRULoggerAPIStep::GetInstalledOutputPlugins_TestL()

{

	TInt err = 0;

	TInt test = KErrNone;

	CArrayPtrFlat<HBufC8>* plugins = new (ELeave) CArrayPtrFlat<HBufC8>(1);

	test = iUlogger.GetInstalledOutputPlugins(*plugins);

	if(test != KErrNone)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("GetInstalledOutputPlugins_TestL - failed!"));

		err++;

		}

	plugins->ResetAndDestroy();

	delete plugins;

	plugins = NULL;

	//summary

	TBuf<64> b;

	if(err)

		b.AppendFormat(_L("GetInstalledOutputPlugins_TestL failed with %d errors!!!"), err);

	else

		b.Append(_L("GetInstalledOutputPlugins_TestL passed"));

	INFO_PRINTF1(b);

	return err;

}

TInt CTestRULoggerAPIStep::SetGetInputPlugin_TestL()

	{

	TInt err = 0;

	TInt test = KErrNone;

	TBuf8<256> plugin;

	_LIT8(KFilePlugin, "uloggerfileplugin");

	_LIT8(KUsbPlugin, "uloggerusbplugin");

	iUlogger.DeActivateInputPlugin(); //set initial state

	//set uloggerusbplugin as input

	test = iUlogger.ActivateInputPlugin(KUsbPlugin);

	if(test!=KErrNone && test!=KErrNotFound)

		{

		INFO_PRINTF2(_L("err: %d"), test);

		INFO_PRINTF1(_L("set uloggerusbplugin as input - failed!"));

		err++;

		}

	//set uloggerusbplugin as input again

	test = iUlogger.ActivateInputPlugin(KUsbPlugin);

	if(test!=KErrAlreadyExists && test!=KErrNotFound)

		{

		INFO_PRINTF2(_L("err: %d"), test);