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

// These are all out of memory tests.

// Call api first in order that all lazy initializations take place

// check heap balance is maintained for client side tests

// make sure all failures result only in KErrNoMemory only.

// 

//

/**

 @file 

 @publishedAll

 @released

*/

#include "CRUDOOMStep.h"

#include "PerformanceFunctionalityDefs.h"

_LIT(KRun1,"Read");

_LIT(KRun2,"Open");

_LIT(KRun3,"Delete");

_LIT(KRun4,"Add");

_LIT(KRun5,"Close");

_LIT(KRun6,"Commit");

_LIT(KRun7,"Update");

_LIT(KRun8,"ViewsRemote");

_LIT(KRun9,"ViewsLocal");

_LIT(KRun10,"ViewsLocalFS");

_LIT(KTest1, "Read test");

_LIT(KTest2, "Open test");

_LIT(KTest3, "Delete test");

_LIT(KTest4, "Add contact test");

_LIT(KTest5, "Close contact test");

_LIT(KTest6, "Commit contact test");

_LIT(KTest7, "Update contact test");

_LIT(KTest8, "Remote View test");

_LIT(KTest9, "Local View test");

_LIT(KView, "Views");

_LIT(KStars,"***************************");

const static TInt KNumberOfContacts = 10;

const static TInt32 KExistingUidsArray[] = 

	{

	KUidContactFieldAddressValue,

	KUidContactFieldPostOfficeValue,

	KUidContactFieldExtendedAddressValue,

	KUidContactFieldLocalityValue,

	KUidContactFieldRegionValue,

	KUidContactFieldPostCodeValue,

	KUidContactFieldCountryValue,

	KUidContactFieldCompanyNameValue,

	KUidContactFieldCompanyNamePronunciationValue,

	KUidContactFieldPhoneNumberValue,

	KUidContactFieldGivenNameValue,

	KUidContactFieldFamilyNameValue,

	KUidContactFieldGivenNamePronunciationValue,

	KUidContactFieldFamilyNamePronunciationValue,

	KUidContactFieldAdditionalNameValue,

	KUidContactFieldSuffixNameValue,

	KUidContactFieldPrefixNameValue,

	KUidContactFieldHiddenValue,

	KUidContactFieldEMailValue,

	KUidContactFieldMsgValue,

	KUidContactFieldSmsValue,

	KUidContactFieldFaxValue,

	KUidContactFieldDefinedTextValue,

	KUidContactFieldNoteValue,

	KUidContactFieldBirthdayValue,

	KUidContactFieldUrlValue,

	KUidContactFieldStorageInlineValue,

	KUidContactFieldTemplateLabelValue,

	KUidContactFieldPictureValue,

	KUidContactFieldRingToneValue,

	KUidContactFieldDTMFValue,

	KUidContactsVoiceDialFieldValue,

	KUidContactFieldNoneValue,

	KUidContactFieldJobTitleValue,

	KUidContactFieldICCSlotValue,

	KUidContactFieldICCPhonebookValue,

	KUidContactFieldICCGroupValue,

	KUidContactFieldIMAddressValue,

	KUidContactFieldSecondNameValue,

	KUidContactFieldSIPIDValue,

	KIntContactFieldVCardMapWORK,

	KIntContactFieldVCardMapHOME,

	KIntContactFieldVCardMapMSG,

	KIntContactFieldVCardMapVOICE,

	KIntContactFieldVCardMapFAX,

	KIntContactFieldVCardMapPREF,

	KIntContactFieldVCardMapCELL,

	KIntContactFieldVCardMapPAGER,

	KIntContactFieldVCardMapBBS,

	KIntContactFieldVCardMapMODEM,

	KIntContactFieldVCardMapCAR,

	KIntContactFieldVCardMapISDN,

	KIntContactFieldVCardMapVIDEO,

	KIntContactFieldVCardMapDOM,

	KIntContactFieldVCardMapADR,

	KIntContactFieldVCardMapPOSTOFFICE,

	KIntContactFieldVCardMapEXTENDEDADR,

	KIntContactFieldVCardMapLOCALITY,

	KIntContactFieldVCardMapREGION,

	KIntContactFieldVCardMapPOSTCODE,

	KIntContactFieldVCardMapCOUNTRY,

	KIntContactFieldVCardMapAGENT,

	KIntContactFieldVCardMapBDAY,

	KIntContactFieldVCardMapEMAILINTERNET,

	KIntContactFieldVCardMapGEO,

	KIntContactFieldVCardMapLABEL,

	KIntContactFieldVCardMapLOGO,

	KIntContactFieldVCardMapMAILER,

	KIntContactFieldVCardMapNOTE,

	KIntContactFieldVCardMapORG,

	KIntContactFieldVCardMapORGPronunciation,

	KIntContactFieldVCardMapPHOTO,

	KIntContactFieldVCardMapROLE,

	KIntContactFieldVCardMapSOUND,

	KIntContactFieldVCardMapTEL,

	KIntContactFieldVCardMapTELFAX,

	KIntContactFieldVCardMapTITLE,

	KIntContactFieldVCardMapURL,

	KIntContactFieldVCardMapUnusedN,

	KIntContactFieldVCardMapUnusedFN,

	KIntContactFieldVCardMapNotRequired,

	KIntContactFieldVCardMapUnknownXDash,

	KIntContactFieldVCardMapUnknown,

	KIntContactFieldVCardMapUID,

	KIntContactFieldVCardMapINTL,

	KIntContactFieldVCardMapPOSTAL,

	KIntContactFieldVCardMapPARCEL,

	KIntContactFieldVCardMapGIF,

	KIntContactFieldVCardMapCGM,

	KIntContactFieldVCardMapWMF,

	KIntContactFieldVCardMapBMP,

	KIntContactFieldVCardMapMET,

	KIntContactFieldVCardMapPMB,

	KIntContactFieldVCardMapDIB,

	KIntContactFieldVCardMapPICT,

	KIntContactFieldVCardMapTIFF,

	KIntContactFieldVCardMapPDF,

	KIntContactFieldVCardMapPS,

	KIntContactFieldVCardMapJPEG,

	KIntContactFieldVCardMapMPEG,

	KIntContactFieldVCardMapMPEG2,

	KIntContactFieldVCardMapAVI,

	KIntContactFieldVCardMapQTIME,

	KIntContactFieldVCardMapTZ,

	KIntContactFieldVCardMapKEY,

	KIntContactFieldVCardMapX509,

	KIntContactFieldVCardMapPGP,

	KIntContactFieldVCardMapSMIME,

	KIntContactFieldVCardMapWV,

	KIntContactFieldVCardMapSECONDNAME,

	KIntContactFieldVCardMapSIPID,

	KIntContactFieldVCardMapPOC,

	KIntContactFieldVCardMapSWIS,

	KIntContactFieldVCardMapVOIP

	};

CCRUDOOMStep::CCRUDOOMStep() 

		: CPerformanceFunctionalityBase(KNumberOfContacts)

	{

	SetTestStepName(KCRUDOOMStep);

	}

void CCRUDOOMStep::PreTestL()

	{

	const TDesC &run = ConfigSection();//for views tests only use one contact, otherwise tests too slow

	if( run.Find(KView) == 0 )

		{

		iContacts = 1;

		}

	}

void CCRUDOOMStep::InitializeL()

	{

	CPerformanceFunctionalityBase::InitializeL();

	iDestroyView = new (ELeave) CDestroyView( this );

	CActiveScheduler::Add(iDestroyView);

	}

void CCRUDOOMStep::Cleanup()

	{

	CLEAR( iDestroyView );

	CPerformanceFunctionalityBase::Cleanup();

	}

TVerdict CCRUDOOMStep::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.

 */

	{

	__UHEAP_MARK;

	InitializeL();

	_LIT(KDostepPrint,"CCRUDOOMStep::doTestStepL()");

	INFO_PRINTF1(KDostepPrint);

	iIterate->Reset();

	const TDesC &run = ConfigSection();

	_LIT(KFullContactOOMTest,"Full contacts OOM testing");

	_LIT(KEmptyOOMTest,"Empty contacts OOM testing");

	//perform clientside and serverside testing when contacts are empty

	if( run != KRun10 )

		{

		INFO_PRINTF1(KNullDesC);

		INFO_PRINTF1(KStars);

		INFO_PRINTF1(KEmptyOOMTest);

		INFO_PRINTF1(KStars);

		INFO_PRINTF1(KNullDesC);

		RunAllTestsL(ETrue);

		RunAllTestsL(EFalse);

		}

	//perform clientside and serverside testing when contacts are full

	INFO_PRINTF1(KNullDesC);

	INFO_PRINTF1(KStars);

	INFO_PRINTF1(KFullContactOOMTest);

	INFO_PRINTF1(KStars);

	INFO_PRINTF1(KNullDesC);

	iIterate->Reset();

	TInt j = 0;

	for(; j < iContacts; ++j)

		{

		OpenL(iIterate->NextL());

		SetAllFieldsL( GetFieldL(KStringFields, KField, 2) );

		CommitL(EFalse);

		}

	iIterate->Reset();	

	if( run != KRun10 )

		{

		RunAllTestsL(ETrue);

		}

	if( run != KRun9 ) //with full contacts, localview serverside oom test is too slow, run as sperate step

		{

		RunAllTestsL(EFalse);

		}

	Cleanup();

	__UHEAP_MARKEND;

	return TestStepResult();

	}

/**

If aClient is true perform client side OOM testing 

Otherwise perform Serverside Heap testing

*/

void CCRUDOOMStep::RunAllTestsL(const TBool aClient)

	{

	if(aClient)

		{

		_LIT(KClientOOM,"Clientside OOM testing");

		INFO_PRINTF1(KClientOOM);

		INFO_PRINTF1(KNullDesC);

		}

	else

		{

		INFO_PRINTF1(KNullDesC);

		_LIT(KServerOOM,"Serverside OOM testing");

		INFO_PRINTF1(KServerOOM);

		INFO_PRINTF1(KNullDesC);

		}

	const TDesC &run = ConfigSection();

	if( run == KRun1 )

		{

		ReadOOML(aClient);

		}

	else if( run == KRun2 )

		{

		OpenOOML(aClient);

		}

	else if( run == KRun3 )

		{

		DeleteOOML(aClient);

		}

	else if( run == KRun4 )

		{

		AddContactOOML(aClient);

		}

	else if( run == KRun5 )

		{	

		CloseContactOOML(aClient);

		}

	else if( run == KRun6 )

		{

		CommitContactOOML(aClient);

		}

	else if( run == KRun7 )

		{

		UpdateContactOOML(aClient);

		}

	else if( run == KRun8 )

		{

		INFO_PRINTF1(KTest8);

		ViewOOMTestL(ETrue, aClient);

		}

	else if( run == KRun9 || run == KRun10 )

		{

		INFO_PRINTF1(KTest9);

		ViewOOMTestL(EFalse, aClient);

		}

	else

		{

		MissingTestPanic();

		}

	}

/**

set heapmark and set heap failure to aFailAt

performs testing on client or serverside

*/

void CCRUDOOMStep::StartHeapCheck(const TInt aFailAt, const TBool aClient)

	{

	if( aClient)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic, aFailAt); // leavescan thinks this macro is a leaver but it isn't

		__UHEAP_MARK;

		}

	else

		{

		iContactsDatabase->SetCntServerHeapFailure(RHeap::EDeterministic, aFailAt); //__UHEAP_SETFAIL

		}

	}

/**

reset heapmark and reset heap failure

check that error receved from api failiure equals KErrNoMemory or there was no failiure

performs checking on client or serverside

*/

TBool CCRUDOOMStep::EndHeapCheckL(const TInt aErr, const TBool aClient)

	{	

	TBool ret = EFalse;

	if( aClient)

		{

		__UHEAP_RESET;

		RecoverL(aErr);

		__UHEAP_MARKEND;

		}

	else

		{

		iContactsDatabase->SetCntServerHeapFailure(RHeap::ENone, 1);//__UHEAP_RESET

		RecoverL(aErr);

		}

	TESTPRINT( ret = ( (KErrNoMemory == aErr) || (KErrNone == aErr) ) );

	return ret;

	}

/**

check value of received error and print relevant error message as necessary

*/

void CCRUDOOMStep::ErrorProcess(const TInt aFailAt, const TInt aErr, 

								const TBool aClient, const TBool aCleanup)

	{

	_LIT(KNonMemoryError,"iteration %d failed - non-memory error in OOM test: %d");

	_LIT(KCleanupError,"iteration %d failed - cleanup error in OOM test");

	if( aClient )

		{

		if( (KErrNoMemory != aErr) && (KErrNone != aErr)  )

			{

			ERR_PRINTF3(KNonMemoryError, aFailAt, aErr);

			}

		else

			{

			ERR_PRINTF2(KCleanupError, aFailAt);

			}

		}

	else

		{

		if( (KErrNoMemory == aErr) || (KErrNone == aErr) )

			{

			if( aCleanup )

				{

				ERR_PRINTF2(KCleanupError, aFailAt);

				}

			else

				{

				_LIT(KHeapError,"iteration %d failed - server-heap imbalance error in OOM test");

				ERR_PRINTF2(KHeapError, aFailAt);

				}

			}

		else

			{

			ERR_PRINTF3(KNonMemoryError, aFailAt, aErr);

			}

		}

	}

/**

recover database if it is damaged

*/

void CCRUDOOMStep::RecoverL(const TInt aErr)

	{

	if( aErr != KErrNone )

		{

		if( iContactsDatabase->IsDamaged() )

			{

			iContactsDatabase->RecoverL();

			}

		}

	}

/**

perform oom testing for read contact

*/

void CCRUDOOMStep::ReadOOML(const TBool aClient)

	{

	INFO_PRINTF1(KTest1);

	TBool ErrorCheckTest = EFalse;

	TContactItemId cid = iIterate->NextL();

	CContactItem *contactItem = NULL;

	//any lazy initialization should be performed here, so that it doesnt interfere with oom testing

	ReadL( cid );

	CloseL( EFalse );

	iContactsDatabase->CompactL();

	TInt err = KErrNone;

	TInt failAt = 0;

	do

		{

		++failAt;

		//set heap failure on client/server

		StartHeapCheck(failAt, aClient);

		//perform read	

		TRAP(err, contactItem = iContactsDatabase->ReadContactL( cid, *iViewAll ); );

		if (err == KErrNone)

			{

			CLEAR(contactItem);	

			}

		//reset heap failure on client/server, check that there is no memory leak on client

		TESTPRINTI( ErrorCheckTest = EndHeapCheckL(err, aClient), failAt);

		if(!ErrorCheckTest)

			{

			//if test failed print appropriate message

			ErrorProcess(failAt, err, aClient, EFalse);

			break;

			}

		}

	while(err != KErrNone);

	}

/**

perform oom testing for open contact

*/	

void CCRUDOOMStep::OpenOOML(const TBool aClient)

	{

	INFO_PRINTF1(KTest2);

	TBool ErrorCheckTest = EFalse;

	TContactItemId cid = iIterate->NextL();

	CContactItem *contactItem = NULL;

	//any lazy initialization should be performed here, so that it doesnt interfere with oom testing

	OpenL( cid );

	CloseL( ETrue );

	iContactsDatabase->CompactL();

	TInt err = KErrNone;

	TInt failAt = 0;

	do

		{

		++failAt;

		//set heap failure on client/server

		StartHeapCheck(failAt, aClient);

		//perform open contact				

		TRAP(err, contactItem = iContactsDatabase->OpenContactL( cid, *iViewAll ); );

		if (err == KErrNone)

			{

			CLEAR(contactItem);	

			}

		//reset heap failure on client/server, check that there is no memory leak on client	

		TESTPRINTI( ErrorCheckTest = EndHeapCheckL(err, aClient), failAt );

		if(!ErrorCheckTest)

			{

			//if test failed print appropriate message

			ErrorProcess(failAt, err, aClient, EFalse);

			iIterate->RemoveL(cid);	

			break;

			}

		}

	while(err != KErrNone);

	iContactsDatabase->CloseContactL( cid );

	}

/**

perform oom testing for delete contact

*/	

void CCRUDOOMStep::DeleteOOML(const TBool aClient)

	{

	INFO_PRINTF1(KTest3);

	TBool ErrorCheckAllTests 	= EFalse;

	TBool ErrorCheckSingleTest 	= EFalse;

	TBool cleanupError = EFalse;

	TContactItemId cid = iIterate->NextL();

	//any lazy initialization should be performed here, so that it doesnt interfere with oom testing