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

//

#include <e32test.h>

#include <e32base.h>

#include <e32std.h>

#include <f32file.h>

#include <s32file.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <coreappstest/testserver.h>

#include "T_UTILS.H"

_LIT(KTestName,"T_SEC_CNTDBASE");

#include "testhelpers.h"

LOCAL_C RFs fileServer;

LOCAL_C TDriveList drives;

LOCAL_C const TInt NoDrives = 2;

LOCAL_C TInt driveIdx=0;

LOCAL_C TInt NoDatabases=0;

LOCAL_C TInt NoFileOnPreviousDrive=0;

const TInt KNumTestContacts=20;

LOCAL_C TFileName KNewCntTestFile(_L("Contacts.cbrchar"));

LOCAL_C TDriveUnit driveArray[NoDrives];

LOCAL_C CContactDatabase* db;

_LIT(KNoFiles,"NoFiles");

_LIT(KContactsFilename,"Contacts.cdb");

// These defines and the Local method DrivesOfMediaTypeL should be moved to the 

// Agenda Test Library (agntestlibrary)

_LIT(KMediaNotPresent,	"MediaNotPresent");

_LIT(KMediaUnknown,		"MediaUnknown");

_LIT(KMediaFloppy,		"MediaFloppy");

_LIT(KMediaHardDisk,	"MediaHardDisk");

_LIT(KMediaCdRom,		"MediaCdRom");

_LIT(KMediaRam,			"MediaRam");

_LIT(KMediaFlash,		"MediaFlash");

_LIT(KMediaRom,			"MediaRom");

_LIT(KMediaRemote,		"MediaRemote");

_LIT(KMediaNANDFlash,	"MediaNANDFlash");

TPtrC MediaTypes[] = 

			{ KMediaNotPresent(),KMediaUnknown(),KMediaFloppy(),KMediaHardDisk(),KMediaCdRom(),

			KMediaRam(),KMediaFlash(),KMediaRom(),KMediaRemote(),KMediaNANDFlash()};

_LIT(KCdbSecure,"c:T_Sec_Cntdbase.cdb");

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

_LIT(KCdbPrivate,"c:\\private\\10003A73\\SQLite__T_Sec_Cntdbase.cdb");

#else

_LIT(KCdbPrivate,"c:\\private\\10003A73\\T_Sec_Cntdbase.cdb");

#endif

_LIT(KCntNameFormat, "NAME #%d");

_LIT(KCntNewNameFormat, "NEW NAME #%d");

LOCAL_C CArrayFix<TInt>* DrivesOfMediaTypeL( TMediaType aMedia, RFs& aFs, TBool aStopAtFirst )

	{

	TDriveInfo info;

	TInt error = KErrNone;

	TDriveList driveList;

	CArrayFix<TInt>* array = new (ELeave) CArrayFixFlat<TInt>(10);

	CleanupStack::PushL( array );

	error = aFs.DriveList(driveList);

	User::LeaveIfError(error);

	for(TInt drive=EDriveA;drive<=EDriveZ;drive++)

		{

		if( driveList[drive] )

			{

			error = aFs.Drive(info, drive);

			if	(error != KErrNone)

				{

				continue;

				}

			if	( info.iType == aMedia )

				{

				array->AppendL( drive );

				if( aStopAtFirst )

					{ // return if only the first drive of the required type.

					break;

					}

				}

			}

		}

	CleanupStack::Pop( array );

	return array;

	}

/**

	MMCDriveL

	Determines a list of drives of type EMediaHardDisk.

	The first drive in this list is returned and used

	by the rest of the test.

        NOTE: if this test is running on ARMv5, an MMC card

        must be present otherwise the test fails.

*/

LOCAL_C TDriveUnit MMCDriveL()

	{

	CArrayFix<TInt>* drives = DrivesOfMediaTypeL(EMediaHardDisk,fileServer,EFalse);

	CleanupStack::PushL(drives);

	TInt drivesTInt = drives->Count();

	if( drivesTInt )

		{

		test.Printf(_L("Found the following drives of type %S\n"),&MediaTypes[EMediaHardDisk]);

		for(TInt i=0;i<drivesTInt;i++)

			{

			TDriveUnit drv(drives->At(i));

			TPtrC drvPtr(drv.Name());

			test.Printf(_L("%S\n"),&drvPtr);

			}

		}

	else

		{

		test.Printf( _L("No drives found of type %S\n"),&MediaTypes[EMediaHardDisk]);

		User::LeaveIfError(KErrHardwareNotAvailable);

		}

	TDriveUnit mmcDrive(drives->At(0));

	CleanupStack::PopAndDestroy(drives);

	// Use the first drive in the list for the rest of the test.

	return mmcDrive;

	}

/**

	AddNewContactsL

	Add KNumTestContacts new contacts with varying numbres of text fields

	@param aIdList

*/

LOCAL_C void AddNewContactsL(CArrayFix<TContactItemId>* aIdList)

	{

	CContactCard* card=CContactCard::NewL();

	CleanupStack::PushL(card);

	TContactItemId id=KNullContactId;

	TContactItemId newId=KNullContactId;

	for (TInt ii=0;ii<KNumTestContacts;ii++)

		{

		TBuf<16> name;

		name.Format(KCntNameFormat, ii);

		SetNameL(*card,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,name,EFalse);

		CContactItemField* field=CContactItemField::NewLC(KStorageTypeText);

		card->AddFieldL(*field);

		CleanupStack::Pop(); // field

		newId=db->AddNewContactL(*card);

		id=newId;

		aIdList->AppendL(id);

		}

	CleanupStack::PopAndDestroy(); // card

	}

LOCAL_C TPtrC Name(CContactItem& aItem)

	{

	CContactItemFieldSet& fieldSet=aItem.CardFields();

	const TInt pos=fieldSet.Find(KUidContactFieldFamilyName);

	if (pos==KErrNotFound)

		return _L("");

	return fieldSet[pos].TextStorage()->Text();

	}

/**

	EditContactsL

	Check then edit contact names

	@param aIdList

*/

LOCAL_C void EditContactsL(CArrayFix<TContactItemId>* aIdList)

	{

	TInt ii=0;

	test.Next(_L("Change all contact names"));

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

	for (;ii<aIdList->Count();++ii)

#else		

	for (;ii<KNumTestContacts;ii++)

#endif

		{

		const TInt index=(*aIdList)[ii];

		// exercise OpenContactLX api, Commit the change and Pop the lock record

		CContactItem* item=db->OpenContactLX(index);

		CleanupStack::PushL(item);

		TBuf<16> name;

		name.Format(KCntNameFormat, ii); // "NAME %d"

		test(name==Name(*item));

		name.Format(KCntNewNameFormat, index);	// "NEW NAME %d"

		SetNameL(*item,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,name,EFalse);

		db->CommitContactL(*item);

		CleanupStack::PopAndDestroy(); // item;

		CleanupStack::Pop(); // lock record

		}

	test.Next(_L("Check new contact names"));

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

	for (;ii<aIdList->Count();++ii)

#else

	for (ii=0;ii<KNumTestContacts;ii++)

#endif

		{

		const TInt index=(*aIdList)[ii];

		CContactItem* item=db->ReadContactL(index);

		TBuf<16> name;

		name.Format(KCntNewNameFormat, index);

		test(name==Name(*item));

		delete item;

		}

	test.Next(_L("Regression test for Contact locking/unlocking (DEF067162)"));

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

	for (;ii<aIdList->Count();++ii)

#else	

	for (ii = 0; ii < KNumTestContacts; ii++)

#endif

		{

		// open 2 different items

		const TInt index1 = (*aIdList)[ii];

		const TInt index2 = (*aIdList)[(ii + 1) % KNumTestContacts];

		CContactItem* item1 = db->OpenContactLX(index1);

		CleanupStack::PushL(item1);

		CContactItem* item2 = db->OpenContactLX(index2);

		delete item2;

		CleanupStack::PopAndDestroy(); // destroy lock = close item2

		CleanupStack::PopAndDestroy(item1);

		CleanupStack::PopAndDestroy(); // destroy lock = close item1

		// re-open 1st item - should not be locked

		// OpenContactLX() and PopAndDestroy()

		item1 = db->OpenContactLX(index1);

		delete item1;

		CleanupStack::PopAndDestroy(); // destroy lock = close item1

		// re-open 2nd item - should not be locked

		// OpenContactL() and CloseContactL()

		item2 = db->OpenContactL(index2);

		CleanupStack::PushL(item2);

		db->CloseContactL(index2);				// explicitly close item 2

		CleanupStack::PopAndDestroy(item2);

		}

	// try to read a non-existant contact

	TRAPD(err,db->ReadContactL(KNullContactId));

	TESTTRUEL(err!=KErrNone);

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

	if(aIdList->Count() > 0)

		{

#endif		

	// try to edit a contact that hasn't been opened

	CContactItem* item=db->ReadContactLC((*aIdList)[0]);

	TRAP(err,db->CommitContactL(*item));

	CleanupStack::PopAndDestroy(); // item

	TESTTRUEL(err==KErrAccessDenied);

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

		}

#endif			

	// try to close a non-existant contact

	TRAP(err,db->CloseContactL(KNullContactId));

	TESTTRUEL(err==KErrNone); // test changed from 001 (using DBMS 043) - this test makes more sense anyway

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

	if(aIdList->Count() > 0)

		{

#endif			

	// try to close a contact that hasn't been opened

	TRAP(err,db->CloseContactL((*aIdList)[0]));

	TESTTRUEL(err==KErrNone);

#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__

		}

#endif			

	}

/**

	Gets the list of installed drives and then stores the first 2

	in the array drives for use within the test. The second entry

	in this array should use method MMCDriveL as used in T_Sec_Tidy

	and T_Sec_ListAgendaFile.

*/

LOCAL_C void DrivesL()

	{

	driveArray[0] = EDriveC;

	driveArray[1] = MMCDriveL();

	// Tell the user which drive has been chosen. 

	TPtrC drv( driveArray[1].Name() );

	test.Printf(_L("%S chosen for the test.\n"),&drv);

	}

/**

	Ensure that the filename conforms to the correct form.

	The analysis functionality is dependent on the flags:

	SYMBIAN_SECURE_DBMS. Unlike Agenda, in contacts as GetDefaultNameL

	existed before platsec there is legacy functionality that must

	maintained. In not SYMBIAN_SECURE_DBMS the full path must be checked

	for. The default filename exits on the current drive.

	@param reference to the default file name.

	@return ETrue if the default filename is correctly formed.

*/

LOCAL_C TBool CheckDefaultContactsFilename( TFileName& aFilename )

	{

	_LIT(KDriveFailure, "Incorrect Drive Specified" );

	_LIT(KPathFailure, "Incorrect No Path expected" );

	_LIT(KFilenameFailure, "Incorrect Filename" );

	TDriveUnit lDriveUnit;

	// Get the current drive.

	CContactDatabase::DatabaseDrive(lDriveUnit);

	TParse filename;

	filename.Set( aFilename, NULL, NULL);

	// Check that the drive letter exists. No drive is an error 

	// in both modes.

	if( filename.Drive() != lDriveUnit.Name())

		{

		test.Printf(KDriveFailure);

		return EFalse;

		}

	if( filename.Path().Length())

		{

		test.Printf(KPathFailure);

		return EFalse;

		}

	if( filename.NameAndExt().CompareF(KContactsFilename()))

		{

		test.Printf(KFilenameFailure);

		return EFalse;

		}

	return ETrue;

	}

/** 

	CheckNotDefaultContactsFiles

	Uses all the default database related API's to ensure that

	they all return negative, now that the default db has been

	removed.

	@return ETrue if a default database cannot be found on the

	default drive.

*/

LOCAL_C TBool CheckNotDefaultContactsFiles()

	{

	// The default database on the current default drive.(3)

	// The default database on the specific drive. (4)

	TBool response = EFalse;

	TRAPD(err, response = CContactDatabase::DefaultContactDatabaseExistsL());

	if( !(err == KErrNone && !response ))

		{

		return EFalse;

		}

	// Use the default database, as we have confirmed previously

	// this shouldn't exits. This is dependent upon the Security mode.

	TFileName filename;

	filename.Copy(driveArray[driveIdx].Name());

	filename.Append(KContactsFilename);

	// (5)

	TRAP(err, response = CContactDatabase::ContactDatabaseExistsL(filename));

	if( !(err == KErrNone && !response ))

		{

		return EFalse;

		}

	// None of the API return true, no default Contact DB files were detected. 

	return ETrue;

	}

/**

	CheckCntFilesL

	Ensure that cntFiles contains the list of correct files.

	The analysis functionality is dependent on the flags:

	_SECURE_DATA_ and _UNSECURE_DATA_

	Determines the list of agn files, checks for the existance of aFilename

	within the list of aNum names.

	@param aNum number of expected files. 

	@param aFilename a reference to an expected filename.

	@return aFileExpectedToExist ETrue if the list contains the expected files.

*/

LOCAL_C TBool CheckCntFilesL( TInt aNum,  const TDesC& aFilename , TBool aFileExpectedToExist = ETrue)

	{

	// Data bases on all drives.

	CDesCArray* cntFiles = CContactDatabase::ListDatabasesL();

	CleanupStack::PushL(cntFiles);

	// Data bases on the specified drive.

	CDesCArray* cntFilesFromDrive = CContactDatabase::ListDatabasesL(driveArray[driveIdx]);

	CleanupStack::PushL(cntFilesFromDrive);

	TInt DriveZCount=0;

	// Determine files on drive Z:

	if( !cntFiles->Count() && !cntFilesFromDrive->Count() && !aNum )

		{

		CleanupStack::PopAndDestroy( cntFilesFromDrive );

		CleanupStack::PopAndDestroy( cntFiles );								

		return !aFileExpectedToExist;

		}

	// Ensure that all drive contents add up.

	if( cntFiles->Count() != NoFileOnPreviousDrive + DriveZCount + cntFilesFromDrive->Count() )

		{

		CleanupStack::PopAndDestroy(cntFilesFromDrive);

		CleanupStack::PopAndDestroy(cntFiles);

		return !aFileExpectedToExist;

		}

	TFileName filename;

	// In un-secure mode if aFilename contains no path, then

	// a backslash must be included between the drive and the

	// filename. This because when asked to create filename 

	// "c:filename" ListDatabasesL returns the name "c:\filename"

	// hence a backslash is inserted for comparison purposes.

	TParse file;

	file.Set(aFilename,NULL,NULL);

	filename.Copy(aFilename);	

	// Check that aFilename is in the list.

	TBool retValue = ETrue;

	if (!aFileExpectedToExist)

		{

		// File is not expected to exist. So return EFalse if we find it.

		for(TInt i=0;i<cntFilesFromDrive->Count();i++)

			{

			TFileName driveList_1 = (*cntFilesFromDrive)[i];

			if(!driveList_1.CompareF(filename))

				{

				CleanupStack::PopAndDestroy(cntFilesFromDrive);

				CleanupStack::PopAndDestroy(cntFiles);

				return !retValue;

				}

			}

		retValue = EFalse;

		}

	else

		{

		// File is expected to exist. We should find it in both lists.

		// return EFalse if not found in this list.

		TBool fileFound = EFalse;

		// does file exist in list from drive

		for(TInt j=0;j<cntFilesFromDrive->Count();j++)

			{

			TFileName driveList_2 = (*cntFilesFromDrive)[j];

			if(!driveList_2.CompareF(filename))

				{

				fileFound = ETrue;

				break;

				}

			}

		if(!fileFound)

			{

			CleanupStack::PopAndDestroy(cntFilesFromDrive);

			CleanupStack::PopAndDestroy(cntFiles);

			return !retValue;

			}

		}

	// We found the file in cntFilesFromDrive 

	// Does file exist in list from all drives

	for(TInt k=0;k<cntFiles->Count();k++)

		{

		TFileName driveList_3 = (*cntFiles)[k];

		if(!driveList_3.CompareF(filename))

			{

			CleanupStack::PopAndDestroy(cntFilesFromDrive);

			CleanupStack::PopAndDestroy(cntFiles);

			return retValue;

			}

		}	

	CleanupStack::PopAndDestroy(cntFilesFromDrive);

	CleanupStack::PopAndDestroy(cntFiles);

	// File was not found so return false.

	return !retValue;

	}

/**

	This API uses all the Contacts API's relating to identification

	of the default file.

*/

LOCAL_C TBool DefaultDatabaseL()

	{

		// The default database on the current default drive.

	if(!CContactDatabase::DefaultContactDatabaseExistsL())

		return EFalse;

	// Use the default database, as we have confirmed previously

	// this shouldn't exits. This is dependent upon the Security mode.

	TFileName filename;

	filename.Copy(driveArray[driveIdx].Name());

	filename.Append(KContactsFilename);

	if(!CContactDatabase::ContactDatabaseExistsL(filename))

		return EFalse;

	// None of the API return true, no files were detected.

	return ETrue;

	}

/**

	This function uses Five API's available to determine the existance

	of database files. These are (1)ListDatabasesL(),(2)ListDatabasesL(TDriveUnit&)

	(3)DefaultContactDatabaseExistsL(),(4)DefaultContactDatabaseExistsL(TDriveUnit&)

	and (5)ContactDatabaseExistsL(const TDesC&). All five should confirm that there

	are no contacts database files.

*/

LOCAL_C TBool CheckNoDatabaseFilesL()

	{

	TFileName filename;

	TBool retVal = EFalse;

	filename.Copy(driveArray[driveIdx].Name());