/**

 @file

 @publishedAll

 @released

*/

_LIT(KRun1,"Update");

_LIT(KRun2,"Commit");

_LIT(KRun3,"Add");

_LIT(KRun4,"Delete");

_LIT(KRun5,"CloseOpenTables");

_LIT(KRun7,"OwncardAddDelete");

_LIT(KRun9,"Speeddial");

_LIT(KRun10,"TransactionCommit");

_LIT(KRun11,"TransactionRevert");

_LIT(KRun12,"CUDTransactionCommit");

_LIT(KRun13,"CUDTransactionRevert");

_LIT(KRun14,"EmptyTransactionCommit");

_LIT(KRun15,"EmptyTransactionRevert");

_LIT(KRun16,"UnknownChange");

_LIT(KTest1, "Update notification test");

_LIT(KTest2, "Commit notification test");

_LIT(KTest3, "Add notification test");

_LIT(KTest4, "Delete notification test");

_LIT(KTest5, "Open tables notification test");

_LIT(KTest6, "Close tables notification test");

_LIT(KTest7, "Own Card notification test");

_LIT(KTest14, "Change Own Card notification test");

_LIT(KTest9, "Own Card Deletion notification test");

_LIT(KTest8, "Speed dial notification test");

_LIT(KTest15, "Delete Speed dial Card notification test");

_LIT(KTest16, "Remove Speed dial Card notification test");

_LIT(KTest10, "Single commit transaction notification test");

_LIT(KTest102, "Single commit revert transaction notification test");

_LIT(KTest11, "Multiple Cud transaction notification test");

_LIT(KTest112, "Multiple Cud revert transaction notification test");

_LIT(KTest12, "Empty transaction notification test");

_LIT(KTest122, "Empty revert transaction notification test");

_LIT(KTest13, "unknown changes notification test");

_LIT(KClients,"Clients");

_LIT(KNotifier,"Notifier");

_LIT(KSperator," ");

_LIT(KSingleCharacter,"A");

const TInt KTimeout = 5000000;//5 seconds timeout

//start initlizer step

CConcurrentInitializerStep::CConcurrentInitializerStep() : CPerformanceFunctionalityBase(KConcurrentContacts)

	{

	iUnclean = ETrue;

	SetTestStepName(KConcurrentInitilizerStep);

	}

TVerdict CConcurrentInitializerStep::doTestStepL()

	{

	__UHEAP_MARK;

	_LIT(KStartTest,"CConcurrentInitializerStep::doTestStepL()");

	INFO_PRINTF1(KStartTest);  //Block start

	InitializeL();

	iIterate->Reset();

	TInt j = 0;

	for(; j < iContacts; ++j)

		{

		OpenL(iIterate->NextL());

		TInt fieldId=iFields->Find(KUidContactFieldPhoneNumber);

		SetFieldL(fieldId,GetFieldL(KStringFields, KField, 1));// if this is not set, speeddial cant be set

		CommitL(EFalse);

		}

	iIterate->Reset();

	Cleanup();

	__UHEAP_MARKEND;

	return TestStepResult();

	}

//end initlizer step

CConcurrentNotifierStep::CConcurrentNotifierStep() :

					CPerformanceFunctionalityBase(KConcurrentContacts)

	{

	iConcurrent = ETrue;

	SetTestStepName(KConcurrentNotifierStep);

	}

void CConcurrentNotifierStep::CConcurrentNotifierActive::RunL()

	{

	const TInt many = iStep->iTests->Count();

	if( iStep->iNextTest >= many )

		{

		if( many > 1 )

			{

			iStep->SetSharedTextL(KSharedContact,KNullDesC, EFalse);

			iStep->SetSharedTextL(KSharedEvents,KNullDesC, EFalse);

			iStep->SetSharedTextL(KSharedNextTest, KNullDesC, EFalse);

			}

		CActiveScheduler::Stop();

		iStep->iNextTest = 0;

		}

	else

		{

		if( iStep->iWaiting )

			{

			iStep->ProcessWaitL();

			}

		else

			{

			RArray< void (CConcurrentNotifierStep::*)() > &Tests = *( iStep->iTests );

			//select test to run

			void (CConcurrentNotifierStep::*TestFunction)() = Tests[ iStep->iNextTest ];

			//execute test

			( iStep->*TestFunction )();

			}

		Activate();

		}

	}

CConcurrentNotifierStep::CConcurrentNotifierActive::CConcurrentNotifierActive(CConcurrentNotifierStep *aStep)

								:	CActive( EPriorityStandard ),

									iStep ( aStep )

	{

	}

void CConcurrentNotifierStep::CConcurrentNotifierActive::DoCancel()

	{

	//nothing to cleanup

	}

TInt CConcurrentNotifierStep::CConcurrentNotifierActive::RunError(TInt aError)

	{

	_LIT(KActiveError,"CConcurrentNotifierStep:: Error in doTest runL: %d");

	iStep->ERR_PRINTF2( KActiveError , aError );

	return aError;

	}

void CConcurrentNotifierStep::CConcurrentNotifierActive::Activate()

	{

	if(!IsActive())

		{

		TRequestStatus *pS=&iStatus;

		User::RequestComplete(pS,KErrNone);

		SetActive();

		}

	}

CConcurrentNotifierStep::~CConcurrentNotifierStep()

	{

	if( iTests )

		{

		iTests->Close();

		CLEAR(iTests);

		}

	CLEAR(iMyActive);

	}

void CConcurrentNotifierStep::PreTestL()

	{

	_LIT(KPretestPrint,"I am in CConcurrentNotifierStep PreTestL()");

	INFO_PRINTF1(KPretestPrint);

	GetIntFromConfig( KNotifier, KClients, iManyListeners );

	iMyActive = new (ELeave) CConcurrentNotifierStep::CConcurrentNotifierActive( this );

	iTests = new(ELeave) RArray< void (CConcurrentNotifierStep::*)() >();

	ClearSharedL();

	SetSharedTextL(KSharedNextTest, KNullDesC, EFalse);

	const TDesC &run = ConfigSection();

	if( run == KRun1 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::UpdateTestL );

		}

	else if( run == KRun2 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::CommitTestL );

		}

	else if( run == KRun3 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::AddTestL );

		}

	else if( run == KRun4 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::DeleteTestL );

		}

	else if( run == KRun5 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::CloseTablesTestL );

		iTests->AppendL( &CConcurrentNotifierStep::OpenTablesTestL );

		}

	else if( run == KRun7 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::OwnCardTestL );

		iTests->AppendL( &CConcurrentNotifierStep::ChangeOwnCardTestL );

		iTests->AppendL( &CConcurrentNotifierStep::OwnCardDeleteTestL );

		}

	else if( run == KRun9 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::SpeedDialTestL );

		iTests->AppendL( &CConcurrentNotifierStep::RemoveSpeedDialTestL );

		iTests->AppendL( &CConcurrentNotifierStep::DeleteSpeedDialTestL );

		}

	else if( run == KRun10 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::SingleCommitTransactionTestL );

		}

	else if( run == KRun11 )

		{

		iRevert = ETrue;

		iTests->AppendL( &CConcurrentNotifierStep::SingleCommitTransactionTestL );

		}

	else if( run == KRun12 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::MultipleChangeTransactionTestL );

		}

	else if( run == KRun13 )

		{

		RProcess().SetPriority(EPriorityBackground);

		iRevert = ETrue;

		iTests->AppendL( &CConcurrentNotifierStep::MultipleChangeTransactionTestL );

		RProcess().SetPriority(EPriorityForeground);

		}

	else if( run == KRun14 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::EmptyTransactionTestL );

		}

	else if( run == KRun15 )

		{

		RProcess().SetPriority(EPriorityBackground);

		iRevert = ETrue;

		iTests->AppendL( &CConcurrentNotifierStep::EmptyTransactionTestL );

		RProcess().SetPriority(EPriorityForeground);

		}

	else if( run == KRun16 )

		{

		iTests->AppendL( &CConcurrentNotifierStep::UnkownChangeTestL );

		}

	else

		{

		MissingTestPanic();

		}

	}

TVerdict CConcurrentNotifierStep::doTestStepL()

	{

	__UHEAP_MARK;

	InitializeL();

	_LIT(KDoStepPrint,"CTransactionsStep::doTestStepL()");

	INFO_PRINTF1(KDoStepPrint);  //Block start

	iIterate->Reset();

	SetSharedTextL(KSharedEvents,KNullDesC, EFalse);

	CActiveScheduler::Add(iMyActive);

	iMyActive->Activate();

	CActiveScheduler::Start();

	Cleanup();

	__UHEAP_MARKEND;

	return TestStepResult();

	}

TVerdict CConcurrentNotifierStep::doTestStepPostambleL()

	{

	_LIT(KPostamblePrint,"I am in CConcurrentNotifierStep doTestStepPostambleL()");

	INFO_PRINTF1(KPostamblePrint);

	ClearSharedL();

	SetSharedTextL(KSharedNextTest, KNullDesC, EFalse);

	return CPerformanceFunctionalityBase::doTestStepPostambleL();

	}

/**

tell listener to expect aEvent type notification

increase message count

*/

void CConcurrentNotifierStep::AddEventL(const TInt aEvent)

	{

	if( !iRevert )

		{

		ShareIntL(KSharedEvents, aEvent, ETrue, KSperator);

		++iMessageCount;//either here or in addcontact

		}

	}

/**

tell listener to expect notification for aCid contact

don't

*/

void CConcurrentNotifierStep::AddContactL(const TInt aCid)

	{

	if( !iRevert )

		{

		ShareIntL(KSharedContact, aCid, ETrue, KSperator);

		}

	}

/**

tell listener to expect iMessageCount many messages / notifications

sets the shared string to contain the value iMessageCount

*/

void CConcurrentNotifierStep::SetMessageCountL()

	{

	ShareIntL(KSharedMessageCount, iMessageCount);

	iMessageCount = 0;

	}

/**

each listener appends a charcter to shared memory KSharedClients

once it has received all notifications from this thread,

this returns length of string

*/

TInt CConcurrentNotifierStep::ReceivedCountL()

	{

	return SharedCountL(KSharedClients);

	}

/**

Sets the value of all shared memmories to Null

used at beginning/end of test case

*/

void CConcurrentNotifierStep::ClearSharedL()

	{

	SetSharedTextL(KSharedEvents, KNullDesC, EFalse);

	SetSharedTextL(KSharedContact, KNullDesC, EFalse);

	SetSharedTextL(KSharedClients, KNullDesC, EFalse);

	SetSharedTextL(KSharedMessageCount, KNullDesC, EFalse);

	}

/**

if in revert mode rollback transaction, otherwise commit,

tell listner to expect an notifications that may be generated

*/

void CConcurrentNotifierStep::EndTransactionL( )

	{

	if(iRevert)

		{

		iRevert = EFalse;

		iContactsDatabase->DatabaseRollback();

		AddEventL( EContactDbObserverEventRollback );

		AddContactL( KNullContactId );

		CleanupStack::Pop();

		TBool damaged = iContactsDatabase->IsDamaged();

		#ifdef _DEBUG

			#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__

		//It maybe necessary to explicitly damage the database more than once

		//for it to be registered as damaged

		while( !iContactsDatabase->IsDamaged() )

			{

			//will give consistent behaviour on debug builds

			iContactsDatabase->DamageDatabaseL(0x666);

			}

		if( !damaged )

			{

			AddEventL( EContactDbObserverEventRollback );

			AddContactL( KNullContactId );

			}

			#endif

		#endif

		if( iContactsDatabase->IsDamaged() )

			{

			iContactsDatabase->RecoverL();

			AddEventL( EContactDbObserverEventRecover );

			AddContactL( 0 );

			if( !damaged )

				{

				AddEventL( EContactDbObserverEventTablesClosed );

				AddContactL( 0 );

				}

			AddEventL( EContactDbObserverEventTablesOpened );

			AddContactL( 0 );

			}

		iRevert = ETrue;

		}

	else

		{

		iContactsDatabase->DatabaseCommitLP(EFalse);

		}

	iRevert = !iRevert;

	}

/**

Used by all tests to wait for listener to recive notification and send confirmation back.

timesout if no confirmation received

*/

void CConcurrentNotifierStep::ProcessWaitL()

	{

	iEnd.UniversalTime();

	if(ReceivedCountL() == iManyListeners)

		{

		if( iTests->Count() > 1 )

			{

			ClearSharedL();

			}

		iWaiting = EFalse;

		++iNextTest;

		}

	else if( iEnd.MicroSecondsFrom( iStart ).Int64() > KTimeout ) //test has timed out

		{

		_LIT(KTimedOut,"Notifier test %d has timed out");

		ERR_PRINTF2(KTimedOut, ++iNextTest);

		if( iTests->Count() > 1 )

			{

			ClearSharedL();

			}

		iWaiting = EFalse;

		TESTPRINT( EFalse );

		iNextTest = iTests->Count();

		}

	//else test is not complete and has not timed out... continue waiting

	}

void CConcurrentNotifierStep::UpdateTestL()

	{

	INFO_PRINTF1(KTest1);

	SetSharedTextL(KSharedNextTest,KSingleCharacter , ETrue);

	iWaiting = ETrue;

	TContactItemId cid = iIterate->NextL();

	ReadL( cid );

	iContactsDatabase->UpdateContactLC( cid, iContactItem);

	CleanupStack::PopAndDestroy();

	CloseL( ETrue );

	AddEventL(EContactDbObserverEventContactChanged);

	AddContactL( cid );

	SetMessageCountL();

	iStart.UniversalTime();

	}

void CConcurrentNotifierStep::CommitTestL()

	{

	INFO_PRINTF1(KTest2);

	SetSharedTextL(KSharedNextTest, KSingleCharacter, ETrue);

	iWaiting = ETrue;

	TContactItemId cid = iIterate->NextL();

	OpenL( cid );

	CommitL( EFalse );

	AddEventL(EContactDbObserverEventContactChanged);

	AddContactL( cid );

	SetMessageCountL();

	iStart.UniversalTime();

	}

void CConcurrentNotifierStep::AddTestL()

	{

	INFO_PRINTF1(KTest3);

	SetSharedTextL(KSharedNextTest, KSingleCharacter, ETrue);

	iWaiting = ETrue;

	CContactCard* contact = CContactCard::NewLC(iTemplate);

	TContactItemId cid = iContactsDatabase->AddNewContactL(*contact);

	iIterate->AddL( cid );

	CleanupStack::PopAndDestroy(contact);

	AddEventL(EContactDbObserverEventContactAdded);

	AddContactL( cid );

	SetMessageCountL();

	iStart.UniversalTime();

	}

void CConcurrentNotifierStep::DeleteTestL()

	{

	INFO_PRINTF1(KTest4);

	SetSharedTextL(KSharedNextTest, KSingleCharacter, ETrue);

	iWaiting = ETrue;

	TContactItemId cid = iIterate->NextL();

	DeleteContactL( cid, EFalse );

	AddEventL(EContactDbObserverEventContactDeleted);

	AddContactL( cid );

	SetMessageCountL();

	iStart.UniversalTime();

	}

void CConcurrentNotifierStep::OpenTablesTestL()

	{

	INFO_PRINTF1(KTest5);

	SetSharedTextL(KSharedNextTest, KSingleCharacter, ETrue);

	iWaiting = ETrue;

	iMyActive->Activate();

	iContactsDatabase->OpenTablesL();

	AddEventL( EContactDbObserverEventTablesOpened );

	AddContactL( 0 );

	SetMessageCountL();

	iStart.UniversalTime();