diff -r 000000000000 -r e686773b3f54 phonebookengines/contactsmodel/tsrc/Integration/CntPerfTest/src/PrepareDataTestStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phonebookengines/contactsmodel/tsrc/Integration/CntPerfTest/src/PrepareDataTestStep.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,553 @@ +// Copyright (c) 2007-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 "PrepareDataTestStep.h" + +/** + * Constructor + */ +CPrepareDataTestStep::CPrepareDataTestStep() + { + // Mandatory call to base class method to set up the human readable name for logging. + SetTestStepName(KPrepareDataTestStep); + } + +/** + * Destructor + */ +CPrepareDataTestStep::~CPrepareDataTestStep() + { + iListOfContactItemsInDatabase.Close(); + } + +/** + * Setup the environment required for test, install schedular in the current thread + * Opens the relevant contacts database file + */ +TVerdict CPrepareDataTestStep::doTestStepPreambleL() + { + CTestContactViewDatabaseUtilitiesStep::doTestStepPreambleL(); + return TestStepResult(); + } + +/** + * Cleanup function for the test step + */ +TVerdict CPrepareDataTestStep::doTestStepPostambleL() + { + CTestContactViewDatabaseUtilitiesStep::doTestStepPostambleL(); + return TestStepResult(); + } + + +/** +Base class pure virtual. +* @return EPass or EFail indicating the result of the test step. +*/ +TVerdict CPrepareDataTestStep::doTestStepL() + { + ImportContactsL(); + AddContactsInDatabaseL(); + IterateThroAllSortOrderSectionsAndUpdateContactsInDatabaseL(); + IterateThroAllFilterViewsSectionsAndUpdateL(); + IterateThroAllMatchingStringSectionsAndUpdateL(); + AddGroupsInDatabaseL(); + IterateThroAllGroupSectionsAndUpdateL(); + UpdateContactToSpecificStringL(); + CloseDatabaseL(); + CopyDatabaseL(); + return TestStepResult(); + } + +/** +* Import Contact entries +*/ +void CPrepareDataTestStep::ImportContactsL() + { + ViewUtilityReference().ImportContactsL(); + } + +/** + * Here we are trying add blank contact items in the database + * Say some 2000 thousand contacts are added to the database + */ +void CPrepareDataTestStep::AddContactsInDatabaseL() + { + _LIT(KNumOfContacts, "numofcontacts"); + TInt numOfContacts = 0; + GetIntFromConfig(ConfigSection(), KNumOfContacts, numOfContacts); + + for(TInt i = 0; i < numOfContacts; ++i) + { + CContactCard* contactCard = CContactCard::NewL(); + CleanupStack::PushL(contactCard); + TContactItemId contactId = DatabaseReference().AddNewContactL(*contactCard); + CleanupStack::PopAndDestroy(contactCard); + iListOfContactItemsInDatabase.AppendL(contactId); + DatabaseReference().CloseContactL(contactId); + } + + TInt count = DatabaseReference().CountL(); + _LIT(KDatabaseCount, "Total number of contact entries is %d :"); + INFO_PRINTF2(KDatabaseCount, count); + } + + +/* As mentioned earlier there will be some 1000 blank contacts in the database + * Now any view will have it's own criteria like + * -- view sort order i.e. the order in which the contact items in the view must be sorted + * -- view preferences i.e. whether only contact cards or contact groups or both must be included in the view + * whether the unsorted contacts must be included in the view or not, if included, whether they must be included in the + * start of view or end of view + * It becomes necessary to supply the necessary envirnoment that meets the view criteia + * Each view can supply its desired criteria. Based on this, the contacts in the database will be updated to meet the view specificattions + */ +void CPrepareDataTestStep::IterateThroAllSortOrderSectionsAndUpdateContactsInDatabaseL() + { + _LIT(KListOfSortOrderSections, "listofsortorder"); + TPtrC listOfSortOrderSectionsString; + GetStringFromConfig(ConfigSection(), KListOfSortOrderSections, listOfSortOrderSectionsString); + + RArray listOfSortOrderSections; + CleanupClosePushL(listOfSortOrderSections); + + ViewUtilityReference().TokenizeStringL(listOfSortOrderSectionsString, listOfSortOrderSections); + + for ( TInt i = 0; i < listOfSortOrderSections.Count(); ++i ) + { + UpdateContactFieldsSpecificToSortOrderL(listOfSortOrderSections[i]); + } + + CleanupStack::PopAndDestroy(&listOfSortOrderSections); + } + +/** + * Here we are trying add contacts fields in the existing contacts such that they meet the contact views + * Sort Order. Intentionally some of the contacts are updated with the contact fields of Null data to meet + * the unsorted contacts criteria + */ +void CPrepareDataTestStep::UpdateContactFieldsSpecificToSortOrderL(const TPtrC& aSortOrderSection) + { + // Based on the sort order, the desired number of contacts will be updated i.e contact fields will be + // added to the contacts in the database. The new fields added will be as per the sort order + // at the end of this operation, if we constuct a contact view with this sort order + // then the desired number of contacts will be included in the view + + _LIT(KViewSortOrder, "sortorder"); + TPtrC viewSortOrderString; + GetStringFromConfig(aSortOrderSection, KViewSortOrder, viewSortOrderString); + + RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString) ; + CleanupClosePushL(sortOrder); + + _LIT(KNumOfSortableContacts, "numofsortablecontacts"); + TInt numOfSortableContacts; + GetIntFromConfig(aSortOrderSection, KNumOfSortableContacts, numOfSortableContacts); + + // Here we are trying to update the desired number of contacts in the database + // with Null contact fields in order to meet the unsortable contacts requirement + + _LIT(KNumUnSortableContacts, "numunsortedcontacts"); + TInt numUnSortableContacts; + GetIntFromConfig(aSortOrderSection, KNumUnSortableContacts, numUnSortableContacts); + + const TInt KTotalNumOfContactsSpecificToThisSortOrder = numOfSortableContacts + numUnSortableContacts; + + TInt numberOfReadySortableContacts = 0; + TInt numberOfReadyUnSortableContacts = 0; + + // There may be contact items in the database that meet the sort order + // We need be sure about the contact items that we should update + + RArray ListOfContactItemsThatCanUpdatedToMeetSortOrder; + CleanupClosePushL(ListOfContactItemsThatCanUpdatedToMeetSortOrder); + + + for(TInt i = 0; i < iListOfContactItemsInDatabase.Count(); ++i) + { + TContactItemId desiredContactItemId = iListOfContactItemsInDatabase[i]; + CContactItem* contact = DatabaseReference().OpenContactL(desiredContactItemId); + CleanupStack::PushL(contact); + CContactItemFieldSet& fieldSet = contact->CardFields(); + + TInt firstContactFieldPosition = fieldSet.Find(sortOrder[0]); + TInt secondContactFieldPosition = fieldSet.Find(sortOrder[1]); + TInt thirdContactFieldPosition = fieldSet.Find(sortOrder[2]); + + if ((firstContactFieldPosition != KErrNotFound) && (secondContactFieldPosition != KErrNotFound) && (thirdContactFieldPosition!= KErrNotFound)) + { + CContactItemField& firstContactItemField = fieldSet[firstContactFieldPosition]; + CContactItemField& secondContactItemField = fieldSet[secondContactFieldPosition]; + CContactItemField& thirdContactItemField = fieldSet[thirdContactFieldPosition]; + + if((firstContactItemField.Storage() == NULL) && (secondContactItemField.Storage() == NULL) && (thirdContactItemField.Storage() == NULL)) + { + ++numberOfReadyUnSortableContacts; + } + else + { + ++numberOfReadySortableContacts; + } + } + else + { + ListOfContactItemsThatCanUpdatedToMeetSortOrder.AppendL(desiredContactItemId); + } + + CleanupStack::PopAndDestroy(contact); + DatabaseReference().CloseContactL(desiredContactItemId); + } + + if((numberOfReadyUnSortableContacts + numberOfReadySortableContacts) < KTotalNumOfContactsSpecificToThisSortOrder) + { + TInt j = 0; + for(; j < (numOfSortableContacts-numberOfReadySortableContacts); ++j) + { + TContactItemId contactItemIdToBeUpdated = ListOfContactItemsThatCanUpdatedToMeetSortOrder[j]; + CContactItem* contact = DatabaseReference().OpenContactL(contactItemIdToBeUpdated); + CleanupStack::PushL(contact); + AddContactFieldL(*contact, sortOrder, ETrue); + DatabaseReference().CommitContactL(*contact); + DatabaseReference().CloseContactL(contactItemIdToBeUpdated); + CleanupStack::PopAndDestroy(contact); + } + + for(TInt k = j; k < (j + (numUnSortableContacts-numberOfReadyUnSortableContacts)); ++k) + { + TContactItemId contactItemIdToBeUpdated = ListOfContactItemsThatCanUpdatedToMeetSortOrder[k]; + CContactItem* contact = DatabaseReference().OpenContactL(contactItemIdToBeUpdated); + CleanupStack::PushL(contact); + AddContactFieldL(*contact, sortOrder); + DatabaseReference().CommitContactL(*contact); + DatabaseReference().CloseContactL(contactItemIdToBeUpdated); + CleanupStack::PopAndDestroy(contact); + } + } + + CleanupStack::PopAndDestroy(2,&sortOrder); + } + +/** Adds contact fields specific to sort order, + * Sort Order. Intentionally some of the contacts are updated with the contact fields of Null data to meet + * the unsorted contacts criteria + */ +void CPrepareDataTestStep::AddContactFieldL(CContactItem& aContact, const RContactViewSortOrder& aSortOrder, + TBool aDataRequired) + { + const TInt KMaxSortOrderCount = 3; + for(TInt i = 0; i < KMaxSortOrderCount; ++i) + { + TFieldType fieldType = aSortOrder[i]; + TStorageType storageType = GetStorageType(fieldType); + CContentType* contentType = CContentType::NewL(); + CleanupStack::PushL(contentType); + contentType->AddFieldTypeL(fieldType); + CContactItemField* field = CContactItemField::NewL(storageType, *contentType); + CleanupStack::PushL(field); + + if(aDataRequired) + { + SetDataL(fieldType, *field); + } + + aContact.AddFieldL(*field); + CleanupStack::Pop(field); + CleanupStack::PopAndDestroy(contentType); + } + } + +/** + * Reads all the sections in the ini file relevant for updating the contacts database + * in order to meet filter view requirements + */ +void CPrepareDataTestStep::IterateThroAllFilterViewsSectionsAndUpdateL() + { + _LIT(KListOfFilterViewSectionsString, "listoffilterviewsections"); + TPtrC listOfFilterViewSectionsString; + GetStringFromConfig(ConfigSection(), KListOfFilterViewSectionsString, listOfFilterViewSectionsString); + + RArray listOfFilterViewSections; + CleanupClosePushL(listOfFilterViewSections); + ViewUtilityReference().TokenizeStringL(listOfFilterViewSectionsString, listOfFilterViewSections); + + for(TInt i = 0; i < listOfFilterViewSections.Count(); ++i) + { + UpdateContactsInDatabaseAsPerFilteredViewRequirementsL(listOfFilterViewSections[i]); + } + + CleanupStack::PopAndDestroy(&listOfFilterViewSections); + } + +/** + * Updates contacts in database as per filter view requirements specified in the ini section + */ +void CPrepareDataTestStep::UpdateContactsInDatabaseAsPerFilteredViewRequirementsL(const TPtrC& aFilteredViewSection) + { + _LIT(KViewSortOrder, "sortorder"); + TPtrC viewSortOrderString; + GetStringFromConfig(aFilteredViewSection, KViewSortOrder, viewSortOrderString); + + RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString); + CleanupClosePushL(sortOrder); + + _LIT(KNumOfContactsWithFilter, "numofcontactswiththisfilter"); + TInt numOfContactsWithFilter; + GetIntFromConfig(aFilteredViewSection, KNumOfContactsWithFilter, numOfContactsWithFilter); + + _LIT(KDesiredFilterString, "desiredFilter"); + TPtrC desiredFilterString; + GetStringFromConfig(aFilteredViewSection, KDesiredFilterString, desiredFilterString); + + CContactDatabase::TContactViewFilter viewFilter = ViewUtilityReference().GetContactViewFilterL(desiredFilterString); + + RArray contactSpecificToSortOrder; + CleanupClosePushL(contactSpecificToSortOrder); + + RetrieveContactsSpecificToSortOrderL(sortOrder, contactSpecificToSortOrder); + + for(TInt i = 0; i < numOfContactsWithFilter; ++i) + { + TContactItemId id = contactSpecificToSortOrder[i]; + CContactItem* contactItem = DatabaseReference().OpenContactL(id); + CleanupStack::PushL(contactItem); + AddFilterBasedFieldsL(*contactItem, viewFilter); + DatabaseReference().CommitContactL(*contactItem); + DatabaseReference().CloseContactL(id); + CleanupStack::PopAndDestroy(contactItem); + } + + CleanupStack::PopAndDestroy(2, &sortOrder); + } + + +/** + * Retrieves contacts specific to desired sort order from the database + */ +void CPrepareDataTestStep::RetrieveContactsSpecificToSortOrderL(const RContactViewSortOrder& aSortOrder, RArray& aContactSpecificToSorder) + { + for(TInt i = 0; i < iListOfContactItemsInDatabase.Count(); ++i) + { + TContactItemId contactId = iListOfContactItemsInDatabase[i]; + CContactItem* contactItem = DatabaseReference().OpenContactL(contactId); + CleanupStack::PushL(contactItem); + TBool exists = CheckAllTheFieldsExists(*contactItem, aSortOrder); + if(exists) + { + aContactSpecificToSorder.AppendL(contactId); + } + DatabaseReference().CloseContactL(contactId); + CleanupStack::PopAndDestroy(contactItem); + } + + } + +/** + * Checks whether all the three desired contact fields are present in the contact or not + */ +TBool CPrepareDataTestStep::CheckAllTheFieldsExists(const CContactItem& aContact, const RContactViewSortOrder& aSortOrder) + { + CContactItemFieldSet& fieldSet = aContact.CardFields(); + + TInt firstContactFieldPosition = fieldSet.Find(aSortOrder[0]); + TInt secondContactFieldPosition = fieldSet.Find(aSortOrder[1]); + TInt thirdContactFieldPosition = fieldSet.Find(aSortOrder[2]); + + TInt error = KErrNotFound; + + if ((firstContactFieldPosition != error) && (secondContactFieldPosition != error) && (thirdContactFieldPosition!= error)) + { + return ETrue; + } + else + { + return EFalse; + } + } + + +/** + * Data is read from the ini file about the matching strings expected to be present in some of the + * contact fields and desired number of contacts in the database are updated with this matching string info + */ +void CPrepareDataTestStep::IterateThroAllMatchingStringSectionsAndUpdateL() + { + _LIT(KListOfMatchingStringSectionsString, "listofMatchingString"); + TPtrC listOfMatchingStringSectionsString; + GetStringFromConfig(ConfigSection(), KListOfMatchingStringSectionsString, listOfMatchingStringSectionsString); + + RArray listOfMatchingStringSections; + CleanupClosePushL(listOfMatchingStringSections); + ViewUtilityReference().TokenizeStringL(listOfMatchingStringSectionsString, listOfMatchingStringSections); + + for(TInt i = 0; i < listOfMatchingStringSections.Count(); ++i) + { + UpdateContactsInDatabaseAsPerMatchingStringsL(listOfMatchingStringSections[i]); + } + + CleanupStack::PopAndDestroy(&listOfMatchingStringSections); + } + +/** + * Updates the contacts in the database based on the data available in the ini section + * @param aMatchingStringSection - Relevant section in the ini file + */ +void CPrepareDataTestStep::UpdateContactsInDatabaseAsPerMatchingStringsL(const TPtrC& aMatchingStringSection) + { + _LIT(KViewSortOrder, "sortorder"); + TPtrC viewSortOrderString; + GetStringFromConfig(aMatchingStringSection, KViewSortOrder, viewSortOrderString); + + RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString); + CleanupClosePushL(sortOrder); + + + _LIT(KNumOfContactsWithFilter, "numofcontactswiththisstring"); + TInt numOfContactsWithThisString; + GetIntFromConfig(aMatchingStringSection, KNumOfContactsWithFilter, numOfContactsWithThisString); + + _LIT(KDesiredMatchingString, "matchingstring"); + TPtrC desiredMatchingString; + GetStringFromConfig(aMatchingStringSection, KDesiredMatchingString, desiredMatchingString); + + _LIT(KDesiredContactField, "contactfield"); + TPtrC desiredContactField; + GetStringFromConfig(aMatchingStringSection, KDesiredContactField, desiredContactField); + + TUid uidInfo = GetContactFieldType(desiredContactField); + + RArray contactSpecificToSortOrder; + CleanupClosePushL(contactSpecificToSortOrder); + + RetrieveContactsSpecificToSortOrderL(sortOrder, contactSpecificToSortOrder); + + for(TInt i = 0; (i < (contactSpecificToSortOrder.Count()) && (i < numOfContactsWithThisString)); ++i) + { + TContactItemId id = contactSpecificToSortOrder[i]; + CContactItem* contactItem = DatabaseReference().OpenContactL(id); + CleanupStack::PushL(contactItem); // contactItem + AddMatchingStringToContactL(*contactItem, uidInfo, desiredMatchingString); + DatabaseReference().CommitContactL(*contactItem); + DatabaseReference().CloseContactL(id); + CleanupStack::PopAndDestroy(contactItem); + } + + CleanupStack::PopAndDestroy(2, &sortOrder); + + } + +/** + * Update contacts in database with desired string + * This feature is useful while constructing Find Views, Sub Views etc.. + * @param aContact - Contact to be updated + * @param aUid - uid of field in the contact item to be updated + * @param aDesiredMatchingString - Matching string + */ +void CPrepareDataTestStep::AddMatchingStringToContactL(CContactItem& aContact, TUid aUid, const TPtrC& aDesiredMatchingString) + { + CContactItemFieldSet& fieldSet = aContact.CardFields(); + TInt pos = fieldSet.Find(aUid); + if(pos == KErrNotFound) + { + TFieldType fieldType = aUid; + TStorageType storageType = GetStorageType(fieldType); + CContentType* contentType = CContentType::NewL(); + contentType->AddFieldTypeL(fieldType); + CContactItemField* field = CContactItemField::NewL(storageType, *contentType); + CleanupStack::PushL(field); + field->TextStorage()->SetTextL(aDesiredMatchingString); + aContact.AddFieldL(*field); + CleanupStack::Pop(); // field + } + else + { + CContactItemField& field = fieldSet[pos]; + field.TextStorage()->SetTextL(aDesiredMatchingString); + } + } + +void CPrepareDataTestStep::UpdateContactToSpecificStringL() + { + _LIT(KListOfSetDesiredStringSections, "listofcontacttoupdate"); + TPtrC listOfSections; + GetStringFromConfig(ConfigSection(), KListOfSetDesiredStringSections, listOfSections); + + RArray listOfUpdateContact; + CleanupClosePushL(listOfUpdateContact); + + ViewUtilityReference().TokenizeStringL(listOfSections, listOfUpdateContact); + + for ( TInt i = 0; i < listOfUpdateContact.Count(); ++i ) + { + UpdateContactFieldsToDesireStingL(listOfUpdateContact[i]); + } + + CleanupStack::PopAndDestroy(&listOfUpdateContact); + + } + +void CPrepareDataTestStep::UpdateContactFieldsToDesireStingL(const TPtrC& aMatchingStringSection) + { + _LIT(KViewSortOrder, "sortorder"); + _LIT(KContactId, "contactid"); + _LIT(KDesiredString, "desiredstring"); + + TPtrC viewSortOrderString; + GetStringFromConfig(aMatchingStringSection, KViewSortOrder, viewSortOrderString); + + RContactViewSortOrder sortOrder = ViewUtilityReference().ConvertStringToSortOrderL(viewSortOrderString) ; + CleanupClosePushL(sortOrder); + + TInt contactId; + GetIntFromConfig(aMatchingStringSection, KContactId, contactId); + + TPtrC desiredSting; + GetStringFromConfig(aMatchingStringSection, KDesiredString, desiredSting); + + RArray contactSpecificToSortOrder; + CleanupClosePushL(contactSpecificToSortOrder); + + RetrieveContactsSpecificToSortOrderL(sortOrder, contactSpecificToSortOrder); + CContactItem* contactItem = DatabaseReference().OpenContactL(contactId); + CleanupStack::PushL(contactItem); + + CContactItemFieldSet& fieldSet = contactItem->CardFields(); + + TInt firstContactFieldPosition = fieldSet.Find(sortOrder[0]); + TInt secondContactFieldPosition = fieldSet.Find(sortOrder[1]); + TInt thirdContactFieldPosition = fieldSet.Find(sortOrder[2]); + + // Check whether they have content. + CContactItemField& field1 = fieldSet[firstContactFieldPosition]; + CContactFieldStorage* firstStorage = field1.Storage(); + + CContactItemField& field2 = fieldSet[secondContactFieldPosition]; + CContactFieldStorage* secondStorage = field2.Storage(); + + CContactItemField& field3 = fieldSet[thirdContactFieldPosition]; + CContactFieldStorage* thirdStorage = field3.Storage(); + + field1.TextStorage()->SetTextL(desiredSting); + field2.TextStorage()->SetTextL(desiredSting); + field3.TextStorage()->SetTextL(desiredSting); + + DatabaseReference().CommitContactL(*contactItem); + DatabaseReference().CloseContactL(contactId); + + CleanupStack::PopAndDestroy(contactItem); + CleanupStack::PopAndDestroy(&contactSpecificToSortOrder); + CleanupStack::PopAndDestroy(&sortOrder); + } + +