diff -r 000000000000 -r e686773b3f54 phonebookengines/contactsmodel/tsrc/Integration/PerfFuncSuite/src/ConcurrentTimeOutNotifierStep.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines/contactsmodel/tsrc/Integration/PerfFuncSuite/src/ConcurrentTimeOutNotifierStep.cpp	Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,278 @@
+// 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:
+// Notifier step / thread, locks a contact / database, sends message to
+// concurrent running listener thread / step informing it what has been locked
+// waits for message from  listner to start countdown to release of lock
+// listener will send message and wait for specified lock to be released
+// or for timeout to be invoked by cntmodel.
+// Sending Messages:
+// Set shared string to contain length of time resource will be locked for in seconds. KSharedEvents. (6)
+// Set shared string to contain  id of contact that is locked. KSharedContact. (1)
+// Set shared string to contain a value, specify that new test case can start. KSharedNextTest. (aa)
+// Receiving messages:
+// Read shared string length signifying that thread should start countdown 
+// until realease of resource. KSharedClients. (AA)
+// 
+//
+
+/**
+ @file 
+ @publishedAll
+ @released
+*/
+ 
+#include "ConcurrentTimeOutNotifierStep.h"
+#include "PerformanceFunctionalityDefs.h"
+
+_LIT(KRun1,"NonTrans");
+_LIT(KRun2,"Transaction");
+
+_LIT(KTest1, "Contacts timeout test");
+_LIT(KTest2, "Transaction timeout test");
+
+const static TInt KTimeout = 50000000;//50 seconds timeout
+const static TInt KOneSecond = 1000000;
+
+_LIT(KDoubleChar,"AA");
+	
+CConcurrentTimeOutNotifierStep::CConcurrentTimeOutNotifierStep() : 	
+									CPerformanceFunctionalityBase(KConcurrentTimeoutContacts),
+									iSeconds( 10 )
+	{
+	iConcurrent = ETrue;
+	SetTestStepName(KConcurrentTimeoutNotifierStep);
+	}
+/**
+runs the next test that will lock a particular resource
+*/
+void CConcurrentTimeOutNotifierStep::CConcurrentTimeOutNotifierMyActive::RunL()
+	{
+	const static TInt KTestCount = iStep->iTests->Count();
+	if( iStep->iNextTest >= KTestCount )
+		{
+		CActiveScheduler::Stop();
+		iStep->iNextTest = 0;
+		}
+	else
+		{
+		RArray< void (CConcurrentTimeOutNotifierStep::*)() > &Tests = *( iStep->iTests );
+		//select test to run
+		void (CConcurrentTimeOutNotifierStep::*TestFunction)() = Tests[ iStep->iNextTest ];
+		//execute test
+		( iStep->*TestFunction )();
+		Activate();
+		}
+	}
+	
+void CConcurrentTimeOutNotifierStep::CConcurrentTimeOutNotifierMyActive::DoCancel()
+	{
+	//nothing to cleanup, does nothing.
+	}
+
+TInt CConcurrentTimeOutNotifierStep::CConcurrentTimeOutNotifierMyActive::RunError(TInt aError)
+	{
+	 _LIT(KActiveError,"CConcurrentTimeOutNotifierStep:: Error in doTest runL: %d");
+	iStep->ERR_PRINTF2(KActiveError, aError );
+	return aError;
+	}
+
+void CConcurrentTimeOutNotifierStep::CConcurrentTimeOutNotifierMyActive::Activate()
+	{
+	if(!IsActive())
+		{	
+		TRequestStatus *pS=&iStatus;
+		User::RequestComplete(pS,KErrNone);
+		SetActive();
+		}
+	}
+
+CConcurrentTimeOutNotifierStep::~CConcurrentTimeOutNotifierStep()
+	{
+	if( iTests )
+		{
+		iTests->Close();
+		CLEAR(iTests);
+		}
+	CLEAR(iMyActive);
+	}
+
+/**
+create active object and test array
+append contact lock or transaction lock test as necessary
+*/	
+void CConcurrentTimeOutNotifierStep::PreTestL()
+	{
+	iMyActive = new (ELeave) CConcurrentTimeOutNotifierStep::CConcurrentTimeOutNotifierMyActive( this );
+	iTests = new(ELeave) RArray< void (CConcurrentTimeOutNotifierStep::*)() >();
+	
+	const TDesC &run = ConfigSection();
+	
+	if( run == KRun1 )
+		{
+		iTests->AppendL( &CConcurrentTimeOutNotifierStep::LockContactTestL );
+		}
+	else if( run == KRun2 )
+		{
+		iTests->AppendL( &CConcurrentTimeOutNotifierStep::LockDatabaseTestL );
+		}
+	else
+		{
+		MissingTestPanic();
+		}
+	}
+
+TVerdict CConcurrentTimeOutNotifierStep::doTestStepL()
+	{
+	__UHEAP_MARK;
+	InitializeL();
+	_LIT(KDoStepPrint,"CConcurrentTimeOutNotifierStep::doTestStepL()");
+	INFO_PRINTF1(KDoStepPrint);  //Block start 
+	iIterate->Reset();
+	SetTimerL(-1);
+	SetContactL( -1 );
+	SetSharedTextL(KSharedNextTest, KDoubleChar, EFalse);
+	CActiveScheduler::Add(iMyActive);
+	iMyActive->Activate();
+	CActiveScheduler::Start();
+	
+	Cleanup();
+	__UHEAP_MARKEND;
+
+	return TestStepResult();
+	}
+
+/**
+sends message to listener specifying the length of time resource will be locked for
+*/
+void CConcurrentTimeOutNotifierStep::SetTimerL(const TInt aTime)
+	{
+	
+	ShareIntL(KSharedEvents, aTime);
+	
+	}
+
+/**
+sends message to listener specifying the contact that will be locked
+*/
+void CConcurrentTimeOutNotifierStep::SetContactL(const TInt aCid)
+	{
+	
+	ShareIntL(KSharedContact, aCid);
+	
+	}
+
+/**
+wait for message from listener specifying that countdown to release of resource should commence
+*/
+void CConcurrentTimeOutNotifierStep::StartCountdownL()
+	{
+	if ( iCountdown )
+		{
+		return;
+		}
+	iCountdown = SharedCountL(KSharedClients) > 0;
+	if (iCountdown)
+		{
+		iStart.UniversalTime();
+		SetSharedTextL(KSharedClients, KNullDesC, EFalse);
+		}
+	}
+	
+/**
+either release resource after countdown has reached the necessary value
+or timeout test if countdown is not started after the timeout period has passed
+*/
+void CConcurrentTimeOutNotifierStep::ProcessWaitL(const TBool aTransaction)
+	{
+	StartCountdownL();
+	iEnd.UniversalTime();
+	const TInt64 KLockTime = iEnd.MicroSecondsFrom( iStart ).Int64();
+	const TInt64 KTestTime = iEnd.MicroSecondsFrom( iTestStart ).Int64();
+	if( iCountdown && ( KLockTime >= ((iSeconds - KTimeDiff) * KOneSecond) ) )
+		{
+		iWaiting = EFalse;
+		iCountdown = EFalse;
+		if(aTransaction)
+			{
+			iContactsDatabase->DatabaseCommitL( EFalse );//unlock database
+			}
+		else
+			{
+			CloseL( ETrue );//unlock contact
+			}
+		++iNextTest;
+		SetSharedTextL(KSharedNextTest, KDoubleChar, EFalse);
+		}
+	else if( KTestTime > KTimeout ) //test has timed out
+		{
+		_LIT(KTimedOut,"Notifier test %d has timed out");
+		ERR_PRINTF2(KTimedOut, ++iNextTest);
+		iWaiting = EFalse;
+		iCountdown = EFalse;
+		TESTPRINT( EFalse );
+		SetSharedTextL(KSharedNextTest, KDoubleChar, EFalse);
+		iNextTest = iTests->Count();
+		}
+	//else test is not complete and has not timed out... continue waiting
+	}
+	
+/*
+open a contact, this causes that contact to be locked
+*/
+void CConcurrentTimeOutNotifierStep::LockContactTestL()
+	{
+	if(iWaiting)
+		{
+		ProcessWaitL( EFalse );
+		}
+	else
+		{
+		INFO_PRINTF1(KTest1);
+		iWaiting = ETrue;
+		TContactItemId cid = iIterate->NextL();
+		OpenL( cid );
+		//notify listener that database will be unlocked after x amount of time
+		SetTimerL( iSeconds - KTimeDiff );
+		SetContactL( cid );
+		iTestStart.UniversalTime();
+		}
+	}
+	
+/*
+starts a transactions
+this causes the database to be locked	
+*/
+void CConcurrentTimeOutNotifierStep::LockDatabaseTestL()
+	{
+	if(iWaiting)
+		{
+		ProcessWaitL( ETrue );
+		}
+	else
+		{
+		INFO_PRINTF1(KTest2);
+		iWaiting = ETrue;
+		TContactItemId cid = iIterate->NextL();
+		iContactsDatabase->DatabaseBeginLC(EFalse);
+		//notify listener that contact will be unlocked after x amount of time
+		SetTimerL( iSeconds - KTimeDiff );
+		SetContactL( cid );
+		CleanupStack::Pop(); // cleanup item from the CContactDatabase::DatabaseBeginLC() 
+		iTestStart.UniversalTime();
+		}
+	}
+		
+
+
+