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

//

// System includes

#include <cntdb.h>

#include <cntdef.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

// System includes

#include <e32std.h>

#include <e32twin.h>

#include <e32test.h>

#include <cntdbobs.h>

// User includes

#include "t_utils2.h"

// Constant

_LIT(KDatabaseFileName, "c:t_owncard.cdb");

_LIT(KSemaphoreNameOne,		"One");

_LIT(KSemaphoreNameTwo,		"Two");

_LIT(KThreadNameOne,		"OneThread");

_LIT(KThreadNameTwo,		"TwoThread");

const TInt KDelay = 1000000;

static RTest					TheTest(_L("t_owncard"));

//

/* CTestActiveScheduler                                                      */

//  This class has been nicked from the t_currentdb.h / .cpp files

class CTestActiveScheduler : public CActiveScheduler

	{

	public:

		void Error (TInt aError) const;

	};

void CTestActiveScheduler::Error(TInt aError) const

	{

	User::Panic(_L("AScheduler"),aError);

	}

//

/* CConcurrentDatabaseAccessBase - Specification                             */

// Forms the base class for both threads.

class CConcurrentDatabaseAccessBase : public CActive

	{

	public: // Data Types

		enum TStage

			{

			EOne_Startup,

			ETwo_FirstCheck,

			EThree_ChangeOwner,

			ENOP_One,

			ENOP_Two,

			EFour_SecondCheck,

			EFive_Cleanup,

			EFinished

			} ;

	public:

		CConcurrentDatabaseAccessBase();

		virtual ~CConcurrentDatabaseAccessBase();

		virtual void ConstructL(const TDesC& aFilename);

		void RunTestL();

	public: // data

		RThread					iThread;

	protected:

		void OpenSemaphore();

		void CloseSemaphore();

		void SyncronizeSignal();

		void SyncronizeWait();

		void OpenDatabaseL();

		void CloseDatabase();

		void CloseTest();

		virtual TBool RunTestImplementationL() = 0;

	protected: // from CActive

		void DoCancel() {};

		void RunL();

		TInt RunError(TInt aError);

		void CallRunLAgain();

		TBool NextStage();

	protected:

		CContactDatabase*		iDb;

		TStage					iStage;

		TInt					iTestError;

	private:

		RSemaphore				iSemaphoreSignal;

		RSemaphore				iSemaphoreWait;

		TBool					iSemaphoreOpen;

		HBufC*					iDatabaseName;

	};

//

/* CConcurrentDatabaseAccessBase - Implementation                            */

CConcurrentDatabaseAccessBase::CConcurrentDatabaseAccessBase()

	: CActive( /*EPriorityStandard*/ EPriorityIdle )

	{

	iStage = EOne_Startup;

	}

CConcurrentDatabaseAccessBase::~CConcurrentDatabaseAccessBase()

	{

	iThread.Close();

	CloseSemaphore();

	delete iDatabaseName;

	}

void CConcurrentDatabaseAccessBase::ConstructL(const TDesC& aFilename)

	{

	iDatabaseName = aFilename.AllocL();

	}

void CConcurrentDatabaseAccessBase::OpenDatabaseL()

	{

	iDb = CContactDatabase::OpenL(*iDatabaseName, CContactDatabase::EMultiThread);

	}

void CConcurrentDatabaseAccessBase::CloseDatabase()

	{

	delete iDb;

	iDb = NULL;

	}

void CConcurrentDatabaseAccessBase::CloseTest()

	{

	}

void CConcurrentDatabaseAccessBase::CallRunLAgain()

	{

	iStatus = KRequestPending;

	TRequestStatus* ptrStatus = &iStatus;

	User::RequestComplete( ptrStatus, KErrNone );

	SetActive();

	}

TBool CConcurrentDatabaseAccessBase::NextStage()

	{

	TInt stage = static_cast<TInt>( iStage );

	stage++;

	iStage = static_cast<TStage>( stage );

	return ( iStage == EFinished );

	}

void CConcurrentDatabaseAccessBase::RunL()

	{

	TBool stopProcessing = EFalse;

	stopProcessing = RunTestImplementationL();

	if (stopProcessing)

		{

		CActiveScheduler::Stop();

		}

	}

TInt CConcurrentDatabaseAccessBase::RunError(TInt aError)

	{

	// propagate the error

	iTestError = aError;

	RDebug::Print(_L("Thread failed at test stage %i, with error %i"), iStage, aError);

	CActiveScheduler::Stop();

	return KErrNone;

	}

void CConcurrentDatabaseAccessBase::RunTestL()

	{

	// set's up an active scheduler for the thread

	// and calls the RunTesImplementation function to actually

	// preform the tests. This function should be implemented in the

	// child class.

	CTestActiveScheduler*  scheduler = NULL;

	scheduler = new (ELeave) CTestActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	CActiveScheduler::Add( this );

	OpenDatabaseL();

	CallRunLAgain();

	CActiveScheduler::Start();

	CloseDatabase();

	CleanupStack::PopAndDestroy( scheduler );

	// propagate error

	User::LeaveIfError(iTestError);

	}

void CConcurrentDatabaseAccessBase::OpenSemaphore()

	{

	TInt success = KErrNone;

	success = iSemaphoreSignal.OpenGlobal( KSemaphoreNameOne );

	if ( success == KErrNotFound )

		{

		iSemaphoreSignal.CreateGlobal( KSemaphoreNameOne, 0 );

		success = KErrNone;

		}

	success = iSemaphoreWait.OpenGlobal( KSemaphoreNameTwo );

	if ( success == KErrNotFound )

		{

		iSemaphoreWait.CreateGlobal( KSemaphoreNameTwo, 0 );

		}

	iSemaphoreOpen = ETrue;

	}

void CConcurrentDatabaseAccessBase::CloseSemaphore()

	{

	if (iSemaphoreOpen)

		{

		iSemaphoreSignal.Close();

		iSemaphoreWait.Close();

		}

	iSemaphoreOpen = EFalse;

	}

void CConcurrentDatabaseAccessBase::SyncronizeSignal()

	{

	CallRunLAgain();

	iSemaphoreSignal.Signal();

	iSemaphoreWait.Wait();

	}

void CConcurrentDatabaseAccessBase::SyncronizeWait()

	{

	CallRunLAgain();

	iSemaphoreSignal.Wait();

	iSemaphoreWait.Signal();

	}

//

/* CConcurrentOwnerCardModifier - Specification                               */

// This class should allow the two threads to compare the owner ID's of there db.

class TOwnerCardCompare

	{

	public:

	enum EThreadName

		{

			EModifier,

			EChecker

		};

	public:

	TOwnerCardCompare();

	~TOwnerCardCompare();

	void			AssignValuesAndCheckL(TContactItemId aValue, EThreadName aThreadName);

	private:

	void			CheckValuesL();

	void			ClearValues();

	private: // data

	TBool			iModifierDataPresent;

	TBool			iCheckerDataPresent;

	TContactItemId	iModifierValue;

	TContactItemId	iCheckerValue;

	};

//

/* CConcurrentOwnerCardModifier - Implementatio                              */

// This class should allow the two threads to compare the owner ID's of there db.

TOwnerCardCompare::TOwnerCardCompare()

	{

	ClearValues();

	}

TOwnerCardCompare::~TOwnerCardCompare()

	{

	ClearValues();

	}

void TOwnerCardCompare::AssignValuesAndCheckL(TContactItemId aValue, EThreadName aThreadName)

	{

	switch ( aThreadName )

		{

		case EModifier:

			iModifierDataPresent = ETrue;

			iModifierValue = aValue;

		break;

		case EChecker:

			iCheckerDataPresent = ETrue;

			iCheckerValue = aValue;

		break;

		}

	CheckValuesL();

	}

void TOwnerCardCompare::CheckValuesL()

	{

	if ( iModifierDataPresent && iCheckerDataPresent )

		{

		TheTest( (iCheckerValue == iModifierValue) );

		ClearValues();

		}

	}

void TOwnerCardCompare::ClearValues()

	{

	iCheckerDataPresent = EFalse;

	iModifierDataPresent = EFalse;

	iCheckerValue = 0;

	iModifierValue = 0xFFFFFFFF;

	}

//

/* CConcurrentOwnerCardModifier - Specification                               */

// This class should create the db, and set the owner card.

class CConcurrentOwnerCardModifier : public CConcurrentDatabaseAccessBase

	{

	public:

		CConcurrentOwnerCardModifier(TOwnerCardCompare& aOwnerCardCompare);

		~CConcurrentOwnerCardModifier();

		static CConcurrentOwnerCardModifier* NewLC(const TDesC& aFilename, TOwnerCardCompare& aOwnerCardCompare);

		virtual void ConstructL(const TDesC& aFilename);

		static TInt ThreadFunction(TAny* aSelf);

	protected:

		TBool	RunTestImplementationL();

	private:

		void					AssignAndCompareOwnerCardIdL(TContactItemId aOwner);

	private:

		TOwnerCardCompare&		iOwnerCardCompare;

	};

//

/* CConcurrentOwnerCardModifier - Implementation                              */

CConcurrentOwnerCardModifier* CConcurrentOwnerCardModifier::NewLC(const TDesC& aFilename, TOwnerCardCompare& aOwnerCardCompare)

	{

	CConcurrentOwnerCardModifier* self = NULL;

	self = new (ELeave) CConcurrentOwnerCardModifier(aOwnerCardCompare);

	CleanupStack::PushL( self );

	self->ConstructL(aFilename);

	return self;

	}

CConcurrentOwnerCardModifier::CConcurrentOwnerCardModifier(TOwnerCardCompare& aOwnerCardCompare)

	: iOwnerCardCompare( aOwnerCardCompare )

	{

	}

CConcurrentOwnerCardModifier::~CConcurrentOwnerCardModifier()

	{

	}

TInt CConcurrentOwnerCardModifier::ThreadFunction(TAny* aSelf)

	{

	CConcurrentOwnerCardModifier* self = STATIC_CAST(CConcurrentOwnerCardModifier*, aSelf);

	// Prepare the stuff required before we start the

	// active scheduler.

	TInt error = KErrNone;

    CTrapCleanup* cleanup = CTrapCleanup::New();

	if	(!cleanup)

		return KErrNoMemory;

	// Call virtual handler which does anything that needs doing as

	// a result of the thread function from being created.

	TRAP(error, self->RunTestL());

    delete cleanup;

	return error;

	}

void CConcurrentOwnerCardModifier::ConstructL(const TDesC& aFilename)

	{

	CConcurrentDatabaseAccessBase::ConstructL(aFilename);

	iThread.Create( KThreadNameOne, CConcurrentOwnerCardModifier::ThreadFunction, KDefaultStackSize, 0x2000, 0x20000, this, EOwnerThread );

	iThread.Resume();

	iThread.SetPriority(/*EPriorityNormal*/EPriorityAbsoluteBackground);

	}

// 1. Set up

// 2. Check current owner card.

// 3. Sync

// 4. modify owner card

// 5. Sync

// 6. Check owner card

// 7. Sync

// 8. Finished.

TBool CConcurrentOwnerCardModifier::RunTestImplementationL()

	{

	TInt bit = 0;

	TContactItemId id;

	CRandomContactGenerator* generator = NULL;

	CContactItem* item = NULL;

	TBool retval = EFalse;

	switch( iStage )

		{

		case EOne_Startup:

			OpenSemaphore();

			retval = NextStage();

			SyncronizeWait(); // pause until corresponding Searcher thread is ready.

		break;

		case ETwo_FirstCheck:

			id = iDb->OwnCardId();

			AssignAndCompareOwnerCardIdL( id );

			retval = NextStage();

			SyncronizeWait();

		break;

		case EThree_ChangeOwner:

			generator = CRandomContactGenerator::NewL();

			CleanupStack::PushL( generator );

			generator->SetDbL(*iDb);

			bit |= CContactDatabase::ESmsable;

			id = generator->AddTypicalContactForFilterL(bit);

			item = iDb->ReadContactL( id );

			CleanupStack::PushL( item );

			iDb->SetOwnCardL( *item );

			CleanupStack::PopAndDestroy( item );

			item = NULL;

			CleanupStack::PopAndDestroy( generator );

			generator = NULL;

			retval = NextStage();

			SyncronizeWait(); // wait here.

		break;

		case ENOP_One:

			CallRunLAgain();

			retval = NextStage();

		break;

		case ENOP_Two:

			CallRunLAgain();

			retval = NextStage();

		break;

		case EFour_SecondCheck:

			iDb->CountL();

			id = iDb->OwnCardId();

			AssignAndCompareOwnerCardIdL( id );

			retval = NextStage();

			SyncronizeWait();

		break;

		case EFive_Cleanup:

			CloseSemaphore();

			CloseTest();

			retval = ETrue;

		break;

		default:

		break;

		}

	return retval;

	}

void CConcurrentOwnerCardModifier::AssignAndCompareOwnerCardIdL(TContactItemId aOwner)

	{

	//SyncronizeWait();

	iOwnerCardCompare.AssignValuesAndCheckL( aOwner, TOwnerCardCompare::EModifier );

	//SyncronizeWait();

	//SyncronizeWait();

	}

//

/* CConcurrentOwnerCardChecker                                               */

class CConcurrentOwnerCardChecker : public CConcurrentDatabaseAccessBase

	{

	public:

		CConcurrentOwnerCardChecker(TOwnerCardCompare& aOwnerCardCompare);

		~CConcurrentOwnerCardChecker();

		static CConcurrentOwnerCardChecker* NewLC(const TDesC& aFilename, TOwnerCardCompare& aOwnerCardCompare);

		virtual void ConstructL(const TDesC& aFilename);

		static TInt ThreadFunction(TAny* aSelf);

		static TInt FakeFunction(TAny *aParams);

	protected:

		TBool	RunTestImplementationL();

	private:

		void	AssignAndCompareOwnerCardIdL(TContactItemId aOwner);

	private:

		TOwnerCardCompare& iOwnerCardCompare;

	};